String、StringBuffer、StringBuilder
罗炜光
4月 16, 2016
例子
String
public class Test
{
public static void main(String[] args) throws UnsupportedEncodingException
{
String str = "Hello World";
// charAt(int index) char 返回指定索引处的char值
System.out.println("charAt(int index):"+str.charAt(0));
// codePointAt(int index) int 返回指定索引处的字符（Unicode 代码点）。
System.out.println("codePointAt(int index):"+str.codePointAt(0));
// codePointBefore(int index) int 返回指定索引之前的字符（Unicode 代码点）。codePointBefore(index)相当于codePointAt(index - 1);
System.out.println("codePointBefore(int index):"+str.codePointBefore(1));
// codePointCoubt(int beginIndex,int endIndex) int 返回此 String 的指定文本范围中的 Unicode 代码点数。 //一般用不到
System.out.println("codePointCoubt(int beginIndex,int endIndex):" + str.codePointCount(1, 10));
// compareTo(String anotherString) int 按字典顺序比较两个字符串。 正数表示str更大
System.out.println("compareTo(String anotherString):" + str.compareTo("Hello World"));
// compareToIgnoreCase(String str) int 按字典顺序比较两个字符串，不考虑大小写。 正数表示str更大
System.out.println("compareToIgnoreCase(String str):" + str.compareToIgnoreCase("hello world"));
// concat(String str) String 将指定字符串连接到此字符串的结尾。 不会改变str的值
System.out.println("concat(String str):" + str.concat("."));
// contains(CharSequence s) boolean 当且仅当此字符串包含指定的 char 值序列时，返回 true。
System.out.println("contains(CharSequence s):" + str.contains("Hello World"));
//contentEquals(CharSequence cs) boolean 将此字符串与指定的 CharSequence 比较。
System.out.println("contentEquals(CharSequence cs):" + str.contentEquals("He"));
//contentEquals(StringBuffer sb) boolean 将此字符串与指定的 StringBuffer 比较。
System.out.println("contentEquals(StringBuffer sb):" + str.contentEquals(new StringBuffer("Hello World")));
//copyValueOf(char[] data) static String 返回指定数组中表示该字符序列的 String。
char[] array = new char[]{'H','e','l','l','o',' ','W','o','r','l','d'};
System.out.println("copyValueOf(char[] data):" + String.copyValueOf(array));
//copyValueOf(char[] data, int offset, int count) static String 返回指定数组中表示该字符序列的 String。
System.out.println("copyValueOf(char[] data, int offset, int count):" + String.copyValueOf(array, 0, 5));
//endsWith(String suffix) boolean 测试此字符串是否以指定的后缀结束。
System.out.println("endsWith(String suffix):" + str.endsWith("World "));
//equals(Object anObject) boolean 将此字符串与指定的对象比较。
System.out.println("equals(Object anObject):" + str.equals("Hello World"));
//equalsIgnoreCase(String anotherString) boolean 将此 String 与另一个 String 比较，不考虑大小写。
System.out.println("equalsIgnoreCase(String anotherString):" + str.equalsIgnoreCase("hello world"));
//format(Locale l, String format, Object... args)
// 转 换 符 说 明 示 例
// %s 字符串类型 "mingrisoft"
// %c 字符类型 'm'
// %b 布尔类型 true
// %d 整数类型（十进制） 99
// %x 整数类型（十六进制） FF
// %o 整数类型（八进制） 77
// %f 浮点类型 99.99
// %a 十六进制浮点类型 FF.35AE
// %e 指数类型 9.38e+5
// %g 通用浮点类型（f和e类型中较短的）
// %h 散列码
// %% 百分比类型 ％
// %n 换行符
// %tx 日期与时间类型（x代表不同的日期与时间转换符
// 标 志 说 明 示 例 结 果
// + 为正数或者负数添加符号 ("%+d",15) +15
// − 左对齐 ("%-5d",15) |15 |
// 0 数字前面补0 ("%04d", 99) 0099
// 空格 在整数之前添加指定数量的空格 ("% 4d", 99) | 99|
// , 以“,”对数字分组 ("%,f", 9999.99) 9,999.990000
// ( 使用括号包含负数 ("%(f", -99.99) (99.990000)
// # 如果是浮点数则包含小数点，如果是16进制或8进制则添加0x或0 ("%#x", 99) 0x63
// ("%#o", 99) 0143
// < 格式化前一个转换符所描述的参数 ("%f和%<3.2f", 99.45) 99.450000和99.45
// $ 被格式化的参数索引 ("%1$d,%2$s", 99,"abc") 99,abc
// 转 换 符 说 明 示 例
// c 包括全部日期和时间信息 星期六 十月 27 14:21:20 CST 2007
// F “年-月-日”格式 2007-10-27
// D “月/日/年”格式 10/27/07
// r “HH:MM:SS PM”格式（12时制） 02:25:51 下午
// T “HH:MM:SS”格式（24时制） 14:28:16
// R “HH:MM”格式（24时制） 14:28
// 转 换 符 说 明 示 例
// H 2位数字24时制的小时（不足2位前面补0） 15
// I 2位数字12时制的小时（不足2位前面补0） 03
// k 2位数字24时制的小时（前面不补0） 15
// l 2位数字12时制的小时（前面不补0） 3
// M 2位数字的分钟（不足2位前面补0） 03
// S 2位数字的秒（不足2位前面补0） 09
// L 3位数字的毫秒（不足3位前面补0） 015
// N 9位数字的毫秒数（不足9位前面补0） 562000000
// p 小写字母的上午或下午标记 中：下午英：pm
// z 相对于GMT的RFC822时区的偏移量 +0800
// Z 时区缩写字符串 CST
// s 1970-1-1 00:00:00 到现在所经过的秒数 1193468128
// Q 1970-1-1 00:00:00 到现在所经过的毫秒数 1193468128984
System.out.println("format(Locale l, String format, Object... args):" + String.format(Locale.CHINA, "%s", str));
System.out.println("format(Locale l, String format, Object... args):" + String.format(Locale.CHINA, "%05d", 123));
System.out.println("format(Locale l, String format, Object... args):" + String.format(Locale.CHINA, "%tc", new Date()));
System.out.println("format(Locale l, String format, Object... args):" + String.format(Locale.CHINA, "%tQ", new Date()));
//format(String format, Object... args) static String 使用指定的格式字符串和参数返回一个格式化字符串。
System.out.println("format(String format, Object... args):" + String.format("%#x", 123));
//getBytes() byte[] 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
System.out.println("getBytes():" + new String(str.getBytes()));
//getBytes(Charset charset) byte[] 使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。
System.out.println("getBytes(Charset charset):" + new String(str.getBytes(Charset.defaultCharset())));
//getBytes(String charsetName) byte[] 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
System.out.println("getBytes(String charsetName):" + new String(str.getBytes("UTF-8")));
//getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) void 将字符从此字符串复制到目标字符数组。
char[] array2 = new char[]{'a','b','c','d','e','f','g','h','i','j','k'};
str.getChars(0, 5, array2, 4);
System.out.println("getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin):" + new String(array2));
//hashCode() int 返回此字符串的哈希码。
System.out.println("hashCode():" + str.hashCode());
//indexOf(int ch) int 返回指定字符在此字符串中第一次出现处的索引。
System.out.println("indexOf(int ch):" + str.indexOf('H'));
//indexOf(int ch, int fromIndex) int 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
System.out.println("indexOf(int ch, int fromIndex):" + str.indexOf('l',4));
//indexOf(String str)
System.out.println("indexOf(String str):" + str.indexOf("Hello"));
//indexOf(String str, int fromIndex) int 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
System.out.println("indexOf(String str, int fromIndex):" + str.indexOf("l", 4));
//intern() String 返回字符串对象的规范化表示形式。即将字符串添加到常量池中(假如常量池中没有)，并返回其引用
System.out.println("intern():" + str.intern());
//isEmpty() boolean 当且仅当 length() 为 0 时返回 true。
System.out.println("isEmpty():" + str.isEmpty());
//lastIndexOf(int ch) int 返回指定字符在此字符串中最后一次出现处的索引。
System.out.println("lastIndexOf(int ch):" + str.lastIndexOf('l'));
//lastIndexOf(int ch, int fromIndex) int 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
System.out.println("lastIndexOf(int ch, int fromIndex):" + str.lastIndexOf('l', 8));
//lastIndexOf(String str) int 返回指定子字符串在此字符串中最右边出现处的索引。
System.out.println("lastIndexOf(String str):" + str.lastIndexOf("World"));
//lastIndexOf(String str, int fromIndex) int 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
System.out.println("lastIndexOf(String str, int fromIndex):" + str.lastIndexOf("World", 5));
//length() int 返回此字符串的长度。
System.out.println("length():" + str.length());
//matches(String regex) boolean 告知此字符串是否匹配给定的正则表达式。
System.out.println("matches(String regex):" + str.matches("[H]ello World"));
//offsetByCodePoints(int index, int codePointOffset) int 返回此 String 中从给定的 index 处偏移 codePointOffset 个代码点的索引。
System.out.println("offsetByCodePoints(int index, int codePointOffset):" + str.offsetByCodePoints(2, 5));
//regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) boolean 测试两个字符串区域是否相等。
// 参数：
// ignoreCase - 如果为 true，则比较字符时忽略大小写。
// toffset - 此字符串中子区域的起始偏移量。
// other - 字符串参数。
// toffset - 字符串参数中子区域的起始偏移量。
// len - 要比较的字符数。
System.out.println("regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len):" + str.regionMatches(false, 6, "World", 0, 3));
//regionMatches(int toffset, String other, int ooffset, int len) boolean 测试两个字符串区域是否相等。
System.out.println("regionMatches(int toffset, String other, int ooffset, int len):" + str.regionMatches(6, "World", 0, 3));
//replace(char oldChar, char newChar) String 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
System.out.println("replace(char oldChar, char newChar):" + str.replace('o', '0'));
//replace(CharSequence target, CharSequence replacement) String 使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
System.out.println("replace(CharSequence target, CharSequence replacement):" + str.replace("Hello", "Hello "));
//replaceAll(String regex, String replacement) String 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
System.out.println("replaceAll(String regex, String replacement):" + str.replaceAll("[l]", "L"));
//replaceFirst(String regex, String replacement) String 用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
System.out.println("replaceFirst(String regex, String replacement):" + str.replaceFirst("[l]", "L"));
//split(String regex) String[] 根据给定正则表达式的匹配拆分此字符串。
String[] strs1 = str.split("[l]");
for(int i = 0 ;i < strs1.length; i++)
System.out.println("split(String regex):" +strs1[i]);
//split(String regex, int limit) String[] 根据匹配给定的正则表达式来拆分此字符串。
String[] strs2 = str.split("[l]",2);
for(int i = 0 ;i < strs2.length; i++)
System.out.println("split(String regex, int limit):" +strs2[i]);
//startsWith(String prefix) boolean 测试此字符串是否以指定的前缀开始。
System.out.println("startsWith(String prefix):" + str.startsWith("Hello"));
//startsWith(String prefix, int toffset) boolean 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
System.out.println("startsWith(String prefix, int toffset):" + str.startsWith("World", 6));
//subSequence(int beginIndex, int endIndex) CharSequence 返回一个新的字符序列，它是此序列的一个子序列。
System.out.println("subSequence(int beginIndex, int endIndex):" + str.substring(2, 5));
//substring(int beginIndex) String 返回一个新的字符串，它是此字符串的一个子字符串。
System.out.println("substring(int beginIndex):" + str.substring(6));
//substring(int beginIndex, int endIndex) String 返回一个新的字符串，它是此字符串的一个子字符串。
System.out.println("substring(int beginIndex, int endIndex):" + str.substring(2, 3));
//toCharArray() char[] 将此字符串转换为一个新的字符数组。
System.out.println("toCharArray():" + new String(str.toCharArray()));
//toLowerCase() String 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
System.out.println("toLowerCase():" + str.toLowerCase());
//toLowerCase(Locale locale) String 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
System.out.println("toLowerCase(Locale locale):" + str.toLowerCase(Locale.CHINESE));
//toString() String 返回此对象本身（它已经是一个字符串！）。
System.out.println("toString():" + str.toString());
//toUpperCase() String 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
System.out.println("toUpperCase():" + str.toUpperCase());
//toUpperCase(Locale locale) String 使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
System.out.println("toUpperCase(Locale locale):" + str.toUpperCase(Locale.CHINESE));
//trim() String 返回字符串的副本，忽略前导空白和尾部空白。
System.out.println("trim():" + str.trim());
//valueOf(boolean b) static String
System.out.println("valueOf(boolean b):" + String.valueOf(Boolean.FALSE));
//valueOf(char c) static String
System.out.println("valueOf(char c):" + String.valueOf('a'));
//valueOf(char[] data) static String
System.out.println("valueOf(char[] data):" + String.valueOf(array2));
//valueOf(char[] data, int offset, int count) static String
System.out.println("valueOf(char[] data, int offset, int count):" + String.valueOf(array2,2,3));
//valueOf(double d) static String
System.out.println("valueOf(double d):" + String.valueOf(11.2d));
//valueOf(float f) static String
System.out.println("valueOf(float f):" + String.valueOf(11.3f));
//valueOf(int i) static String
System.out.println("valueOf(int i):" + String.valueOf(12));
//valueOf(long l) static String
System.out.println("valueOf(long l):" + String.valueOf(11111111111l));
//valueOf(Object obj) static String
System.out.println("valueOf(Object obj):" + String.valueOf(new Date()));
}
}
输出
charAt(int index):H
codePointAt(int index):72
codePointBefore(int index):72
codePointCount(int beginIndex,int endIndex):9
compareTo(String anotherString):0
compareToIgnoreCase(String str):0
concat(String str):Hello World.
contains(CharSequence s):true
contentEquals(CharSequence cs):false
contentEquals(StringBuffer sb):true
copyValueOf(char[] data):Hello World
copyValueOf(char[] data, int offset, int count):Hello
endsWith(String suffix):false
equals(Object anObject):true
equalsIgnoreCase(String anotherString):true
format(Locale l, String format, Object... args):Hello World
format(Locale l, String format, Object... args):00123
format(Locale l, String format, Object... args):星期六 四月 16 20:23:41 CST 2016
format(Locale l, String format, Object... args):1460809421630
format(String format, Object... args):0x7b
getBytes():Hello World
getBytes(Charset charset):Hello World
getBytes(String charsetName):Hello World
getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin):abcdHellojk
hashCode():-862545276
indexOf(int ch):0
indexOf(int ch, int fromIndex):9
indexOf(String str):0
indexOf(String str, int fromIndex):9
intern():Hello World
isEmpty():false
lastIndexOf(int ch):9
lastIndexOf(int ch, int fromIndex):3
lastIndexOf(String str):6
lastIndexOf(String str, int fromIndex):-1
length():11
matches(String regex):true
offsetByCodePoints(int index, int codePointOffset):7
regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len):true
regionMatches(int toffset, String other, int ooffset, int len):true
replace(char oldChar, char newChar):Hell0 W0rld
replace(CharSequence target, CharSequence replacement):Hello World
replaceAll(String regex, String replacement):HeLLo WorLd
replaceFirst(String regex, String replacement):HeLlo World
split(String regex):He
split(String regex):
split(String regex):o Wor
split(String regex):d
split(String regex, int limit):He
split(String regex, int limit):lo World
startsWith(String prefix):true
startsWith(String prefix, int toffset):true
subSequence(int beginIndex, int endIndex):llo
substring(int beginIndex):World
substring(int beginIndex, int endIndex):l
toCharArray():Hello World
toLowerCase():hello world
toLowerCase(Locale locale):hello world
toString():Hello World
toUpperCase():HELLO WORLD
toUpperCase(Locale locale):HELLO WORLD
trim():Hello World
valueOf(boolean b):false
valueOf(char c):a
valueOf(char[] data):abcdHellojk
valueOf(char[] data, int offset, int count):cdH
valueOf(double d):11.2
valueOf(float f):11.3
valueOf(int i):12
valueOf(long l):11111111111
valueOf(Object obj):Sat Apr 16 20:23:41 CST 2016
StringBuffer
public class Test
{
public static void main(String[] args)
{
// 构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。
StringBuffer sb1 = new StringBuffer();
// 构造一个不带字符，但具有指定初始容量的字符串缓冲区。
StringBuffer sb2 = new StringBuffer(512);
// 构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。
StringBuffer sb3 = new StringBuffer("Hello World");
//append(boolean b) StringBuffer 将指定的boolean值添加到该序列。
System.out.println("append(boolean b):" + sb1.append(true));
//append(char c) StringBuffer 将指定的char值添加到该序列。
System.out.println("append(char c):" + sb1.append('a'));
//append(char[] str) StringBuffer 将指定的char[]值添加到该序列。
char[] array = new char[]{'b','c','d','e','f'};
System.out.println("append(char[] str) :" + sb1.append(array));
//append(char[] str, int offset, int len) StringBuffer 将指定的char[]值添加到该序列
System.out.println("append(char[] str, int offset, int len) :" + sb1.append(array,2,3));
//append(CharSequence s) StringBuffer 将指定的 CharSequence 添加到该序列。
CharSequence charSequence = new String("ghijk");
System.out.println("append(CharSequence s):" + sb1.append(charSequence));
//append(CharSequence s, int start, int end) StringBuffer 将指定的 CharSequence 添加到该序列。
System.out.println("append(CharSequence s, int start, int end):" + sb1.append(charSequence,2,5));
//append(double d) StringBuffer 将指定的double值添加到该序列。
System.out.println("append(double d):" + sb1.append(11.2));
//append(float f) StringBuffer 将指定的float值添加到该序列。
System.out.println("append(float f):" + sb1.append(11.3f));
//append(int i) StringBuffer 将指定的int值添加到该序列。
System.out.println("append(int i):" + sb1.append(12));
//append(long lng) StringBuffer 将指定的long值添加到该序列。
System.out.println("append(long lng):" + sb1.append(11111111111l));
//append(Object obj) StringBuffer 将指定的Object值添加到该序列。
System.out.println("append(Object obj):" + sb1.append(new Date()));
//append(String str) StringBuffer 将指定的String值添加到该序列。
System.out.println("append(String str):" + sb1.append("Hello World"));
//append(StringBuffer sb) StringBuffer 将指定的float值添加到该序列。
System.out.println("append(StringBuffer sb):" + sb1.append(new StringBuffer("Hello")));
//appendCodePoint(int codePoint) StringBuffer 将指定的字符值添加到该序列。
System.out.println("appendCodePoint(int codePoint):" + sb1.appendCodePoint(97));
//capacity() int 获取字符串缓冲区的容量大小，不是字符串长度。
System.out.println("capacity():" + sb2.capacity());
//charAt(int index) char 返回指定索引处的char值
System.out.println("charAt(int index):" + sb1.charAt(4));
//codePointAt(int index) int 返回指定索引处的字符（Unicode 代码点）。
System.out.println("codePointAt(int index):" + sb1.codePointAt(4));
//codePointBefore(int index) int 返回指定索引之前的字符（Unicode 代码点）。codePointBefore(index)相当于codePointAt(index - 1);
System.out.println("codePointBefore(int index):" + sb1.codePointBefore(5));
//codePointCount(int beginIndex,int endIndex) int 返回此 String 的指定文本范围中的 Unicode 代码点数。 //一般用不到
System.out.println("codePointCount(int beginIndex,int endIndex):" + sb1.codePointCount(4, 6));
//delete(int start, int end) StringBuffer 删除指定区间以内的所有字符，包含start，不包含end索引值的区间。
System.out.println("delete(int start, int end):" + sb1.delete(0, 4));
//deleteCharAt(int index) StringBuffer 删除指定位置的字符，然后将剩余的内容形成新的字符串
System.out.println("deleteCharAt(int index):" + sb1.deleteCharAt(0));
//ensureCapacity(int minimumCapacity) void 重新设置字符串容量的大小,只能设置比之前更大的数
sb1.ensureCapacity(1024);
System.out.println("ensureCapacity(int minimumCapacity):" + sb1.capacity());
//getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) void 将字符从此字符串复制到目标字符数组。
char[] array2 = new char[]{'a','b','c','d','e','f','g','h','i','j','k'};
sb1.getChars(0, 5, array2, 4);
System.out.println("getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin):" + new String(array2));
//indexOf(String str) int 返回指定字符在此字符串中第一次出现处的索引。
System.out.println("indexOf(String str):" + sb1.indexOf("Hello"));
//indexOf(int ch, int fromIndex) int 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
System.out.println("indexOf(int ch, int fromIndex):" + sb1.indexOf("Hello", 66));
//insert(int offset, boolean b) StringBuffer 在StringBuffer对象指定处插入boolean值，然后形成新的字符串
System.out.println("insert(int offset, boolean b):" + sb2.insert(0, true));
//insert(int offset, char c) StringBuffer 在StringBuffer对象指定处插入char值，然后形成新的字符串
System.out.println("insert(int offset, char c):" + sb2.insert(4, 'a'));
//insert(int offset, char[] str) StringBuffer 在StringBuffer对象指定处插入char[]值，然后形成新的字符串
System.out.println("insert(int offset, char[] str):" + sb2.insert(4, array));
//insert(int index, char[] str, int offset, int len) StringBuffer 在StringBuffer对象指定处插入char[]值，然后形成新的字符串
System.out.println("insert(int index, char[] str, int offset, int len):" + sb2.insert(4, array, 3, 2));
//insert(int dstOffset, CharSequence s) StringBuffer 在StringBuffer对象指定处插入CharSequence值，然后形成新的字符串
System.out.println("insert(int dstOffset, CharSequence s):" + sb2.insert(4, charSequence));
//insert(int dstOffset, CharSequence s, int start, int end) StringBuffer 在StringBuffer对象指定处插入CharSequence值，然后形成新的字符串
System.out.println("insert(int dstOffset, CharSequence s, int start, int end):" + sb2.insert(4, charSequence, 2, 4));
//insert(int offset, double d) StringBuffer 在StringBuffer对象指定处插入double值，然后形成新的字符串
System.out.println("insert(int offset, double d):" + sb2.insert(4, 11.2));
//insert(int offset, float f) StringBuffer 在StringBuffer对象指定处插入float值，然后形成新的字符串
System.out.println("insert(int offset, float f):" + sb2.insert(4, 11.3f));
//insert(int offset, int i) StringBuffer 在StringBuffer对象指定处插入int值，然后形成新的字符串
System.out.println("insert(int offset, int i):" + sb2.insert(4, 13));
//insert(int offset, long l) StringBuffer 在StringBuffer对象指定处插入long值，然后形成新的字符串
System.out.println("insert(int offset, long l):" + sb2.insert(4, 11111111111l));
//insert(int offset, Object obj) StringBuffer 在StringBuffer对象指定处插入Object值，然后形成新的字符串
System.out.println("insert(int offset, Object obj):" + sb2.insert(4, new Date()));
//insert(int offset, String str) StringBuffer 在StringBuffer对象指定处插入String值，然后形成新的字符串
System.out.println("insert(int offset, String str):" + sb2.insert(4, "Hello World"));
//lastIndexOf(String str) int 返回指定子字符串在此字符串中最右边出现处的索引。
System.out.println("lastIndexOf(String str):" + sb1.lastIndexOf("Hello"));
//lastIndexOf(String str, int fromIndex) int 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
System.out.println("lastIndexOf(String str, int fromIndex):" + sb1.lastIndexOf("Hello", 81));
//length() int 获取字符串长度
System.out.println("length():" + sb1.length());
//offsetByCodePoints(int index, int codePointOffset) int 返回该序列是从给定的索引由codePointOffset代码点偏移中的索引
System.out.println("offsetByCodePoints(int index, int codePointOffset):" + sb1.offsetByCodePoints(12, 16));
//replace(int start, int end, String str) StringBuffer 此方法替换这个序列中的特定字符串的子字符串。
System.out.println("replace(int start, int end, String str):" + sb1.replace(0, 5, "Hello"));
//reverse() StringBuffer 将StringBuffer对象中的内容反转，然后形成新的字符串。
System.out.println("reverse():" + sb1.reverse());
//setCharAt(int index, char ch) void 修改对象中索引值为index位置的字符为新的字符ch。
sb1.setCharAt(0, 'a');
System.out.println("setCharAt(int index, char ch):" + sb1);
//setLength(int newLength) void 设置字符串长度大小。 如果用小于当前字符串长度的值调用setlength()方法，则新长度后面的字符将丢失。
sb1.setLength(10);
System.out.println("setLength(int newLength):" + sb1.length());
//subSequence(int start, int end) CharSequence 返回一个新的字符序列，为这个序列的子序列
System.out.println("subSequence(int start, int end):" + sb1.subSequence(0, 5));
//substring(int start) String 返回一个新的String，它包含的字符目前包含在此字符序列子序列
System.out.println("substring(int start):" + sb1.substring(5));
//substring(int start, int end) String 返回一个新的String，它包含的字符目前包含在此字符序列子序列
System.out.println("substring(int start, int end):" + sb1.substring(0, 5));
//toString() String 此方法返回表示此序列中数据的字符串。
System.out.println("toString():" + sb1.toString());
//trimToSize() void 该方法的作用是将StringBuffer对象的中存储空间缩小到和字符串长度一样的长度，减少空间的浪费
sb1.trimToSize();
System.out.println("trimToSize():" + sb1);
}
}
输出
append(boolean b):true
append(char c):truea
append(char[] str) :trueabcdef
append(char[] str, int offset, int len) :trueabcdefdef
append(CharSequence s):trueabcdefdefghijk
append(CharSequence s, int start, int end):trueabcdefdefghijkijk
append(double d):trueabcdefdefghijkijk11.2
append(float f):trueabcdefdefghijkijk11.211.3
append(int i):trueabcdefdefghijkijk11.211.312
append(long lng):trueabcdefdefghijkijk11.211.31211111111111
append(Object obj):trueabcdefdefghijkijk11.211.31211111111111Sat Apr 16 20:22:16 CST 2016
append(String str):trueabcdefdefghijkijk11.211.31211111111111Sat Apr 16 20:22:16 CST 2016Hello World
append(StringBuffer sb):trueabcdefdefghijkijk11.211.31211111111111Sat Apr 16 20:22:16 CST 2016Hello WorldHello
appendCodePoint(int codePoint):trueabcdefdefghijkijk11.211.31211111111111Sat Apr 16 20:22:16 CST 2016Hello WorldHelloa
capacity():512
charAt(int index):a
codePointAt(int index):97
codePointBefore(int index):97
codePointCount(int beginIndex,int endIndex):2
delete(int start, int end):abcdefdefghijkijk11.211.31211111111111Sat Apr 16 20:22:16 CST 2016Hello WorldHelloa
deleteCharAt(int index):bcdefdefghijkijk11.211.31211111111111Sat Apr 16 20:22:16 CST 2016Hello WorldHelloa
ensureCapacity(int minimumCapacity):1024
getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin):abcdbcdefjk
indexOf(String str):65
indexOf(int ch, int fromIndex):76
insert(int offset, boolean b):true
insert(int offset, char c):truea
insert(int offset, char[] str):truebcdefa
insert(int index, char[] str, int offset, int len):trueefbcdefa
insert(int dstOffset, CharSequence s):trueghijkefbcdefa
insert(int dstOffset, CharSequence s, int start, int end):trueijghijkefbcdefa
insert(int offset, double d):true11.2ijghijkefbcdefa
insert(int offset, float f):true11.311.2ijghijkefbcdefa
insert(int offset, int i):true1311.311.2ijghijkefbcdefa
insert(int offset, long l):true111111111111311.311.2ijghijkefbcdefa
insert(int offset, Object obj):trueSat Apr 16 20:22:16 CST 2016111111111111311.311.2ijghijkefbcdefa
insert(int offset, String str):trueHello WorldSat Apr 16 20:22:16 CST 2016111111111111311.311.2ijghijkefbcdefa
lastIndexOf(String str):76
lastIndexOf(String str, int fromIndex):76
length():82
offsetByCodePoints(int index, int codePointOffset):28
replace(int start, int end, String str):Hellodefghijkijk11.211.31211111111111Sat Apr 16 20:22:16 CST 2016Hello WorldHelloa
reverse():aolleHdlroW olleH6102 TSC 61:22:02 61 rpA taS11111111111213.112.11kjikjihgfedolleH
setCharAt(int index, char ch):aolleHdlroW olleH6102 TSC 61:22:02 61 rpA taS11111111111213.112.11kjikjihgfedolleH
setLength(int newLength):10
subSequence(int start, int end):aolle
substring(int start):Hdlro
substring(int start, int end):aolle
toString():aolleHdlro
trimToSize():aolleHdlro
StringBuilder与StringBuffer的API相同
注意
●String是不可变的对象
●在switch语句中使用String作为case条件?
从 JDK7 开始,这是可以的,啰嗦一句,Java 6 及以前的版本都不支持这样做.
// 只在java 7及更高版本有效!
switch (str.toLowerCase()) {
case "a":
value = 1;
break;
case "b":
value = 2;
break;
}
●StringBuffer 中的方法大都采用了 synchronized 关键字进行修饰，因此是线程安全的，而 StringBuilder 没有这个修饰，可以被认为是线程不安全的
●如果要操作少量的数据，用String ；单线程操作大量数据，用StringBuilder ；多线程操作大量数据，用StringBuffer。
●不要使用String类的”+”来进行频繁的拼接，因为那样的性能极差的，应该使用StringBuffer或StringBuilder类
●为了获得更好的性能，在构造 StirngBuffer 或 StirngBuilder 时应尽可能指定它们的容量
●相同情况下使用 StirngBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。
参考资料
JAVA字符串格式化-String.format()的使用
Java：String、StringBuffer和StringBuilder的区别