一.字符串入门
1.字符串创建对象的方式：
(1) String str = "hello";
这种方式创建字符串的时候，Jvm首先会检查字符串常量池中是否存在该字符串的对象，如果已经存在，那么就不会在字符串常量池中再创建了，直接返回该字符串在字符串常量池中的内存地址；如果该字符串在字符串常量池中并不存在，那么就会在字符串常量池中先创建该字符串的对象，然后再返回。
(2) new String("hello");
这种方式创建字符串对象的时候，Jvm首先会检查字符串常量池中是否存在“hello”的字符串，如果已经存在，则不会在字符串常量池中创建了；如果还没有存在，那么就会在字符串常量池中创建“hello”字符串对象，然后还会去堆内存中再创建一份字符串的对象，把字符串常量池中的"hello字符串内容拷贝到堆内存中的字符串对象，然后返回堆内存中字符串对象的内存地址。
2.实例一
(1) 实例：
public class Demo1 {
public static void main(String[] args) {
String str1 = "hello";
String str2 = "hello";
String str3 = new String("hello");
String str4 = new String("hello");
System.out.println("str1==str2?"+(str1==str2)); // true
System.out.println("str2==str3?"+(str2==str3)); //false
System.out.println("str3==str4?"+(str3==str4)); // false
System.out.println("str3.equals(str4)?"+(str3.equals(str4))); //true
}
}(2) 运行结果：
(3) 分析：
①首先会在栈内存中声明一个变量str1，然后用双引号引起创建字符串的对象，这时候Jvm就会检查字符串常量池中是否有hello，没有的话就会在字符串常量池中先创建这个对象，然后把这个对象的内存地址返回给str1，假设它的内存地址是0x97，这时候返回给str1的就是0x97，这时候str1是指向了内存地址为0x97所存储的字符串对象。
②然后又声明了一个变量str2，用双引号引起创建字符串的对象，这时候Jvm就会检查字符串常量池中是否有hello，发现字符串常量池中已经有了hello，那么就不会在字符串常量池中再创建了。直接把字符串常量池中hello的内存地址返回给这个变量就可以，也就是说str2记录的内存地址也是0x97.所以现在str1和str2指向的是同一个对象，所以运行结果为true。
③首先在栈内存中声明一个变量str3，当new String的时候，里面有一个双引号引起来的字符串，有双引号引起来的都会先到字符串常量池中先检查，Jvm在字符串常量池中检查的时候发现已经存在hello，就不会在字符串常量池中再创建了，接着有个new关键字，凡是遇到new关键字，Jvm都会在堆内存中开辟一块新的内存空间，这时候会在堆内存中创建一个堆内存的对象，接着会把字符串常量池中的hello的内容拷贝到堆内存创建的对象中去，接着会把堆内存的内存地址返回给str3，比如说它的内存地址是0x78，str3记录的则是0x78的内存地址，它指向的是堆内存中创建的对象的内存地址。
④在栈内存中声明一个变量str4，字符串常量池中有hello，那么就不会再创建，会到堆内存中创建一个字符串对象，把字符串常量池中的内容拷贝到堆内存中创建的对象中，比如说它的内存地址是0x76，这时候栈内存中str4记录的就是0x76内存地址所存储的对象。
(4) 疑问：str3和str4的内存地址并不一样，为什么运行结果返回的是true？
虽然equals方法默认情况下（注意是默认）比较的是两个对象的内存地址，而现在用到的是字符串的对象，那么我们就不允许字符串的类对equals方法进行重写吗？字符串也可以重写equals方法，重写后就可以不遵循默认的情况，因为看的是String中有没有重写equals方法，所以应该查看String的源代码，查看String的源代码后我们发现，重写后的equals方法比较的是两个字符串对应的字符是否一致。
3.为什么比较字符串的时候建议使用equals而不是==号？
因为==号比较的是内存地址，但是我们在现实开发中一般都是比较内容是否一致，所以就不建议使用==号，如果使用==号，str2和str3就会是false，使用equals，只要两个字符串的内容一致那么返回的结果都是一致的。
注意："=="用于比较 引用数据类型数据的时候比较的是两个对象的内存地址，equals方法默认情况下比较的也是两个对象的内存地址。
4. new String("abc")创建了几个对象？
创建了两个对象，一个对象是位于字符串常量池中，一个对象是位于堆内存中。
5.实例二
(1) 实例：
public class Demo2 {
public static void main(String[] args) {
test(null);
}
public static void test(String str){
if(str.equals("中国"))
{
System.out.println("回答正确");
}else{
System.out.println("回答错误");
}
}
}
(2) 运行结果：
(3) 分析：
首先str.equals("中国")运行后就会报空指针异常，如何避免这种错误?
那么就需要使用"中国".equals(str),这也是最简便的一种方式，调换位置后，"中国"是个常量，也就是这个常量在调用equals方法，这样就变成了常量是这个方法的调用者，变量作为参数这样就可以避免永远都不会出现空指针异常。因为如果函数的调用者是一个变量，这个变量有可能指向一个空的对象；如果函数的调用者是一个常量，常量不可能为空，永远都不可能为空也就不会出现空指针异常。这是一个编程习惯，使用equals方法时，我们一般都会让常量作为这个方法的调用者，这样就可以避免空指针异常的出现。
(4) 修改后的实例：
public class Demo3 {
public static void main(String[] args) {
test(null);
}
public static void test(String str){
if("中国".equals("str"))
{
System.out.println("回答正确");
}else{
System.out.println("回答错误");
}
}
}
(5) 运行结果：
二.String类的构造方法
注意：使用字节数组或者字符数组都可以构建一个字符串对象。
1.String();
(1) 该方法用于创建一个空内容的字符串对象。
(2) 实例：
//String类的无参的构造方法。
public class Demo4 {
public static void main(String[] args) {
String str = new String();//调用String类的无参的构造方法，相当于String str = " ";
System.out.println("字符串的内容是："+str);
}
}
(3) 运行结果：
2.String(byte[] bytes) ;
(1) 该方法用于使用一个字节数组构建一个字符串对象；
(2) 实例：
//String(byte[] bytes) 使用一个字节数组构建一个字符串对象
public class Demo5 {
public static void main(String[] args) {
byte[] buf = {97,98,99};//这些字节数组里存储的都是那些字符对应的码值
String str = new String(buf); //使用一个字节数组构建一个字符串对象
System.out.println("字符串的内容："+str);
}
}
(3) 运行结果：
3.String(byte[] bytes, int offset, int length)
(1) 参数详解：
bytes：要解码的数组(解码就是把数字转换成数字代表的字符)
offset：指定从数组中那个索引值开始解码。也就是说从字节数组中的哪一位开始查找对应的字符。
length：要解码多少个元素。也就是要查找多少个字符。
(2) 实例：
public class Demo6 {
public static void main(String[] args) {
byte[] buf = {97,98,99};
String str = new String(buf,1,2);//使用一个字节数组构建一个字符串对象，指定开始解码的索引值和解码的个数
System.out.println("字符串的内容："+str);
}
}
(3) 运行结果：
4.String(char[] value);
(1) 使用一个字符数组构建一个字符串。
(2) 实例：
//String(char[] value) 使用一个字符数组构建一个字符串。
public class Demo7 {
public static void main(String[] args) {
char[] arr = {'马','上','毕','业','了'};
String str = new String(arr); //使用字符数组构建一个字符串
System.out.println("字符串的内容："+str);
}
}
(3) 运行结果：
5.String(char[] value, int offset, int count);
(1) 使用一个字符数组构建一个字符串， 指定开始的索引值，与使用字符个数。
(2) 实例：
public class Demo8 {
public static void main(String[] args) {
char[] arr = {'马','上','毕','业','了'};
String str = new String(arr,2,2);
System.out.println("字符串的内容："+str);
}
}
(3) 运行结果：
6.String(int[] codePoints,int offset,int count);
(1) 实例：
public class Demo9 {
public static void main(String[] args) {
int[] buf = {65,66,67};
String str = new String(buf,0,3);
System.out.println("字符串的内容："+str);
}
}
(2) 运行结果：
三.String类的普通常用方法
1.获取的方法
(1) 方法：
①int length()：该方法用于获取字符串的长度。
②char charAt(int index)：传入一个索引值，根据索引值获取特定位置的字符 (注意角标越界)。
③int indexOf(String str)：查找子串第一次出现的索引值,如果子串没有出现在字符串中，那么则返回-1表示。
④int lastIndexOf(String str)：查找子串最后一次出现的索引值 , 如果子串没有出现在字符串中，那么则返回-1表示。
(2) 实例：
public class Demo3 {
public static void main(String[] args) {
String str = "abc你好ab你好";
System.out.println("字符串的字符个数:" + str.length());
System.out.println("根据索引值获取对应的字符:"+ str.charAt(3));
System.out.println("查找子串第一次出现的索引值：" + str.indexOf("你好"));
System.out.println("查找子串最后一次出现的索引值：" + str.lastIndexOf("你好"));
}
}
(3) 运行结果：
2.判断的方法
(1) 方法：
①boolean endsWith(String str)：判断是否以指定字符串结束。
②boolean isEmpty()：判断长度是否为0，也就是判断字符串是否为空内容。
③boolean contains(CharSequences)：判断是否包含指定序列，该方法可以应用于搜索。
④boolean equals(Object anObject)：判断是否相等，判断两个字符串的内容是否一致。是区分大小写的。
⑤boolean equalsIgnoreCase(String anotherString) 忽略大小写是否相等，验证码都是忽略大小写的。
(2) 实例：
public class Demo11 {
public static void main(String[] args) {
String str = "Demo.java";
System.out.println("是否以指定 的字符串结束:"+ str.endsWith("java"));
System.out.println("是否以指定 的字符串结束:"+ str.endsWith("va"));
System.out.println("是否以指定 的字符串结束:"+ str.endsWith("ja"));
System.out.println("判断字符串是否为空内容："+str.isEmpty());
System.out.println("判断字符串是否包含指定的内容："+ str.contains("Demo"));
System.out.println("判断两个 字符串的内容是否一致："+ "DEMO.JAVA".equals(str));
System.out.println("判断两个字符串的内容是否一致(忽略大小写比较):"+ "DEMO.JAVA".equalsIgnoreCase(str));
}
}
(3) 运行结果：
3.转换的方法
注意：字节数组与字符数组、字符串他们三者之间是可以互相转换的。
(1) 方法：
①char[] toCharArray() ：将字符串转换为字符数组。
②byte[] getBytes()：将字符串转换为字节数组。
(2) 实例：
import java.util.Arrays;
public class Demo12 {
public static void main(String[] args) {
String str = "Demo.java";
char[] buf = str.toCharArray(); //把字符串转换字符数组
System.out.println("字符数组："+ Arrays.toString(buf));
byte[] buf2 = str.getBytes(); //把字符串转字节数组
System.out.println("字节数组："+ Arrays.toString(buf2));
}
}
(3) 运行结果：
4.其他的方法
注意：CharSequence是一个接口，而String类是它的实现类。
(1) 方法：
①String replace(String oldChar, String newChar)：替换。
②String[] split(String regex)：切割。
③String substring(int beginIndex)：指定开始的索引值截取子串。
④String substring(int beginIndex, int endIndex)：指定开始与结束的索引值截取子串。
⑤String toUpperCase()：转大写。
⑥String toLowerCase()：转小写。
⑦String trim()：去除字符串首尾的空格。
(2) 实例：
public class Demo5 {
public static void main(String[] args) {
String str = "我们不学习";
System.out.println("指定新内容替换旧 的内容:"+ str.replace("不", "要好好"));
str = "我们要-好-好-学-习";//切成5份
String[] arr = str.split("-"); //根据指定的字符进行切割 。
System.out.println("字符串数组的内容："+ Arrays.toString(arr));
str = "马上要毕业了";
System.out.println("指定开始的索引值截取子串:"+ str.substring(2));
System.out.println("指定开始与结束的索引值截取子串:"+ str.substring(2,6)); //方法重载，包头不包尾 注意：截取的内容是包括开始的索引值，不包括结束的索引值， 截取的位置是结束的索引值-1.
//注意，凡是Java方法中出现开始和结束的索引值，都是遵循包头不包尾
str = "abC中国";
System.out.println("转大写：" + str.toUpperCase());
str = "AbdfSDD";
System.out.println("转小写："+ str.toLowerCase());
str = " 我们要 努力学习 ";
System.out.println("去除字符串首尾的空格："+ str.trim());
}
}
(3) 运行结果：
四.字符串实例：
1.实例一
(1) 需求：自己实现trim的方法。
(2) 分析：只要我们能确定开始StartIndex和结束endIndex这两个位置的索引值，那么这个题目我们就能做出来。最关键的是这两个索引值应该如何确定？把这两个变量定义成这个字符串开始与结束的位置，首先用startIndex确定是否是空字符，是的话就前进一步，结束的索引值也要判断是否是空字符。是的话就后退一步。
(3) 实例：
public class Demo1 {
public static void main(String[] args) {
String str =" 我们 快要毕业了 ";
System.out.println(myTrim(str));
}
public static String myTrim(String str){
//先转换成字符 数组
char[] arr = str.toCharArray();
//定义两个 变量记录开始与结束 的索引值
int startIndex = 0 ;
int endIndex = arr.length -1;
//确定开始 的索引值
while(true){
if(arr[startIndex]==' '){
startIndex++;
}else{
break;
}
}
//确定结束 的索引值：
while(true){
if(arr[endIndex]==' '){
endIndex--;
}else{
break;
}
}
//截取子串返回
return str.substring(startIndex,endIndex+1);
}
}
(4) 运行结果：
2.实例二
(1) 需求：
获取上传文件名 "D:\\20180225\\day01\\Demo1.java"。从字符串中获取文件名为Demo1.java。
(2) 分析：
可以用切割的方法，按照"\\"来进行切割，把它分割成好几部分，返回一个字符串的数组，只获取字符串数组的最后一个就可以了；也可以用截取的方法，只要能确定D的索引值就可以了。那么如何确定D的索引值？也就是最后"\\"的索引值+1就是D的索引值。
(3) 实例：
public class Demo2 {
public static void main(String[] args) {
String str = "D:\\20180225\\day01\\Demo1.java";
getFileName(str);
}
public static void getFileName(String path){
int index = path.lastIndexOf("\\");//转义
String fileName = path.substring(index+1);
System.out.println("文件名："+ fileName);
}
}
(4) 运行结果：
3.实例三
(1) 需求：
将字符串对象中存储的字符反序。例如：新中国好 -----> 好国中新。
(2) 分析：
只需要把它转换成一个字符数组，转成字符数组后就可以定义两个索引值，一个是开始的索引值startIndex，另一个是结束的索引值endIndex，这两个交换后，startIndex向前++，endIndex向后--，再继续进行交换，(要定义两个变量记录要交换位置的索引值，只要startIndex<endIndex那么就进行交换)，当这个字符数组被反转后，我们只需要再使用这个字符数组构建一个字符串即可。
(3) 实例：
public class Demo3 {
public static void main(String[] args) {
String str = "新中国好";
System.out.println("翻转后的字符串："+ reverse(str));
}
public static String reverse(String str){
char[] arr = str.toCharArray();
for(int startIndex = 0 , endIndex=arr.length-1 ; startIndex<endIndex; startIndex++,endIndex--){
char temp = arr[startIndex];
arr[startIndex] = arr[endIndex];
arr[endIndex] = temp;
}
//使用字符数组构建一个字符串。
return new String(arr);
}
}
(4) 运行结果
4.实例四
(1) 需求：
求一个子串在整串中出现的次数 。
(2) 分析：
先定义一个变量记录出现的次数，count = 0;接着定义一个变量用于记录开始寻找的索引值的位置，int fromIndex = 0;首先从索引值为0的地方开始找，找到第一个Java后，count++，然后继续开始向后寻找，第一次找到Java的索引值是3，第二次是从java后的a开始继续往后找，而这个a的索引值是7，那么第二次的fromIndex应该怎么计算出来？首先确定第一次java的索引值为3，接着java的长度是4，所以第二次从a的索引值7开始找。
(3) 实例：
public class Demo4 {
public static void main(String[] args) {
String str = "abcjavaabcjavaphpjava"; //统计java在这个字符串中出现的次数
getCount(str, "java");
}
//统计子串出现 的次数
public static void getCount(String str,String target){
int count = 0 ; //用于记录出现的次数
int fromIndex = 0; // 记录从那个索引值开始寻找目标子串
while((fromIndex = str.indexOf(target, fromIndex))!=-1){
//如果indexof方法返回 的不是-1，那么就是已经找到了目标 元素。
//如果这个方法返回的是-1意味着再往后找就没有了，所以循环的结束条件是只要不等于-1就继续往后找。
//indexOf会返回一个索引值，找到之后会有一个返回值，比如返回3，那么就应该用fromIndex来记录它。
//因为下次开始寻找的位置是
count++;
fromIndex = fromIndex+target.length();
}
System.out.println("出现的次数："+ count);
}
}
(4) 运行结果：
五.StringBuffer类
1.前言
(1) 字符串的特点：字符串是常量，它们的值在创建之后不能更改。
(2) 字符串的内容一旦发生了变化，那么马上会创建一个新的对象。
(3) 实例：
public class Demo1 {
public static void main(String[] args) {
String str1 = "hello";
String str2 = str1+" world";
System.out.println("str1与str2是同一个 对象吗？"+(str1==str2));
}
}运行结果如下图所示：
2.StringBuffer类：
(1) 字符串的内容不适宜频繁修改，因为一旦修改马上就会创建一个新的对象。如果不断频繁修改，在内存中就会有很多的字符串对象存在。如果需要频繁修改字符串的内容，建议使用字符串缓冲类（StringBuffer）。
(2) StringBuffer 是字符串的缓冲区，其实就是一个存储字符的容器，用它对字符串进行增删查改会非常方便。
(3) 疑问：使用Stringbuffer无参的构造函数创建 一个对象时，默认的初始容量是多少？如果长度不够使用了，自动增长多少倍？
通过查看源代码我们发现，StringBuffer 底层是依赖了一个字符数组才能存储字符数据的，该字符串数组默认 的初始容量是16， 如果字符数组的长度不够使用时，自动增长1倍，也就是是原来的2倍。
(4) 实例：
public class Demo2 {
public static void main(String[] args) {
//先使用StringBuffer无参的构造函数创建一个字符串缓冲类。
StringBuffer sb = new StringBuffer();
sb.append("java");
sb.append("java");
sb.append("java");
sb.append("java");
sb.append("java");
System.out.println(sb);//其初始容量为16个字符，但是为什么可以输出20个字符。
}
}运行结果如下图所示：
3.StringBuffer类具备的方法：
(1) 增加的方法：
①append(boolean b) ：有很多重载的方法，可以添加任意类型的数据到容器中。
package stringbuffer;
public class append {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
//添加的方法
sb.append("abc");
sb.append(true);//把true变成字符串输出
sb.append(3.14f);
System.out.println("字符串缓冲类的内容："+sb);
}
}运行结果如下图所示：
②insert(int offset, boolean b)：指定插入的索引值，插入对应的内容。
public class insert {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
//插入的方法
sb.append("abc");
sb.insert(2,"小明");//在b和c之间插入小明，因为b和c之间的索引值是2.
System.out.println("字符串缓冲类的内容："+sb);
}
}
运行结果如下图所示：
(2) 删除的方法
①delete(int start, int end)：根据指定的开始与结束的索引值删除对应的内容。
public class delete {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("abc");
sb.insert(2,"小明");
System.out.println("执行删除操作前："+sb);
//删除的方法
sb.delete(2, 4);//删除小明,删除的时候也是包头不包尾的。
System.out.println("执行删除操作后："+sb);
}
}运行结果如下图所示：
②deleteCharAt(int index)：根据指定 的索引值删除一个字符。
public class deleteCharAt {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("abc");
sb.insert(2,"小明");
System.out.println("执行删除操作前："+sb);
//删除
sb.deleteCharAt(3);//删除"明"
System.out.println("执行删除操作后："+sb);
}
}运行结果如下图所示：
(3) 修改的方法
①replace(int start, int end, String str)：根据指定 的开始与结束索引值替代成指定的内容。
public class replace {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("abc");
sb.insert(2,"小明");
System.out.println("执行替换操作前："+sb);
//替换
sb.replace(2,4,"张三");//把小明替换成张三
System.out.println("执行替换操作后："+sb);
}
}运行结果如下图所示：
②reverse()：反转字符串缓冲类的内容。abc--->cba
public class reverse {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("abc");
sb.insert(2,"小明");
System.out.println("执行反转操作前："+sb);
//反转字符串的内容
sb.reverse();
System.out.println("执行反转操作后："+sb);
}
}运行结果如下图所示：
③setCharAt(int index, char ch)：把指定索引值的字符替换成指定的字符。
public class setCharAt {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("abc");
sb.insert(2,"小明");
System.out.println("执行替换操作前："+sb);
//替换单个字符
sb.setCharAt(3, '红');//把'明'替换成'红'
System.out.println("执行替换操作后："+sb);
}
}运行结果如下图所示：
④substring(int start, int end)：根据指定的索引值截取子串。
public class substring {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("abc");
sb.insert(2,"小明");
//截取小明
String subString = sb.substring(2, 4);//返回类型是String类型
System.out.println("子串的内容："+subString);
}
}运行结果如下图所示：
⑤ensureCapacity(int minimumCapacity)：指定StringBuffer内部的字符数组长度的。基本很少用到。
如果想指定字符数组的初始容量可以使用带参的构造方法来指定。
public class ensureCapacity {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("abc");
sb.insert(2,"小明");
sb.ensureCapacity(20);//指定字符数组的长度为20，默认是16
}
}(4) 查看的方法
①indexOf(String str, int fromIndex)：查找指定的字符串第一次出现的索引值,并且指定开始查找的位置。
public class indexOf {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("abcjavaabc");
int index = sb.indexOf("java", 0);//从索引值为0的位置开始找
System.out.println("返回的索引值为："+index);
}
}运行结果如下图所示：
②capacity()：查看当前字符数组的长度。
public class capacity {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("abcjavaabc");
//查看当前字符数组的长度
System.out.println("当前字符数组的长度是："+sb.capacity());//16
sb.append("javajava");//此时存储了18个字符，那么这时候当前字符数组的长度又是多少？
System.out.println("当前字符数组的长度是："+sb.capacity());//34，因为字符串的长度会增长一倍+2
}
}运行结果如下图所示：
③length()：查看存储字符的个数。
public class length {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("abcjavaabc");
sb.append("javajava");
System.out.println("查看当前字符数组存储字符的个数："+sb.length());
}
}运行结果如下图所示：
④charAt(int index)：根据指定的索引值查找字符
public class charAt {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("abcjavaabc");
sb.append("javajava");
System.out.println("根据指定的索引值查找字符："+sb.charAt(2));
}
}运行结果如下图所示：
⑤toString()：把字符串缓冲类的内容转成字符串返回。
现在stringBuffer里存储了很多的字符数据，假设有一个test方法，这个方法是要接收一个字符串的，而字符的内容是存储在StringBuffer里的。而现在调用这个test方法应该如何调用呢？首先肯定不能把sb传进去，因为类型不一样，如何把这个容器中存储的字符转换成字符串呢？可以用sb.toString()方法，这样就会把里面存储的内容，以字符串的形式返回。
public class toString {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("abcjavaabc");
sb.append("javajava");
String content = sb.toString();
test(content);
}
public static void test(String str){
System.out.println("字符串缓冲类的内容是："+str);
}
}运行结果如下图所示：
六.StringBuilder类
1.StringBuffer 与 StringBuilder的相同处与不同处：
(1) 相同点：
①两个类都是字符串缓冲类。
②两个类的方法都是一致的。(只要是StringBuffer有的方法，StringBuilder一样有)
(2) 不同点：
①StringBuffer是线程安全的,操作效率低 ，StringBuilder是线程非安全的,操作效率高。
(所谓的安全是指在一个时间段里只会允许一个线程来操作这份代码，而线程不安全是指在一个时间段里一份代码可以由多个线程来执行)
②StringBuffer是jdk1.0出现 的，StringBuilder 是jdk1.5的时候出现的。
2.推荐使用：StringBuilder，因为操作效率高。