String

• String字符串：使用一对” “引起来来标识。
• String声明为final的，不可被继承。
• String实现了Serializable接口：表示字符串是支持序列化的。
  • 实现了Comparable接口：表示String可以比较大小。
• String内部定义了final、char[]、value 用于存储字符串数据。
• String：代表不可变的字符序列。简称：不可变性。
  • 体现：①：当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
  • ②：当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值。不能使用原有的value进行赋值。
  • ③：当调用String的replace() 方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
• 通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。
• 字符串常量池是不会对相同内容的字符串开辟不同的空间的。

**Demo：

**

    public void test1(){
        String s1 = "abc";//字面量的定义方式
        String s2 = "abc";
        s1 = "hello";
    
        System.out.println(s1 == s2);//比较s1和s2的地址值
    
        System.out.println(s1);//hello
        System.out.println(s2);//abc
    
        System.out.println("*****************");
    
        String s3 = "abc";
        s3 += "def";
        System.out.println(s3);//abcdef
        System.out.println(s2);
    
        System.out.println("*****************");
    
        String s4 = "abc";
        String s5 = s4.replace('a', 'm');
        System.out.println(s4);//abc
        System.out.println(s5);//mbc
    
    }

}

String的实例化方式：

• 通过字面量定义的方式。
• 通过new + 构造器的方式。

 面试题：String s = new String("abc");方式创建对象，在内存中创建了几个对象？
        两个:一个是堆空间中new结构，另一个是char[]对应的常量池中的数据："abc"

 */
@Test
public void test2(){
    //通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中。
    String s1 = "javaEE";
    String s2 = "javaEE";
    //通过new + 构造器的方式:此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
    String s3 = new String("javaEE");
    String s4 = new String("javaEE");

    System.out.println(s1 == s2);//true
    System.out.println(s1 == s3);//false
    System.out.println(s1 == s4);//false
    System.out.println(s3 == s4);//false

    System.out.println("***********************");
    Person p1 = new Person("Tom",12);
    Person p2 = new Person("Tom",12);

    System.out.println(p1.name.equals(p2.name));//true
    System.out.println(p1.name == p2.name);//true

    p1.name = "Jerry";
    System.out.println(p2.name);//Tom
}

String的使用：

/*
结论：
1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
2.只要其中有一个是变量，结果就在堆中。
3.如果拼接的结果调用intern()方法，返回值就在常量池中
 */
@Test
public void test4(){
    String s1 = "javaEEhadoop";
    String s2 = "javaEE";
    String s3 = s2 + "hadoop";
    System.out.println(s1 == s3);//false

    final String s4 = "javaEE";//s4:常量
    String s5 = s4 + "hadoop";
    System.out.println(s1 == s5);//true

}

@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;

    System.out.println(s3 == s4);//true
    System.out.println(s3 == s5);//false
    System.out.println(s3 == s6);//false
    System.out.println(s3 == s7);//false
    System.out.println(s5 == s6);//false
    System.out.println(s5 == s7);//false
    System.out.println(s6 == s7);//false

    String s8 = s6.intern();//返回值得到的s8使用的常量值中已经存在的“javaEEhadoop”
    System.out.println(s3 == s8);//true
}

String与byte[]和char[]之间的转换：

public class StringTest1 {

    /*
    String 与 byte[]之间的转换
    编码：String --> byte[]:调用String的getBytes()
    解码：byte[] --> String:调用String的构造器
    
    编码：字符串 -->字节  (看得懂 --->看不懂的二进制数据)
    解码：编码的逆过程，字节 --> 字符串 （看不懂的二进制数据 ---> 看得懂）
    
    说明：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。
     */
    @Test
    public void test3() throws UnsupportedEncodingException {
        String str1 = "abc123中国";
        byte[] bytes = str1.getBytes();//使用默认的字符集，进行编码。
        System.out.println(Arrays.toString(bytes));
    
        byte[] gbks = str1.getBytes("gbk");//使用gbk字符集进行编码。
        System.out.println(Arrays.toString(gbks));
    
        System.out.println("******************");
    
        String str2 = new String(bytes);//使用默认的字符集，进行解码。
        System.out.println(str2);
    
        String str3 = new String(gbks);
        System.out.println(str3);//出现乱码。原因：编码集和解码集不一致！


        String str4 = new String(gbks, "gbk");
        System.out.println(str4);//没有出现乱码。原因：编码集和解码集一致！


    }
  
  
    /*
    String 与 char[]之间的转换
    
    String --> char[]:调用String的toCharArray()
    char[] --> String:调用String的构造器
     */
     
    @Test
    public void test2(){
        String str1 = "abc123";  //题目： a21cb3
    
        char[] charArray = str1.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            System.out.println(charArray[i]);
        }
    
        char[] arr = new char[]{'h','e','l','l','o'};
        String str2 = new String(arr);
        System.out.println(str2);
    }
    
    /*
    复习：
    String 与基本数据类型、包装类之间的转换。
    
    String --> 基本数据类型、包装类：调用包装类的静态方法：parseXxx(str)
    基本数据类型、包装类 --> String:调用String重载的valueOf(xxx)
    
     */
    @Test
    public void test1(){
        String str1 = "123";

//        int num = (int)str1;//错误的
        int num = Integer.parseInt(str1);

        String str2 = String.valueOf(num);//"123"
        String str3 = num + "";
    
        System.out.println(str1 == str3);
    }

}

StringBuffer：

StringBuffer类由来

• String类对象一旦创建就不可更改
• 如果经常对字符串内容进行修改而使用String的话，就会导致即消耗空间又耗时间。
• 例子：
  • String s1 = “abasdas”; String str2 = “123”;
  • String s = s1 + s2;
  • 删除str1中的字母d
• StringBuffer对象的内容是可以改变的
• 因此String类中没有修改字符串的方法，但是StringBuffer类中却有大量修改字符串的方法。

Demo：

public class SBuffer{
	public static void main(String[] args){
		StringBuffer sb = new StringBuffer();
		sb.append("abc");
		sb.append("123");
		System.out.println("sb ="+ sb);   	//  sb = abc123
		sb.insert(3,"--");
		System.out.println("sb ="+ sb);  	//  sb = abc--123
		sb.delete(2,6);				//  把下标从2开始到下标为6-1的字符删除。  也即是6-2删除4个字符。
		System.out.println("sb = "+ sb);    //  sb = ab23
		sb.reverse();
		System.out.println("sb = "+ sb);    //  sb = 32ba
		String str = sb.toString();					//  转换为Strng对象。
		System.out.println("sb = "+ sb);	//  str = 32ba
	}
}

StringBuffer的常用方法：

StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
StringBuffer delete(int start,int end)：删除指定位置的内容
StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str
StringBuffer insert(int offset, xxx)：在指定位置插入xxx
StringBuffer reverse() ：把当前字符序列逆转
public int indexOf(String str)
public String substring(int start,int end):返回一个从start开始到end索引结束的左闭右开区间的子字符串
public int length()
public char charAt(int n )
public void setCharAt(int n ,char ch)

        总结：
        增：append(xxx)
        删：delete(int start,int end)
        改：setCharAt(int n ,char ch) / replace(int start, int end, String str)
        查：charAt(int n )
        插：insert(int offset, xxx)
        长度：length();
        *遍历：for() + charAt() / toString()
     */
    @Test
    public void test2(){
        StringBuffer s1 = new StringBuffer("abc");
        s1.append(1);
        s1.append('1');
        System.out.println(s1);

//        s1.delete(2,4);
//        s1.replace(2,4,"hello");
//        s1.insert(2,false);
//        s1.reverse();
        String s2 = s1.substring(1, 3);
        System.out.println(s1);
        System.out.println(s1.length());
        System.out.println(s2);
    }

对比String、StringBuffer、StringBuilder三者的效率：
    从高到低排列：StringBuilder > StringBuffer > String
     */
    @Test
    public void test3(){
        //初始设置
        long startTime = 0L;
        long endTime = 0L;
        String text = "";
        StringBuffer buffer = new StringBuffer("");
        StringBuilder builder = new StringBuilder("");
        //开始对比
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer的执行时间：" + (endTime - startTime));

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的执行时间：" + (endTime - startTime));

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的执行时间：" + (endTime - startTime));

}

小Tips：

String、StringBuffer、StringBuilder三者的异同？
String:不可变的字符序列；底层使用char[]存储
StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储
StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储

源码分析：
String str = new String();//char[] value = new char[0];
String str1 = new String("abc");//char[] value = new char[]{'a','b','c'};

StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组。
System.out.println(sb1.length());//
sb1.append('a');//value[0] = 'a';
sb1.append('b');//value[1] = 'b';

StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char["abc".length() + 16];

//问题1. System.out.println(sb2.length());//3
//问题2. 扩容问题:如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
         默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中的元素复制到新的数组中。

        指导意义：开发中建议大家使用：StringBuffer(int capacity) 或 StringBuilder(int capacity

---

2021-04-14