八(一)、常用类之String、StringBuffer、StringBuilder

一、String类：

字符串，使用一对“”引起来；

1.String 声明为final 不可被继承；

2.实现了

• Seriablizable:表示字符串是支持序列化的；
• Compareble ：可比较大小
• CharSequence接口：提供对多种不同类型的统一只读访问 序列。

3.String内部声明了final char[] value数组,用于存储char 数组；

4.String:代表不可变的字符序列；简称：不可变性；

• 体现1:当对字符串重新赋值时，需要重新制定内存区域赋值，不能使用原有的value进行赋值
• 体现2:当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value值进行赋值
• 体现3.当调用replace方法时，也需要重新指定内存区域赋值，不能使用原有的value值进行赋值

说明：

    @Test
    public void test1() {
        String s1 = "abc";// 自面量方式创建
        String s2 = s1;
        System.out.println(s1 == s2);
        s1 = "hello";
        System.out.println(s1 == s2);
        System.out.println(s1);
        System.out.println(s2);

    }

这里 第一个 System.out.println(s1 == s2);这里是true;

s1 = "hello";

System.out.println(s1 == s2);

这里是false，因为s1就是hello,s2还是abc,这里区别于其他引用类型对象的赋值；也就是当对字符串重新赋值时，需要重新制定内存区域赋值，不能使用原有的value进行赋值

@Test
    public void test4() {
        String s1 = "abcdef";
        String s2 = "abc";
        s2 += "def";// abcdef
        System.out.println("s1:" + s1);
        System.out.println("s2:" + s2);
        System.out.println(s1 == s2);
    }

s1:abcdef;

s2:abcdef;

s1== s2的结果是false

体现了当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value值进行赋值；

@Test
    public void test4() {
        String s4 = "abc";
        String s5 = s4.replace("a", "m");
        System.out.println("s4:" + s4);
        System.out.println("s5:" + s5);
    }

s4:abc

s5:mbc

体现了当调用replace方法时，也需要重新指定内存区域赋值，不能使用原有的value值进行赋值

二、String 创建的方式

1.通过new+构造器的方式

说明：

给一个字符串赋值,此时的字符串声明在方法区的字符串常量池中;

问：String s = new String("abc");方式创建对象，在内存中创建了几个对象

答：一个是堆空间的new 对象，另一个 char 数组 对应常量池中的数据

 String s = new String("0");
 for(int i=0;i<=5;i++){
 s+=i;
 }
 System.out.println(s)

内存解析：

再看一个例子：

@Test
    public void test2() {

        String s1 = "ABC";// 在方法区 中的 字符串常量池中
        String s2 = "ABC";// 在方法区 中的 字符串常量池中
        String s3 = new String("ABC");// 在 堆空间中
        String s4 = new String("ABC");// 在 堆空间中
        System.out.println(s1 == s2);// true
        System.out.println(s3 == s4);// false;
        System.out.println(s1 == s4);// false;
        Person p1 = new Person("Tom",1);
        Person p2 = new Person("Tom",1);
        System.out.println(p1.getName() == p2.getName());
        System.out.println(p1.getAge() == p2.getAge());
    }

class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

}

2.通过字面量方式（区别于new）

说明：

通过字面量方式给一个字符串赋值,此时的字符串声明在方法区的字符串常量池中;

注意：字符串常量池中不保存相同内容的字符串；也就是String的不可变性；

 String s = "0";
 for(int i=0;i<=5;i++){
 s+=i;
 }
 System.out.println(s)

三、字符串的特性：

常量与常量的拼接结果在常量池；而且常量池中不会存在相同内容的常量；
字符串拼接：只要其中一个是变量，结果就在堆中；如果拼接的结果调用 intern（），返回值就在常量池中

@Test
    public void test3() {
        String s1 = "javaEE";
        String s2 = "hadoop";
        String s3 = "javaEEhadoop";
        String s4 = "javaEE"+"hadoop";
        String s5 = s1 +"hadoop";
        String s6 = "javaEE"+s2;
        String s7 = s1+s2;
        String s8 = s7.intern();
        System.out.println(s3 == s4);
        System.out.println(s3 == s5);
        System.out.println(s3 == s6);
        System.out.println(s5 == s6);
        System.out.println(s3 == s8);
        final String s9 = "hadoop";
        String s10 = "javaEE"+s9;
        System.out.println(s3 == s10);//这里 s9是常量
        
        
        
    }

s3 == s4:结果是true

s3 == s5：结果是false；

s3 == s6：结果是false；

s5 == s6：结果是false；

s3 == s8:结果是true

s3 == s10这里也是true

原因就是我们这里的特性；

 五、String的常用方法：

1. int length():返回字符串长度；
2. char charAt(int index):返回某索引处的字符串 return value[index];
3. boolean isEmpty():判断空字符串 return value.length == 0;
4. String toLowerCase():使用默认语言环境，将String中的所有字符串转化为小写
5. String toUpperCase():使用默认语言环境，将String中的所有字符串转化为大写
6.  String trim():去除字符串 首尾的空格；
7. boolean equals(Object obj)比较字符串内容是否相同
8. boolean equalsIgnoreCase(String anOtherString)与equals方法类似，忽略大小写比较字符串内容是否相同
9. String Concat(String str):将指定字符串连接到此字符串的结尾，等价于 “+”
10. int compareTo(String anotherString),比较两个字符串的大小；
11. String subString(int beginIndex):返回一个新的字符串，他是此字符串的重beginindex 开始截取
12. String subString(int beginIndex，int endIndex):返回一个新的字符串，他是此字符串的重beginindex 开始截取 endIndex结束的
14. boolean endsWith(String suffix):测试字符串是否以指定的后缀结束
15. boolean startWith(String prefix):测试此字符串是否以指定的前缀开始；
16. boolean startWith(string prefix,int toffset)测试此字符串从指定索引开始的子字符串是否以指定的前缀开始
17. boolean contains(charSequence s):当且仅当此字符串包含指定的char值序列时，返回true；
18. int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引
19. int indexOf(String str,int fromIndex);返回指定字符串在此字符串中第一次出现的索引
20. int lastIndexOf(String str,int fromIndex);返回指定字符串在此字符串中最右边出现的索引
21. int lastIndexOf(String str,int fromIndex);返回指定字符串在此字符串中最右边出现的索引
22. 注意：indexOf 和 lastIndexOf方法如果未找到，都是返回-1
24. String replace(char oldChar,char newChar):返回一个新的字符串，他是通过newChar替换此字符串中出现的国有oldChar;
25. String replace(charSequence target,charSequence replacement):使用指定的字面值替换此字符所有匹配字面值目标序列的子字符串
26. String replaceAll(String regex,String replacement):使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串
27. String replaceFirst(String regex,String replacement):使用给定的replacement替换此字符串所有匹配给定的正则表达式的第一个子字符串
29. boolean matches(String regex):告知此字符串是否匹配给定的正则表达式
30. String[] split(string regex);根据给定正则表达式的匹配拆分此字符串；
31. String[] split(string regex,int limit);根据给定正则表达式的匹配拆分此字符串；最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中

@Test
    public void test1() {
        String s1 = "Helloworld";
        String testNull = null;
        String testEmpty = "";
        System.out.println(s1.length());//获取数组长度
        System.out.println(s1.charAt(0));//获取指定位置的字符
        System.out.println(s1.isEmpty());//判断字符串是否为空
///        System.out.println(testNull.isEmpty());//报错
        System.out.println(testEmpty.isEmpty());//判断字符串是否为空
        System.out.println(s1.toUpperCase());//转换为大写
        System.out.println(s1);//Helloworld 体现了不可变性
        System.out.println(s1.toLowerCase());//转换为小写
        
        String s2 = " Hello    World  ";
        String s3 = s2.trim();//去除字符串首尾的空格
        System.out.println("----"+s2+"------");//体现了不可变性
        System.out.println("----"+s3+"------");
        
        String s4 = "HELLOWORLD";
        System.out.println(s1.equals(s4));
        System.out.println(s1.equalsIgnoreCase(s4));//忽略大小写比较字符串内容
        
        String s5 = "abc";
        System.out.println(s5.concat("efg"));//拼接字符串
        
        String s6 = "abf";
        System.out.println(s5.compareTo(s6));//涉及到字符串排序
        
        System.out.println(s6);
        System.out.println(s6.substring(1));
        System.out.println(s1.substring(2,5));//左闭右开 从2开始 到5结束 不包括5
        
        boolean str1 = s1.endsWith("rld");
        System.out.println(str1);
        
        boolean str2 = s1.startsWith("he");
        System.out.println(str2);
        
        boolean str3 = s1.startsWith("He");
        System.out.println(str3);
        

        boolean str4 = s1.startsWith("He",0);
        System.out.println(str4);
        
        boolean str5 = s1.startsWith("el",1);
        System.out.println(str5);
        
        boolean str6 = s1.contains("w");
        System.out.println(str6);
        
        int str7 = s1.indexOf("lo");
        System.out.println(str7);
        
        int str8 = s1.indexOf("lol");
        System.out.println(str8);
        
        int str9 = s1.indexOf("lo",5);
        System.out.println(str9);
        
        int str10 = s1.lastIndexOf("lo",5);
        System.out.println(str10);
        
        int str11 = s1.lastIndexOf("w");
        System.out.println(str11);
    }

    @Test
    public void test2() {
        String str1 = "Hello World";
        String str2 = str1.replace("Hello", "Byby");
        System.out.println(str1);
        System.out.println(str2);
        String str3 = str1.replace('H', 'B');
        System.out.println(str3);
        
        String str = "12hello34world5java789mysql456";
        String string = str.replaceAll("\d+", ",").replaceAll("^,|,$", "");//\d匹配数字， +表示有多个数字，^,|,$ 开头或者结尾有逗号
        System.out.println(string);
        
        str = "12345";
        boolean matches = str.matches("\d+");
        System.out.println(matches);
        String tel = "0571-4534289";
        boolean result = tel.matches("0571-\d{7,8}");//0571开头 ，数字是7-8位
        System.out.println(result);
        
        
        str = "HELLO|WORLD|JAVA";
        String[] strs = str.split("\|");
        for(int i = 0;i<strs.length;i++) {
            System.out.println(strs[i]);
        }
        str2 = "hellow.world.java";
        String[] strs2 = str2.split("\.");
        for(int i = 0;i<strs2.length;i++) {
            System.out.println(strs2[i]);
        }
        

    }

 ★★★相关面试题：

package commonmethod;

public class Day20StringInterviewTest9 {

    String str = new String("good"); 
7     char[] ch = {'t','e','s','t'};
    public void change(String str,char ch[]) {
        str = "test ok";

        ch[0] = 'b';
    }
    public static void main(String[] args) {
        Day20StringInterviewTest9 ex = new Day20StringInterviewTest9();
        ex.change(ex.str, ex.ch);
        System.out.println(ex.str);18         System.out.println(ex.ch);
        
    }
    
}

这里的输出结果 ：

good
best

对于这个结果，前两个解释一下；想看ex.str为什么结果还是good呢？

首先需要两个知识点：

①在对象的方法中，值传递的规则是：如果形参是基本数据类型时，方法参数传递的是参数本事的值，如果参数是引用数据类型时，那个参数传递的是地址值（不是对象本身）；（以下内存解析中0X开头的部分）；

②String 值的不可变性；

ex.change(ex.str, ex.ch);==》形参：ex.str，其实是0x002;

str = "test ok";赋值一个新的值；常量池中没有 “test ok”,那么常量池中创建一个value值是 “test ok”的对象(这个原则，就是String不可变性的体现（即体现1）)；此时在该方法中产生一个 str的副本，该str副本这里称 strx吧；strx 指向test ok ；最后方法结束自动销毁（由jvm垃圾回收）；最后打印出ex.str,就是打印传入的对应地址值的value值即：good；

这里的ch就是普通的引用类型变量；如果要做扩展，那么他可以换成某个对象，那么结果是什么呢？

附上内存解析图：（参考文章https://zhuanlan.zhihu.com/p/266885142）

　　　　

　　　　

这里补充例子：

    public static String changeString(String str){
        return str+"ABC";
    }
    public static int changInt(int a){
        a = 0;
        return a;
    }
    @Test
    public void testString1() {
        String str1="abc123";
        int a = 23;
        System.out.println(str1);
        System.out.println(changInt(a));
        System.out.println(a);
    }

这里的结果是 ？

 abc123

abc123ABC

23

 System.out.println(str1)：这个还是跟上面那个套路是一样的；

System.out.println(a);是23原因是在ChangeInt方法中 a 其实是 a·,它在方法结束后自动销毁了；所以最后a仍然是 23；

六、String的转换：

1.String与基本数据类型的转换：

    String-->基本数据类型、包装类:调用包装类的静态方法；parstXXX(str);
    基本数据类型、包装类--》string 调用S挺重载的valueOf(xxx);

    @Test
    public void test1() {
        String str1 = "123";
        int num = Integer.parseInt(str1);
        String str2 = String.valueOf(num);
        String str3 = num+"";
        System.out.println(str2);
        System.out.println(str3 == str1);
    }

2.String 其他数据机构的转换

string 与char数组的转换 调用string toCharArray方法
string 与byte数组的转换 调用string getBytes方法
编码：String-->byte[]:调用string getBytes方法
解码：byte[]-->string:调用String的构造器；
 说明：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码

    @Test
    public void test1() throws UnsupportedEncodingException {
        String str1 = "abc123中国";//题目 把 abc123 变成 a321cb,那么就需要变成字符串再反转；
        char[] charStr = str1.toCharArray();
        for(int i=0;i<charStr.length;i++) {
            System.out.println(charStr[i]);
        }
        
        char[] arr = new char[] {'h','e','l','l'};
        String str2 = new String(arr);
        System.out.println(str2);
        System.out.println(arr);
        System.out.println(Arrays.toString(arr));
        byte[] toByteArr = str1.getBytes();//可以设置编码
        for(int i=0;i<toByteArr.length;i++) {
            System.out.println(toByteArr[i]);
        }
        System.out.println(toByteArr);
        System.out.println(Arrays.toString(toByteArr));
        byte[] toByteArr1 = str1.getBytes("gbk");//可以设置编码
        System.out.println(Arrays.toString(toByteArr1));
        
        String str3 = new String(toByteArr1);//设置解码
        System.out.println(str3);
        
        String str4 = new String(toByteArr1,"gbk");//解码没有出现乱码。原因是：编码集和节目集一致
        System.out.println(str4);
    }

 七、String、StringBuilder 、StringBuffer

 1.String、StringBuilder 、StringBuffer的区别

String:不可变的字符序列 底层使用char[]存放数据；
 StringBuffer:可变的字符序列，线程安全，效率低；底层使用char[]存放数据；
 StringBuilder:可变的字符序列，线程不安全，效率高；底层使用char[]存放数据；
 源码分析
 String str = new String()//new char[0];
 String str1 = new String("abc")//new char[]{'a','b','c'}
 
 StringBuffer sb1 = new StringBuffer();//new char[16];
 StringBuffer sb1 = new StringBuffer("abc");//new char[19]; value[0] = 'a',value[1] = 'b',value[2] = 'c'
 问题1.System.out.println(sb1.length)//3
 问题2，扩容问题，若果要添加的数据底层数组承载不了，那就需要扩容底层数组；把原来的数组复制到新的value数组；默认情况下扩容为原来容量的2倍+2（详情可参考源码）
 
 指导建议：开发中建议大家使用 StringBuilder(int capacity) 或者StringBuffer(int capacity)

2.String 转换成 StringBuilder 、StringBuffe

StringBuffer sb = new StringBuffer("aaa");

StringBulider sb = new StringBulider("aaa");

String str = new String(sb);

or

String str = sb.toString();

3.StringBuffer的常用方法：

StringBuffer append(xxx):提供了很多append方法，用于字符串拼接
  StringBufferdelete(int start,int end)删除指定位置的内容(左闭右开)
  StringBuffer replace(int start,int end,String str)把[start,end)位置替换为
  StringBuffer insert(int offset,xxx),在指定位置插入XXX
 reverse(),把当前字符串倒叙
 public int indexOf(String str)
 public String subString(int start,int end)
 public int length();
 public char charAt(int n)
 public void setCharAt(int n,char ch);
 总结：
 增：append()
 删：delete(int start,int end)
 改：public void setCharAt(int n,char ch);/StringBuffer replace(int start,int end,String str)
 查：public int indexOf(String str)
 插：StringBuffer insert(int offset,xxx)
 长度length();

    @Test
    public void test1()  {
        StringBuffer sb1 = new StringBuffer();
        sb1.append(1);
        sb1.append("1");
        System.out.println(sb1.toString());
        sb1.delete(0, 1);
        System.out.println(sb1.toString());
        sb1.insert(0, "112123");
        System.out.println(sb1.replace(0, 2, "AA"));
        System.out.println(sb1.toString());
        sb1.insert(0, false);
        System.out.println(sb1.toString());
        System.out.println(sb1.reverse());
        System.out.println(sb1.length());
        System.out.println(sb1.indexOf("eslaf"));
        System.out.println(sb1.charAt(10));
         sb1.setCharAt(10, 'x');
        System.out.println(sb1.toString());
    }

 补充面试题：

1.字符串反转：abcdefg==>abfedcg

    public void testInterview1() {
        String str = "abcdefg";
        String str1 = str.substring(0,2);
        String str2 = str.substring(2,6);
        String str3 = str.substring(6);
        StringBuffer sb = new StringBuffer(str2);
        String res = str1+sb.reverse()+str3;
        System.out.println("字符串反转："+res);    
    }

2.abkkcadkabfkabkskab 问，ab一共出现过几次？

@Test
    public void testInterview2() {
        String str = "abkkcadkabfkabkskab";
        int count = 0;
        int index = -1;
        for(int i=0;i<str.length();i++) {
            if(i == 0) {
                index = str.indexOf("ab",0);
            }else {
                index = str.indexOf("ab",index+1);
            }
            
            
            if(index >-1) {
                count = count+1;
                
            }else {
                break;
            }
        }
        System.out.println(str.length());
        System.out.println(count);
        
    }

3.获取两个字符串中的最大相同子串；str1 = "abcwerthelloyuiodef";str2 = "cvhellobnm";

@Test
    public void testInterviwq3() {
        String str1 = "abcwerthelloyuiodefn";
        String str2 = "cvhellodefnm";
        String min = "";
        String max = "";
        StringBuffer sb = new StringBuffer();
        if(str1.length()<= str2.length()) {
            min = str1;
            max = str2;
        }else {
            min = str2;
            max = str1;
        }
        for(int i=0;i<min.length();i++) {
            for(int x=0,y=min.length()-i;y<=min.length();x++,y++) {
                String tem = min.substring(x,y);
                System.out.println(tem);
                if(max.contains(tem)) {
                    sb.append(tem+"|");
                }
            }
            if(sb.length()>1) {
                break;
            }
        }
        System.out.println("最大相同子串："+sb.toString());
    }

4.StringBuffer中注意的一个地方：

@Test
    public void testInterview4() {
        String str = null;
        StringBuffer sb = new StringBuffer();
        sb.append(str);//appendNull方法把 ‘null’ append进去了；
        System.out.println(sb.length());
        StringBuffer sb2 = new StringBuffer(str);//这里有一个 str.length;这里str是null,所以报错
        System.out.println(sb.length());
        
    }