StringBuilder和StringBuffer
2.StringBuilder和StringBuffer
1.insert方法
StringBuilder stringBuilder = new StringBuilder();
//insert方法============================
System.out.println("====insert方法=====");
stringBuilder.insert(0,new char[]{'a','b','c','d','e'},0,3);
//System.out.println(stringBuilder);
// 在位置0处插入字符数组。0表示字符数组起始位置，3表示长度
stringBuilder.insert(0, new char[]{'A', 'B', 'C', 'D', 'E'}, 0, 3);
// 在位置0处插入float
stringBuilder.insert(0, 1.414f);
// 在位置0处插入double
stringBuilder.insert(0, 3.14159d);
// 在位置0处插入boolean
stringBuilder.insert(0, true);
// 在位置0处插入char
stringBuilder.insert(0, '\n');
// 在位置0处插入int
stringBuilder.insert(0, 100);
// 在位置0处插入long
stringBuilder.insert(0, 12345L);
// 在位置0处插入StringBuilder对象
stringBuilder.insert(0, new StringBuilder("StringBuilder"));
// 在位置0处插入StringBuilder对象。6表示被在位置0处插入对象的起始位置(包括)，13是结束位置(不包括)
stringBuilder.insert(0, new StringBuilder("STRINGBUILDER"), 6, 13);
// 在位置0处插入StringBuffer对象。
stringBuilder.insert(0, new StringBuffer("StringBuffer"));
// 在位置0处插入StringBuffer对象。6表示被在位置0处插入对象的起始位置(包括)，12是结束位置(不包括)
stringBuilder.insert(0, new StringBuffer("STRINGBUFFER"), 6, 12);
// 在位置0处插入String对象。
stringBuilder.insert(0, "String");
// 在位置0处插入String对象。1表示被在位置0处插入对象的起始位置(包括)，6是结束位置(不包括)
stringBuilder.insert(0, "0123456789", 1, 6);
stringBuilder.insert(0, '\n');
// 在位置0处插入Object对象。此处以HashMap为例
HashMap map = new HashMap();
map.put("1", "one");
map.put("2", "two");
map.put("3", "three");
stringBuilder.insert(0, map);
System.out.printf("%s\n\n", stringBuilder);
2.append方法
//append方法===============================
System.out.println("======append方法========");
// 追加字符数组
stringBuilder.append(new char[]{'a','b','c','d','e'});
// 追加字符数组。0表示字符数组起始位置，3表示长度
stringBuilder.append(new char[]{'A','B','C','D','E'}, 0, 3);
// 追加float
stringBuilder.append(1.414f);
// 追加double
stringBuilder.append(3.14159d);
// 追加boolean
stringBuilder.append(true);
// 追加char
stringBuilder.append('\n');
// 追加int
stringBuilder.append(100);
// 追加long
stringBuilder.append(12345L);
// 追加StringBuilder对象
stringBuilder.append(new StringBuilder("StringBuilder"));
// 追加StringBuilder对象。6表示被追加对象的起始位置(包括)，13是结束位置(不包括)
stringBuilder.append(new StringBuilder("STRINGBUILDER"), 6, 13);
// 追加StringBuffer对象。
stringBuilder.append(new StringBuffer("StringBuffer"));
// 追加StringBuffer对象。6表示被追加对象的起始位置(包括)，12是结束位置(不包括)
stringBuilder.append(new StringBuffer("STRINGBUFFER"), 6, 12);
// 追加String对象。
stringBuilder.append("String");
// 追加String对象。1表示被追加对象的起始位置(包括)，6是结束位置(不包括)
stringBuilder.append("0123456789", 1, 6);
stringBuilder.append('\n');
// 追加Object对象。此处以HashMap为例
HashMap map1 = new HashMap();
map1.put("1", "one");
map1.put("2", "two");
map1.put("3", "three");
stringBuilder.append(map1);
stringBuilder.append('\n');
// 追加unicode编码
stringBuilder.appendCodePoint(0x5b57); // 0x5b57是“字”的unicode编码
stringBuilder.appendCodePoint(0x7b26); // 0x7b26是“符”的unicode编码
stringBuilder.appendCodePoint(0x7f16); // 0x7f16是“编”的unicode编码
stringBuilder.appendCodePoint(0x7801); // 0x7801是“码”的unicode编码
System.out.printf("%s\n\n", stringBuilder);
3.replace方法
//replace方法================
System.out.println("=======replace方法=========");
stringBuilder.replace(0, 3, "ABCDE");
stringBuilder.reverse();//反转
stringBuilder.setCharAt(0, 'M');
4.delete方法
//delete方法================
System.out.println("=======delete方法=========");
// 删除位置0的字符，剩余字符是“123456789”。
stringBuilder.deleteCharAt(0);
// 删除位置3(包括)到位置6(不包括)之间的字符，剩余字符是“123789”。
stringBuilder.delete(3,6);
// 获取sb中从位置1开始的字符串
String str1 = stringBuilder.substring(1);
// 获取sb中从位置3(包括)到位置5(不包括)之间的字符串
String str2 = stringBuilder.substring(3, 5);
// 获取sb中从位置3(包括)到位置5(不包括)之间的字符串，获取的对象是CharSequence对象，此处转型为String
String str3 = (String)stringBuilder.subSequence(3, 5);
5.index方法
//index方法================
System.out.println("=======index方法=========");
// 1. 从前往后，找出"bc"第一次出现的位置
System.out.printf("%-30s = %d\n", "stringBuilder.indexOf(\"bc\")",
stringBuilder.indexOf("bc"));
// 2. 从位置5开始，从前往后，找出"bc"第一次出现的位置
System.out.printf("%-30s = %d\n", "stringBuilder.indexOf(\"bc\", 5)",
stringBuilder.indexOf("bc", 5));
// 3. 从后往前，找出"bc"第一次出现的位置
System.out.printf("%-30s = %d\n", "stringBuilder.lastIndexOf(\"bc\")",
stringBuilder.lastIndexOf("bc"));
// 4. 从位置4开始，从后往前，找出"bc"第一次出现的位置
System.out.printf("%-30s = %d\n", "stringBuilder.lastIndexOf(\"bc\", 4)",
stringBuilder.lastIndexOf("bc", 4));
6.其他
//其他
int cap = stringBuilder.capacity();
System.out.printf("cap=%d\n", cap);
/*
capacity()返回的是字符串缓冲区的容量
StringBuffer( ); 分配16个字符的缓冲区
StringBuffer( int len ); 分配len个字符的缓冲区
StringBuffer( String s ); 除了按照s的大小分配空间外,再分配16个 字符的缓冲区
你的StringBuffer是用字符构造的，"0123456789"的长度是10另外再分配16个字符，所
以一共是26。
*/
char c = stringBuilder.charAt(6);
System.out.printf("c=%c\n", c);
char[] carr = new char[4];
stringBuilder.getChars(3, 7, carr, 0);
for (int i=0; i<carr.length; i++){
System.out.printf("carr[%d]=%c ", i, carr[i]);
}
3.小结
【String、StringBuffer、StringBuilder之间的区别】
首先需要说明的是：
String 字符串常量
StringBuffer 字符串变量（线程安全）
StringBuilder 字符串变量（非线程安全）
在大多数情况下三者在执行速度方面的比较：StringBuilder > StringBuffer > String
解释：
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”;
大部分情况下StringBuilder的速度要大于StringBuffer：
java.lang.StringBuilder一个可变的字符序列是5.0新增的。（大多数情况下就是我们是在单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffer的）此类提供一个与 StringBuffer兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer 要快。两者的方法基本相同。
对于三者使用的总结：
1）如果要操作少量的数据用 = String
2）单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
3）多线程操作字符串缓冲区 下操作大量数据 = StringBuffer
StringBuilder 与StringBuffer的区别，StringBuilder与String的区别。
1）StringBuilder效率高，线程不安全，StringBuffer效率低，线程安全。
2）String是不可变字符串，StringBuilder是可变字符串。为什么有这样的差异，可以深入源码去解析，
比如String类内的 priver final char value[] 等方法的原因。
3）如果是简单的声明一个字符串没有后续过多的操作，使用String,StringBuilder均可，若后续对字符串做频繁的添加，删除操作,或者是在循环当中动态的改变字符穿的长度应该用StringBuilder。使用String会产生多余的字符串，占用内存空间。
浙公网安备 33010602011771号