str1 和 str2 中的 value 都指向常量池中的 "hello" 数据空间，str1.value == str2.value。

compareTo方法

int compareTo(String str)方法：String 类型实现了 Comparable 接口， 重写了 compareTo 方法，即 String 对象支持自然排序。

int compareTo(String str) 方法按照字符的 Unicode 编码值进行比较大小的

@Test
public void test07() {
    String[] arr = {"java","linux","hadoop","hive","shell","flink","spark"};

    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr));
}

+ 与 concat 的区别

拼接两个字符串的方式有两种：连接运算符+ 和concat()方法

String str1 = "hello,";
String str2 = "world";

String str3 = str1 + str2;
String str4 = str1.concat(str2);

System.out.println(str3);   // helloworld
System.out.println(str4);   // helloworld

• str1 + str2：

  • "..."字符串字面量拼接，编译器直接优化为拼接后的字符串常量值。如，"abc" + "def" 优化等价于 "abcdef"
  • 非"..."字符串字面量拼接，编译器优化为 StringBuilder 的 append 方法，然后再把结果 toString。

  String str1 = "hello";
  String str2 = "world";
  String str3 = "helloworld";
  String str4 = str1 + str2;		// 非 "..." 字符串字面量拼接
  String str5 = str1 + "world";	// 非 "..." 字符串字面量拼接
  String str6 = "hello" + "world";	// "..." 字符串字面量拼接	等价于: String str6 = "helloworld";
  
  System.out.println(str3 == str4);   // false
  System.out.println(str3 == str5);   // false
  System.out.println(str3 == str6);   // true
  

  现在使用debug方式追一下String str5 = str1 + "world";的执行过程，如下：

  1. 先创建一个 StringBuilder 对象 sb，容量为16，初始为空。

     <="" div="">

  2. 执行 sb.append("hello");

     <="" div="">

  3. 执行 sb.append("world");

     <="" div="">

  4. 调用 sb.toString();方法，返回 String 对象

     <="" div="">

  最后 str5 会指向堆中的 String 对象，value[] 指向常量池中的 "helloworld" 数据空间。

  注意：final String str1 = "hello"; // 此时 str1 完全等价于"hello"

  final String s1 = "hello";//此时s1完全等价于"hello"
  final String s2 = "world";//此时s2完全等价于"world"
  String s3 = "helloworld";
  String s4 = s1 + s2;
  String s5 = s1 + "world";
  String s6 = "hello" + "world";
  
  System.out.println(s3 == s4);//true
  System.out.println(s3 == s5);//true
  System.out.println(s3 == s6);//true
  

• str1.concat(str2)：只要拼接的不是空字符串，每次都 new 一个 String

  String str1 = "hello";
  String str2 = "world";
  String str3 = "helloworld";
  String str4 = str1.concat(str2);	// str2 不是空串 创建一个新对象接受连接后的内容
  String str5 = str1.concat("world");
  String str6 = "hello".concat("world");
  
  System.out.println(str3 == str4);   // false
  System.out.println(str3 == str5);   // false
  System.out.println(str3 == str6);   // false
  

  concat(String)方法源码：

  <="" div="">

可变字符序列

因为 String 对象是不可变对象，虽然可以共享常量对象，但是对于频繁字符串的修改和拼接操作，效率极低。因此 Java 提供了可变字符序列 StringBuilder 和 StringBuffer 类型。

• StringBuffer：线程安全的（方法有 synchronized 修饰）

• StringBuilder：线程不安全的

StringBuffer和StringBuilder

StringBuffer 与 StringBuilder 最大区别就是在于 StringBuffer 是线程安全的，支持多线程访问；StringBuilder是线程不安全的，在单线程下使用。

StringBuilder 的效率要高于 StringBuffer，通常情况先建议使用 StringBuilder，但在要求线程安全的情况下需要使用String Buffer。

其他方面 StringBuffer 与 StringBuilder 相似：

• StringBuffer 和 StringBuilder 都是 final 类，不能被继承

• StringBuffer 和 StringBuilder 都继承自 AbstractStringBuilder，有属性 char[] value，用于存放字符串内容，

  由于 value 不是 final 类型，因此 value 数组里的内容存放在堆空间，而不是常量池。

• StringBuffer 和 StringBuilder 都不用每次都需要创建新对象，所有效高于 String

• StringBuffer 和 StringBuilder 有相同扩容机制：初始容量默认capacity = str.length + 16，每次扩容为capacity = 2 * capacity + 2

常用的API，StringBuilder、StringBuffer是完全一致的：

1. StringBuffer append(xx)：拼接，追加

2. StringBuffer insert(int index, xx)：在 [index] 位置插入 xx

3. StringBuffer deleteCharAt(int index)：删除[index]位置字符

4. void setCharAt(int index, xx)：替换[index]位置字符

5. StringBuffer reverse()：反转

6. int indexOf(String str)：在当前字符序列中查询str的第一次出现下标

@Test
public void test1(){
    StringBuilder s = new StringBuilder();
    s.append("hello").append(true).append('a').append(12).append("world");
    System.out.println(s);
    System.out.println(s.length());
}
@Test
public void test2(){
    StringBuilder s = new StringBuilder("helloworld");
    s.insert(5, "java");
    System.out.println(s);
}
@Test
public void test3(){
    StringBuilder s = new StringBuilder("helloworld");
    s.deleteCharAt(4);
    System.out.println(s);
}
@Test
public void test4(){
    StringBuilder s = new StringBuilder("helloworld");
    s.reverse();
    System.out.println(s);
}
@Test
public void test5(){
    StringBuilder s = new StringBuilder("helloworld");
    s.setCharAt(2, 'a');
    System.out.println(s);
}
@Test
public void test6(){
    StringBuilder s = new StringBuilder("helloworld");
    int index = s.indexOf("owo");
    System.out.println(index);
}

String，StringBuffer，StringBuilder效率测试

import org.junit.jupiter.api.Test;

public class EfficiencyTest {
    @Test
    public void test() {
        long start = System.currentTimeMillis();

        stringTest();
        // stringBufferTest();
        // stringBuilderTest();

        long end = System.currentTimeMillis();
        long memory = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
                                                                
        System.out.println("String拼接+用时：" + (end - start));  
        System.out.println("String拼接+占用内存: " + memory);     
        //          String      StringBuffer    StringBuilder
        // time     5986        5               3
        // memory   57263088    43127632        43127912
    }

    public void stringTest() {
        String str = new String("0");
        for (int i = 0; i < 50000; i++) {
            str += i;
        }
    }

    public void stringBufferTest() {
        StringBuffer sb = new StringBuffer("0");
        for (int i = 0; i < 50000; i++) {
            sb.append(i);
        }
    }

    public void stringBuilderTest() {
        StringBuilder sb = new StringBuilder("0");
        for (int i = 0; i < 50000; i++) {
            sb.append(i);
        }
    }
}