当前位置: 首页>>代码示例 >>用法及示例精选 >>正文

Java StringBuffer用法及代码示例


StringBuffer 是 Java 中的一个类，表示可变的字符序列。它提供了不可变 String 类的替代方案，允许您修改字符串的内容，而无需每次都创建新对象。

以下是 StringBuffer 类的一些重要函数和方法：

  1. StringBuffer 对象是可变的，这意味着您可以更改缓冲区的内容而无需创建新对象。
  2. StringBuffer的初始容量可以在创建时指定，也可以稍后使用ensureCapacity()方法设置。
  3. append() 方法用于将字符、字符串或其他对象添加到缓冲区末尾。
  4. insert()方法用于在缓冲区中的指定位置插入字符、字符串或其他对象。
  5. delete() 方法用于从缓冲区中删除字符。
  6. reverse()方法用于反转缓冲区中字符的顺序。

以下是使用 StringBuffer 连接字符串的示例：

Java 


public class StringBufferExample {
    public static void main(String[] args)
    {
        StringBuffer sb = new StringBuffer();
        sb.append("Hello");
        sb.append(" ");
        sb.append("world");
        String message = sb.toString();
        System.out.println(message);
    }
}
输出 
Hello world

与 Java 中的常规 String 对象相比，使用 StringBuffer 有几个优点：

  1. 可变：StringBuffer对象是可变的，这意味着您可以在创建对象后修改其内容。相比之下，字符串对象是不可变的，这意味着字符串一旦创建就无法更改其内容。
  2. 高效：因为 StringBuffer 对象是可变的，所以它们比每次需要修改字符串时创建新的 String 对象更高效。如果您需要多次修改字符串，则尤其如此，因为对 String 对象的每次修改都会创建一个新对象并丢弃旧对象。
  3. 线程安全：StringBuffer对象是线程安全的，这意味着多个线程可以同时访问它(它们可以被多个线程同时安全地访问和修改)。相比之下，String 对象不是线程安全的，这意味着如果要从多个线程访问 String 对象，则需要使用同步。

总的来说，如果需要对字符串进行多次修改，或者需要从多个线程访问字符串，使用 StringBuffer 比使用常规 String 对象更高效、更安全。

StringBuffer是一个同级类 String 它提供了字符串的许多函数。字符串表示固定长度、不可变的字符序列，而StringBuffer表示可增长且可写的字符序列。StringBuffer可以在中间插入或附加到末尾的字符和子字符串。它会自动增长，为此类添加腾出空间，并且通常会预先分配比实际需要更多的字符，以留出增长空间。

StringBuffer 类用于创建可变(可修改)字符串。 Java 中的 StringBuffer 类与 String 类相同，只是它是可变的，即可以更改。

StringBuffer 类的重要构造函数

  • StringBuffer()：创建一个空字符串缓冲区，初始容量为16。
  • StringBuffer(String str)：用指定的字符串创建一个字符串缓冲区。
  • StringBuffer(intcapacity)：创建一个空字符串缓冲区，以指定容量为长度。

1.append()方法

append() 方法将给定参数与该字符串连接起来。

例子：

Java 


import java.io.*;
class A {
    public static void main(String args[])
    {
        StringBuffer sb = new StringBuffer("Hello ");
        sb.append("Java"); // now original string is changed
        System.out.println(sb);
    }
}
输出 
Hello Java

2.insert()方法

insert() 方法将给定字符串插入到给定位置。

例子：

Java 


import java.io.*;
class A {
    public static void main(String args[])
    {
        StringBuffer sb = new StringBuffer("Hello ");
        sb.insert(1, "Java");
        // Now original string is changed
        System.out.println(sb);
    }
}
输出 
HJavaello

3.replace()方法

replace() 方法替换指定的 beginIndex 和 endIndex-1 中的给定字符串。

例子：

Java 


import java.io.*;
class A {
    public static void main(String args[])
    {
        StringBuffer sb = new StringBuffer("Hello");
        sb.replace(1, 3, "Java");
        System.out.println(sb);
    }
}
输出 
HJavalo

4.delete()方法

StringBuffer 类的delete() 方法删除从指定的beginIndex 到endIndex-1 的字符串。

例子：

Java 


import java.io.*;
class A {
    public static void main(String args[])
    {
        StringBuffer sb = new StringBuffer("Hello");
        sb.delete(1, 3);
        System.out.println(sb);
    }
}
输出 
Hlo

5.reverse()方法

StringBuilder 类的 reverse() 方法反转当前字符串。

例子：

Java 


import java.io.* ;
class A {
    public static void main(String args[])
    {
        StringBuffer sb = new StringBuffer("Hello");
        sb.reverse();
        System.out.println(sb);
    }
}
输出 
olleH

6.capacity()方法

  • StringBuffer 类的capacity() 方法返回缓冲区的当前容量。缓冲区的默认容量为 16。如果字符数比当前容量增加，则容量增加 (oldcapacity*2)+2。
  • 例如，如果您当前的容量为16，则为(16*2)+2=34。

例子：

Java 


import java.io.*;
class A {
    public static void main(String args[])
    {
        StringBuffer sb = new StringBuffer();
        System.out.println(sb.capacity()); // default 16
        sb.append("Hello");
        System.out.println(sb.capacity()); // now 16
        sb.append("java is my favourite language");
        System.out.println(sb.capacity());
        // Now (16*2)+2=34     i.e (oldcapacity*2)+2
    }
}
输出 
16
16
34

关于 StringBuffer 课程的一些有趣的事实

请牢记以下几点：

  • java.lang.StringBuffer 扩展(或继承)Object.
  • StringBuffer 类的所有已实现接口：Serializable、Appendable、CharSequence。
  • public final class StringBuffer 扩展了 Object 实现了 Serializable、CharSequence、Appendable。
  • 字符串缓冲区可供多个线程安全使用。可以在必要时同步这些方法，以便任何特定实例上的所有操作的行为就好像它们按某种串行顺序发生一样。
  • 每当发生涉及源序列的操作(例如从源序列追加或插入)时，此类仅在执行操作的字符串缓冲区上同步，而不在源上同步。
  • 它继承了Object类的一些方法，例如clone()、equals()、finalize()、getClass()、hashCode()、notifies()，notifyAll()。

Remember: StringBuilder, J2SE 5 adds a new string class to Java’s already powerful string handling capabilities. This new class is called StringBuilder. It is identical to StringBuffer except for one important difference: it is not synchronized, which means that it is not thread-safe. The advantage of StringBuilder is faster performance. However, in cases in which you are using multithreading,  you must use StringBuffer rather than StringBuilder.

StringBuffer 类的构造函数

1.StringBuffer()：预留16个字符的空间，无需重新分配

StringBuffer s = new StringBuffer();

2. StringBuffer( int 大小)：它接受一个整数参数，明确设置缓冲区的大小。

StringBuffer s = new StringBuffer(20);

3. 字符串缓冲区(字符串str)：它接受一个字符串 设置 StringBuffer 对象的初始内容并为 16 个以上字符保留空间而无需重新分配的参数。

StringBuffer s = new StringBuffer("GeeksforGeeks");

Java StringBuffer 类的方法

方法 执行的操作
append() 用于在现有文本的末尾添加文本。
length() StringBuffer的长度可以通过length( )方法找到
capacity() 总分配容量可以通过capacity()方法找到
charAt() 此方法返回此序列中指定索引处的 char 值。
delete() 从调用对象中删除字符序列
deleteCharAt() 删除指定索引处的字符位置
ensureCapacity() 确保容量至少等于给定的最小值。
insert() 在指定索引位置插入文本
length() 返回字符串的长度
reverse() 反转 StringBuffer 对象中的字符
replace() 将 StringBuffer 对象中的一组字符替换为另一组字符

Note: Besides that, all the methods that are used in the String class can also be used. These auxiliary methods are as follows:

方法

说明

用法

StringBuffer ensureCapacity()

它用于增加StringBuffer对象的容量。新容量将设置为我们指定的值或当前容量的两倍加二(即容量+2)，以较大者为准。这里，容量指定缓冲区的大小。

void EnsureCapacity(int 容量)

StringBuffer appendCodePoint()

此方法将 codePoint 参数的字符串表示形式附加到该序列。

公共StringBufferappendCodePoint(int codePoint)

charAt(int 索引)

此方法返回此序列中指定索引处的 char 值。

公共 char charAt(int 索引)

IntStream chars()

此方法返回 int zero-extending 此序列中的 char 值的流。

公共 IntStream chars()

StringBuffer codePointAt()

此方法返回指定索引处的字符(Unicode 代码点)。

公共 int codePointAt(int 索引)

StringBuffer codePointBefore()

此方法返回指定索引之前的字符(Unicode 代码点)。

公共 int codePointBefore(int 索引)

StringBuffer codePointCount()

此方法返回此序列的指定文本范围内的 Unicode 代码点的数量。

公共 int codePointCount(int beginIndex, int endIndex)

IntStream codePoints()

此方法返返回自该序列的代码点值流。

公共 IntStream codePoints()

StringBuffer getChars()

在此方法中，字符被从此序列复制到目标字符数组 dst 中。

公共无效 getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

StringBuffer indexOf()

此方法返回此字符串中指定子字符串第一次出现的索引。

公共intindexOf(字符串str)
公共intindexOf(字符串str，intfromIndex)

StringBuffer lastIndexOf()

此方法返回此字符串中最后一次出现的指定子字符串的索引。

公共intlastIndexOf(字符串str)
公共intlastIndexOf(字符串str，intfromIndex)

StringBuffer offsetByCodePoints()

此方法返回此序列中的索引，该索引与给定索引的偏移量为 codePointOffset 代码点。

公共 int offsetByCodePoints(int 索引, int codePointOffset)

StringBuffer setCharAt()

在此方法中，指定索引处的字符被设置为 ch。

公共无效setCharAt(int索引，字符ch)

StringBuffer setLength()

该方法设置字符序列的长度。

公共无效setLength(int newLength)

StringBuffer subSequence()

此方法返回一个新的字符序列，它是该序列的子序列。

公共CharSequence子序列(int开始，int结束)

StringBuffer substring()

此方法返回一个新字符串，其中包含当前包含在此字符序列中的字符子序列。

公共字符串子字符串(int开始)
公共字符串子字符串(int开始，int结束)

StringBuffer toString()

此方法返回一个表示该序列中的数据的字符串。

公共字符串toString()

StringBuffer trimToSize()

此方法尝试减少用于字符序列的存储。

公共无效trimToSize()

Above we only have discussed the most widely used methods and do keep a tight bound around them as they are widely used in programming geeks.

E上述方法的示例

示例 1： length() 和 capacity()方法

Java 


// Java Program to Illustrate StringBuffer class
// via length() and capacity() methods
// Importing I/O classes
import java.io.*;
// Main class
class GFG {
    // main driver method
    public static void main(String[] args)
    {
        // Creating and storing string by creating object of
        // StringBuffer
        StringBuffer s = new StringBuffer("GeeksforGeeks");
        // Getting the length of the string
        int p = s.length();
        // Getting the capacity of the string
        int q = s.capacity();
        // Printing the length and capacity of
        // above generated input string on console
        System.out.println("Length of string GeeksforGeeks="
                           + p);
        System.out.println(
            "Capacity of string GeeksforGeeks=" + q);
    }
}
输出 
Length of string GeeksforGeeks=13
Capacity of string GeeksforGeeks=29

示例 2：StringBuffer append()

它用于在现有文本的末尾添加文本。

以下是它的一些形式：

StringBuffer append(String str)
StringBuffer append(int num)

Java 


// Java Program to Illustrate StringBuffer class
// via append() method 
// Importing required classes
import java.io.*;
// Main class
class GFG {
    // Main driver method
    public static void main(String[] args)
    {
        // Creating an object of StringBuffer class and
        // passing random string
        StringBuffer s = new StringBuffer("Geeksfor");
        // Usage of append() method
        s.append("Geeks");
        // Returns GeeksforGeeks
        System.out.println(s);
        s.append(1);
        // Returns GeeksforGeeks1
        System.out.println(s);
    }
}
输出 
GeeksforGeeks
GeeksforGeeks1

示例 3：StringBuffer insert()

它用于在指定索引位置插入文本。

用法:其中一些如下：

StringBuffer insert(int index, String str)
StringBuffer insert(int index, char ch)

在这里， index 指定索引，在该索引处字符串将被插入到调用中StringBuffer对象。

Java 


// Java Program to Illustrate StringBuffer class
// via insert() method
// Importing required I/O classes
import java.io.*;
// Main class
class GFG {
    // Main driver method
    public static void main(String[] args)
    {
        // Creating an object of StringBuffer class
        StringBuffer s = new StringBuffer("GeeksGeeks");
        // Inserting element and position as an arguments
        s.insert(5, "for");
        // Returns GeeksforGeeks
        System.out.println(s);
        s.insert(0, 5);
        // Returns 5GeeksforGeeks
        System.out.println(s);
        s.insert(3, true);
        // Returns 5GetrueeksforGeeks
        System.out.println(s);
        s.insert(5, 41.35d);
        // Returns 5Getr41.35ueeksforGeeks
        System.out.println(s);
        s.insert(8, 41.35f);
        // Returns 5Getr41.41.3535ueeksforGeeks
        System.out.println(s);
        // Declaring and initializing character array
        char geeks_arr[] = { 'p', 'a', 'w', 'a', 'n' };
        // Inserting character array at offset 9
        s.insert(2, geeks_arr);
        // Returns 5Gpawanetr41.41.3535ueeksforGeeks
        System.out.println(s);
    }
}
输出 
GeeksforGeeks
5GeeksforGeeks
5GetrueeksforGeeks
5Getr41.35ueeksforGeeks
5Getr41.41.3535ueeksforGeeks
5Gpawanetr41.41.3535ueeksforGeeks

示例4： StringBuffer reverse()

它可以使用以下命令反转 StringBuffer 对象中的字符撤销( )。此方法返回调用它的反转对象。

Java 


// Java Program to Illustrate StringBuffer class
// via reverse() method
// Importing I/O classes
import java.io.*;
// Main class
class GFG {
    // Main driver method
    public static void main(String[] args)
    {
        // Creating a string via creating
        // object of StringBuffer class
        StringBuffer s = new StringBuffer("GeeksGeeks");
        // Invoking reverse() method
        s.reverse();
        // Returns "skeeGrofskeeG"
        System.out.println(s);
    }
}
输出 
skeeGskeeG

实施例5：StringBuffer delete()和StringBuffer deleteCharAt()

它可以使用以下方法删除StringBuffer中的字符删除( )和删除字符()。这删除( )方法从调用对象中删除字符序列。此处，起始索引指定要删除的第一个字符的索引，结束索引指定要删除的最后一个字符之后的索引。因此，删除的子字符串从 startIndex 到 endIndex-1。返回结果StringBuffer 对象。这删除字符()方法删除指定索引处的字符地点它返回生成的StringBuffer 对象。

用法:

StringBuffer delete(int startIndex, int endIndex)
StringBuffer deleteCharAt(int loc)

Java 


// Java Program to Illustrate StringBuffer class
// via delete() and deleteCharAt() Methods 
// Importing I/O classes
import java.io.*;
// Main class
class GFG {
    // Main driver method
    public static void main(String[] args)
    {
        StringBuffer s = new StringBuffer("GeeksforGeeks");
        s.delete(0, 5);
        // Returns forGeeks
        System.out.println(s);
        s.deleteCharAt(7);
        // Returns forGeek
        System.out.println(s);
    }
}
输出 
forGeeks
forGeek

实施例6： StringBuffer replace()

它可以通过调用replace()将StringBuffer对象中的一组字符替换为另一组字符。被替换的子字符串由索引 startIndex 和 endIndex 指定。因此，从 startIndex 到 endIndex-1 的子字符串被替换。替换字符串在 str 中传递。返回结果StringBuffer 对象。

用法:

StringBuffer replace(int startIndex, int endIndex, String str)

示例

Java 


// Java Program to Illustrate StringBuffer class
// via replace() method
// Importing I/O classes
import java.io.*;
// Main class
class GFG {
    // Main driver method
    public static void main(String[] args)
    {
        StringBuffer s = new StringBuffer("GeeksforGeeks");
        s.replace(5, 8, "are");
        // Returns GeeksareGeeks
        System.out.println(s);
    }
}
输出 
GeeksareGeeks

本文由洛克什·托德瓦尔。



相关用法


注：本文由纯净天空筛选整理自佚名大神的英文原创作品 StringBuffer class in Java。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。