虽然我手比脚笨，但我有梦的天真
JAVA中StringBuffer类常用方法详解
String是不变类，用String修改字符串会新建一个String对象，如果频繁的修改，将会产生很多的String对象，开销很大.因此java提供了一个StringBuffer类，这个类在修改字符串方面的效率比String高了很多。
在java中有3个类来负责字符的操作。
1.Character 是进行单个字符操作的，
2.String 对一串字符进行操作。不可变类。
3.StringBuffer 也是对一串字符进行操作，但是可变类。
public class UsingStringBuffer {
* 查找匹配字符串
public static void testFindStr() {
StringBuffer sb = new StringBuffer();
sb.append("This is a StringBuffer");
// 返回子字符串在字符串中最先出现的位置，如果不存在，返回负数
System.out.println("sb.indexOf(\"is\")=" + sb.indexOf("is"));
// 给indexOf方法设置参数，指定匹配的起始位置
System.out.println("sb.indexOf(\"is\")=" + sb.indexOf("is", 3));
// 返回子字符串在字符串中最后出现的位置，如果不存在，返回负数
System.out.println("sb.lastIndexOf(\"is\") = " + sb.lastIndexOf("is"));
// 给lastIndexOf方法设置参数，指定匹配的结束位置
System.out.println("sb.lastIndexOf(\"is\", 1) = "
+ sb.lastIndexOf("is", 1));
* 截取字符串
public static void testSubStr() {
StringBuffer sb = new StringBuffer();
sb.append("This is a StringBuffer");
// 默认的终止位置为字符串的末尾
System.out.print("sb.substring(4)=" + sb.substring(4));
// substring方法截取字符串，可以指定截取的起始位置和终止位置
System.out.print("sb.substring(4,9)=" + sb.substring(4, 9));
* 获取字符串中某个位置的字符
public static void testCharAtStr() {
StringBuffer sb = new StringBuffer("This is a StringBuffer");
System.out.println(sb.charAt(sb.length() - 1));
* 添加各种类型的数据到字符串的尾部
public static void testAppend() {
StringBuffer sb = new StringBuffer("This is a StringBuffer!");
sb.append(1.23f);
System.out.println(sb.toString());
* 删除字符串中的数据
public static void testDelete() {
StringBuffer sb = new StringBuffer("This is a StringBuffer!");
sb.delete(0, 5);
sb.deleteCharAt(sb.length() - 1);
System.out.println(sb.toString());
* 向字符串中插入各种类型的数据
public static void testInsert() {
StringBuffer sb = new StringBuffer("This is a StringBuffer!");
// 能够在指定位置插入字符、字符数组、字符串以及各种数字和布尔值
sb.insert(2, 'W');
sb.insert(3, new char[] { 'A', 'B', 'C' });
sb.insert(8, "abc");
sb.insert(2, 3);
sb.insert(3, 2.3f);
sb.insert(6, 3.75d);
sb.insert(5, 9843L);
sb.insert(2, true);
System.out.println("testInsert: " + sb.toString());
* 替换字符串中的某些字符
public static void testReplace() {
StringBuffer sb = new StringBuffer("This is a StringBuffer!");
// 将字符串中某段字符替换成另一个字符串
sb.replace(10, sb.length(), "Integer");
System.out.println("testReplace: " + sb.toString());
* 将字符串倒序
public static void reverseStr() {
StringBuffer sb = new StringBuffer("This is a StringBuffer!");
System.out.println(sb.reverse()); // reverse方法将字符串倒序
StringBuffer不是不变类，在修改字符串内容时，不会创建新的对象，因此，它比String类更适合修改字符串。
StringBuffer类没有提供同String一样的toCharArray方法
StringBuffer类的replace方法同String类的replace方法不同,它的replace方法有三个参数,第一个参数指定被替换子串的起始位置，第二个参数指定被替换子串的终止位置，第三个参数指定新子串
没有更多推荐了，定义一个StringBuffer类对象，然后通过append（）方法想对象中添加26个小写字母，要求每次只添加一次，共添加26次，然后按照逆序的方式输出，并且可以删除前5个字符。
定义一个StringBuffer类对象，然后通过append（）方法想对象中添加26个小写字母，要求每次只添加一次，共添加26次，然后按照逆序的方式输出，并且可以删除前5个字符。
public class StringBufferDemo{public static void main(String[] args){
StringBuffer buf=new StringBuffer();
Character a='a';
for(int i=0;i&25; i++){
buf.append(a);
a=new Character((char)(a+1));
buf.append(a);
System.out.println("添加之后："+buf);
buf.reverse();
System.out.println("翻转之后："+buf);
buf.delete(0,5);
System.out.println("删除之后："+buf);}
没有更多推荐了，下次自动登录
现在的位置:
& 综合 & 正文
JAVA中String与StringBuffer 、StringBuilder的区别
String和StringBuffer的区别，网上资料可以说是数不胜数，但是看到这篇文章，感觉里面做的小例子很有代表性，所以转一下，并自己做了一点总结。
在java中有3个类来负责字符的操作。
1.Character 是进行单个字符操作的，
2.String 对一串字符进行操作。不可变类。
3.StringBuffer 也是对一串字符进行操作，但是可变类。
是对象不是原始类型.
为不可变对象,一旦被创建,就不能修改它的值.
对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.
String 是final类,即不能被继承.
StringBuffer:
是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象
它只能通过构造函数来建立,
StringBuffer sb = new StringBuffer();
note:不能通过付值符号对他进行付值.
sb = "welcome to here!";//error
对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.向StringBuffer
中付值的时候可以通过它的append方法.
sb.append("hello");
字符串连接操作中StringBuffer的效率要比String高:
String str = new String("welcome to ");
str += "here";
的处理步骤实际上是通过建立一个StringBuffer,让侯调用append(),最后
再将StringBuffer toSting();
这样的话String的连接操作就比StringBuffer多出了一些附加操作,当然效率上要打折扣.
并且由于String 对象是不可变对象,每次操作Sting 都会重新建立新的对象来保存新的值.
这样原来的对象就没用了,就要被垃圾回收.这也是要影响性能的.
看看以下代码：
将26个英文字母重复加了5000次，
String tempstr = "abcdefghijklmnopqrstuvwxyz";
int times = 5000;
long lstart1 = System.currentTimeMillis();
String str = "";
for (int i = 0; i & i++) {
long lend1 = System.currentTimeMillis();
long time = (lend1 - lstart1);
System.out.println(time);
可惜我的计算机不是超级计算机，得到的结果每次不一定一样一般为 46687左右。
也就是46秒。
我们再看看以下代码
String tempstr = "abcdefghijklmnopqrstuvwxyz";
int times = 5000;
long lstart2 = System.currentTimeMillis();
StringBuffer sb = new StringBuffer();
for (int i = 0; i & i++) {
sb.append(tempstr);
long lend2 = System.currentTimeMillis();
long time2 = (lend2 - lstart2);
System.out.println(time2);
得到的结果为 16 有时还是 0
所以结论很明显，StringBuffer 的速度几乎是String 上万倍。当然这个数据不是很准确。因为循环的次数在100000次的时候，差异更大。不信你试试。
根据上面所说：
str += "here";
的处理步骤实际上是通过建立一个StringBuffer,让侯调用append(),最后
再将StringBuffer toSting();
所以str += "here";可以等同于
StringBuffer sb = new StringBuffer(str);
sb.append("here");
str = sb.toString();
所以上面直接利用"+"来连接String的代码可以基本等同于以下代码
String tempstr = "abcdefghijklmnopqrstuvwxyz";
int times = 5000;
long lstart2 = System.currentTimeMillis();
String str = "";
for (int i = 0; i & i++) {
StringBuffer sb = new StringBuffer(str);
sb.append(tempstr);
str = sb.toString();
long lend2 = System.currentTimeMillis();
long time2 = (lend2 - lstart2);
System.out.println(time2);
平均执行时间为46922左右，也就是46秒。
本文来自CSDN博客，转载请标明出处：
StringBuffer维护了一个大小固定的字符串缓冲区，当字符串长度超过StringBuffer大小时会自动增加，主要使用Insert和append方法，对于运行期要进行字符串的组装操作推荐使用，
StringBuilder: jdk5以后有个和StringBuffer等价的StringBuider，区别在于StringBuffer是线程安全的，StringBuilder是单线程的，不提供同步，理论上效率更高。
String是系统内置类型，而且是final的，定义一个字符串会产生一个实例和一个对该实例地址的引用。
如果在编译期间定义的字符串，例如 :
String a = "name";
a += "is";
a += "good";
尽管这种方法是不被推荐的，但在编译期，编译器会对该代码进行优化，所以还是可以理解为:String a = "name is good";而如果在此时采用StringBuffer，反而会推迟到运行期才会被处理，相比之下，反而会比StringBuffer效率更高，灵活运用。
String 字符串常量
StringBuffer 字符串变量（线程安全）
StringBuilder 字符串变量（非线程安全）简 要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。
而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer
String S1 = “This is only a” + “ simple” + “ test”;
StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个
String S1 = “This is only a” + “ simple” + “test”; 其实就是：
String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，譬如：
String S2 = “This is only a”;
String S3 = “ simple”;
String S4 = “ test”;
String S1 = S2 +S3 + S4;
这时候 JVM 会规规矩矩的按照原来的方式去做
在大部分情况下 StringBuffer & StringStringBufferJava.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。
可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。
StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。 append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。
例如，如果 z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。在大部分情况下 StringBuilder & StringBuffer
java.lang.StringBuildejava.lang.StringBuilder 一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同。
通过非官方试验测试，StringBuilder和StringBuffer的测试总结如下：
1． 为了获得更好的性能，在构造
StirngBuffer 或 StirngBuilder
时应尽可能指定它的容量。当然，如果你操作的字符串长度不超过 16
个字符就不用了。
2． 相同情况下使用
StirngBuilder 相比使用 StringBuffer
仅能获得 10%~15%
左右的性能提升，但却要冒多线程不安全的风险。而在现实的模块化编程中，负责某一模块的程序员不一定能清晰地判断该模块是否会放入多线程的环境中运行，因此：除非你能确定你的系统的瓶颈是在
StringBuffer 上，并且确定你的模块不会运行在多线程模式下，否则还是用
StringBuffer 吧 J
3． 用好现有的类比引入新的类更重要。很多程序员在使用
StringBuffer 时是不指定其容量的（至少我见到的情况是这样），如果这样的习惯带入
StringBuilder 的使用中，你将只能获得
10 ％左右的性能提升（不要忘了，你可要冒多线程的风险噢）；但如果你使用指定容量的
StringBuffer ，你将马上获得 45%
左右的性能提升，甚至比不使用指定容量的 StirngBuilder
【上篇】【下篇】16.StringBuffer - Java基础知识总结(超级经典) - 毕向东 - 电台节目 - 网易云音乐
16.StringBuffer
Java基础知识总结(超级经典) - 毕向东 第16期
介绍： 16.StringBuffer
字符串缓冲区
构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。
1：可以对字符串内容进行修改。
2：是一个容器。
3：是可变长度的。
4：缓冲区中可以存储任意类型的数据。
5：最终需要变成字符串。
容器通常具备一些固定的方法：
StringBuffer append(data):在缓冲区中追加数据。追...
介绍： 16.StringBuffer
字符串缓冲区
构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。
1：可以对字符串内容进行修改。
2：是一个容器。
3：是可变长度的。
4：缓冲区中可以存储任意类型的数据。
5：最终需要变成字符串。
容器通常具备一些固定的方法：
StringBuffer append(data):在缓冲区中追加数据。追加到尾部。
StringBuffer insert(index,data):在指定位置插入数据。
StringBuffer delete(start,end);删除从start至end-1范围的元素
StringBuffer deleteCharAt(index);删除指定位置的元素
//sb.delete(0,sb.length());//清空缓冲区。
StringBuffer replace(start,end,string);将start至end-1替换成string
void setCharAt(index,char);替换指定位置的字符
void setLength(len);将原字符串置为指定长度的字符串
4，查找。（查不到返回-1）
int indexOf(string); 返回指定子字符串在此字符串中第一次出现处的索引。
int indexOf(string,int fromIndex);从指定位置开始查找字符串
int lastIndexOf(string); 返回指定子字符串在此字符串中最右边出现处的索引。
int lastIndexOf(string,int fromIndex); 从指定的索引开始反向搜索
5，获取子串。
string substring(start); 返回start到结尾的子串
string substring(start,end); 返回start至end-1的子串
StringBuffer reverse();字符串反转
网易云音乐多端下载
同步歌单，随时畅听320k好音乐
网易公司版权所有(C)杭州乐读科技有限公司运营：
违法和不良信息举报电话：6
举报邮箱：java中StringBuffer类的常用方法怎么用？_百度知道
java中StringBuffer类的常用方法怎么用？
（1）append()
（2）charcharAt(int n)
（3）StringBufferinert(int index,String str)
（4）StringBufferreverse( )
（5）StringBufferdelete(int startindex, int endindex)
（6）StringBufferreplace(int startindex, int endindex,String str)
我有更好的答案
StringBuffer&sb&=&new&StringBuffer(&Hello&&);sb.append(&world&);&&&//在sb尾部追加一个字符串,&此时变成&Hello&sb.charAt(1)&;&&//返回下标为1的字符&此处是&esb.insert(1,&d&);&&//在&1&处插入新的字符串&d&&此时变为&Hedllo&sb.reverse();&&//反转字符&此时变成&&&&dlrow&olldeHsb.delete(1,2);&&//删除字符串&&此时变为Hllo&worldsb.replace(3,4,&new&);&&//替换字符串&&从&3开始到4结束&&此时变为&&Hllnewworld全是手打的，望采纳
怎么输出呢？
System.out.println(sb.toString());
采纳率：62%
构造方法摘要&StringBuffer()&&&&&&&&&&&构造一个其中不带字符的字符串缓冲区，其初始容量为&16&个字符。&StringBuffer(int&capacity)&&&&&&&&&&&构造一个不带字符，但具有指定初始容量的字符串缓冲区。&StringBuffer(String&str)&&&&&&&&&&&构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。&&方法摘要&&StringBuffer&append(boolean&b)&&&&&&&&&&&将&boolean&参数的字符串表示形式追加到序列。&&StringBuffer&append(char&c)&&&&&&&&&&&将&char&参数的字符串表示形式追加到此序列。&&StringBuffer&append(char[]&str)&&&&&&&&&&&将&char&数组参数的字符串表示形式追加到此序列。&&StringBuffer&append(char[]&str,&int&offset,&int&len)&&&&&&&&&&&将&char&数组参数的子数组的字符串表示形式追加到此序列。&&StringBuffer&append(double&d)&&&&&&&&&&&将&double&参数的字符串表示形式追加到此序列。&&StringBuffer&append(float&f)&&&&&&&&&&&将&float&参数的字符串表示形式追加到此序列。&&StringBuffer&append(int&i)&&&&&&&&&&&将&int&参数的字符串表示形式追加到此序列。&&StringBuffer&append(long&lng)&&&&&&&&&&&将&long&参数的字符串表示形式追加到此序列。&&StringBuffer&append(Object&obj)&&&&&&&&&&&追加&Object&参数的字符串表示形式。&&StringBuffer&append(String&str)&&&&&&&&&&&将指定的字符串追加到此字符序列。&&StringBuffer&append(StringBuffer&sb)&&&&&&&&&&&将指定的&StringBuffer&追加到此序列中。&&StringBuffer&appendCodePoint(int&codePoint)&&&&&&&&&&&将&codePoint&参数的字符串表示形式追加到此序列。&&int&capacity()&&&&&&&&&&&返回当前容量。&&char&charAt(int&index)&&&&&&&&&&&返回此序列中指定索引处的&char&值。&&int&codePointAt(int&index)&&&&&&&&&&&返回指定索引处的字符（统一代码点）。&&int&codePointBefore(int&index)&&&&&&&&&&&返回指定索引前的字符（统一代码点）。&&int&codePointCount(int&beginIndex,&int&endIndex)&&&&&&&&&&&返回此序列指定文本范围内的统一代码点。&&StringBuffer&delete(int&start,&int&end)&&&&&&&&&&&移除此序列的子字符串中的字符。&&StringBuffer&deleteCharAt(int&index)&&&&&&&&&&&移除此序列指定位置的&char。&&void&getChars(int&srcBegin,&int&srcEnd,&char[]&dst,&int&dstBegin)&&&&&&&&&&&将字符从此序列复制到目标字符数组&dst。&&int&indexOf(String&str)&&&&&&&&&&&返回第一次出现的指定子字符串在该字符串中的索引。&&int&indexOf(String&str,&int&fromIndex)&&&&&&&&&&&从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。&&StringBuffer&insert(int&offset,&boolean&b)&&&&&&&&&&&将&boolean&参数的字符串表示形式插入此序列中。&&StringBuffer&insert(int&offset,&char&c)&&&&&&&&&&&将&char&参数的字符串表示形式插入此序列中。&&StringBuffer&insert(int&offset,&char[]&str)&&&&&&&&&&&将&char&数组参数的字符串表示形式插入此序列中。&&StringBuffer&insert(int&index,&char[]&str,&int&offset,&int&len)&&&&&&&&&&&将数组参数&str&的子数组的字符串表示形式插入此序列中。&&StringBuffer&insert(int&dstOffset,&CharSequence&s,&int&start,&int&end)&&&&&&&&&&&将指定&CharSequence&的子序列插入此序列中。&&StringBuffer&insert(int&offset,&double&d)&&&&&&&&&&&将&double&参数的字符串表示形式插入此序列中。&&StringBuffer&insert(int&offset,&float&f)&&&&&&&&&&&将&float&参数的字符串表示形式插入此序列中。&&StringBuffer&insert(int&offset,&int&i)&&&&&&&&&&&将&int&参数的字符串表示形式插入此序列中。&&StringBuffer&insert(int&offset,&long&l)&&&&&&&&&&&将&long&参数的字符串表示形式插入此序列中。&&StringBuffer&insert(int&offset,&Object&obj)&&&&&&&&&&&将&Object&参数的字符串表示形式插入此字符序列中。&&StringBuffer&insert(int&offset,&String&str)&&&&&&&&&&&将字符串插入此字符序列中。&&int&lastIndexOf(String&str)&&&&&&&&&&&返回最右边出现的指定子字符串在此字符串中的索引。&&int&length()&&&&&&&&&&&返回长度（字符数）。&&&StringBuffer&replace(int&start,&int&end,&String&str)&&&&&&&&&&&使用给定&String&中的字符替换此序列的子字符串中的字符。&&StringBuffer&reverse()&&&&&&&&&&&将此字符序列用其反转形式取代。&&void&setCharAt(int&index,&char&ch)&&&&&&&&&&&将给定索引处的字符设置为&ch。&&void&setLength(int&newLength)&&&&&&&&&&&设置字符序列的长度。&&String&substring(int&start)&&&&&&&&&&&返回一个新的&String，它包含此字符序列当前所包含的字符子序列。&&String&substring(int&start,&int&end)&&&&&&&&&&&返回一个新的&String，它包含此序列当前所包含的字符子序列。&&String&toString()&&&&&&&&&&&返回此序列中数据的字符串表示形式。
为您推荐：
其他类似问题
stringbuffer的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。}