String

String类头

public final class String extends Object implements Serializable, Comparable<String>, 
CharSequence

子串

public String substring(int beginIndex, int endIndex)

String greeting = "Hello";
//修改字符串变量
greeting = greeting.substring(0,3);

substring第二个参数为不想赋值的第一个位置。此函数赋值0、1、2。

拼接

“+”可以实现String的拼接。当一个字符串与一个非字符串进行拼接时，后者被转换为字符串。

//拼接字符串
int age = 13;
String rating = "PG" + age;
System.out.println(rating);

关于 equal 和 ==

== 用于比较两个对象的时候，是来check 是否两个引用指向了同一块内存。equals() 是object的方法，默认情况下，它与== 一样，比较的地址。但是当equal被重载之后，根据设计，equal 会比较对象的value。而这个是java希望有的功能。

        //测试equals和==
        //以字面常量测试
        String obj1 = "Hello";
        String obj2 = "Hello";
        if(obj1 == obj2){
            System.out.println("obj1 == obj2: "+"true");
        }
        else {
            System.out.println("obj1 == obj2: "+"false");
        }
        
        if(obj1.equals(obj2)){
            System.out.println("obj1.equals(obj2): "+"true");
        }
        else {
            System.out.println("obj1.equals(obj2): "+"false");
        }
        
        //以new创建对象测试
        String obj3 = new String("Hello");
        String obj4 = new String("Hello");
        if(obj3 == obj4){
            System.out.println("obj3 == obj4: "+"true");
        }
        else {
            System.out.println("obj3 == obj4: "+"false");
        }
        
        if(obj3.equals(obj4)){
            System.out.println("obj3.equals(obj2): "+"true");
        }
        else {
            System.out.println("obj4.equals(obj2): "+"false");
        }

运行结果：

obj1 == obj2: true
obj1.equals(obj2): true
obj3 == obj4: false
obj3.equals(obj2): true

常量池

如果使用字面量创建一个String对象时，它将返回一个位于字符串常量池中的引用，如果该字面量已经存在于常量池(String Pool)中，则无需重新新建，只需要已有的字面量，否则将新建一个字面量。
jdk1.7之前，String Pool位于堆中的永久去内，从jdk1.7开始，String Pool迁移到主堆中。

        //测试String Pool
        String s1 = new String("java");
        String s2 = new String("java");
        String s3 = "java";
        String s4 = "java";

String Pool.png

s1 == s2: false
s1.equals(s2): true
s3 == s4: true

String & StringBuffer & StringBuilder

• String:是不可改变的量，也就是创建后就不能在修改了。

String.png

• StringBuffer:是一个可变字符串序列，它与 String 一样，在内存中保存的都是一个有序的字符串序列（char 类型的数组），不同点是 StringBuffer 对象的值都是可变的。

StringBuffer.png

• StringBuilder:与 StringBuffer 类基本相同，都是可变字符换字符串序列，不同点是 StringBuffer 是线程安全的，StringBuilder 是线程不安全的。

使用场景

• String:在字符串不经常变化的场景中可以使用 String 类，例如常量的声明、少量的变量运算。
• StringBuffer:在频繁进行字符串运算（如拼接、替换、删除等），并且运行在多线程环境中，则可以考虑使用 StringBuffer，例如 XML 解析、HTTP 参数解析和封装。
• StringBuilder:在频繁进行字符串运算（如拼接、替换、和删除等），并且运行在单线程的环境中，则可以考虑使用 StringBuilder，如 SQL 语句的拼装、JSON 封装等。

运行速度

StringBuilder > StringBuffer>String

在正常情况下，每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。
而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢。

final static int ttimes = 3000;// 设置循环次数

    // String测试,对String使用‘+’添加字面常量
    public void test(String s) {
        long begin = System.currentTimeMillis();
        for (int i = 0; i < ttimes; i++) {
            s += "add";
        }
        long over = System.currentTimeMillis();
        System.out.println(" 操作 " + s.getClass().getName() + " 类型使用的时间为： "
                + (over - begin) + " 毫秒 ");
    }

    // String测试,对String直接进行字符串拼接
    public void test2() {
        String s2 = "abcdefg";
        
        long begin = System.currentTimeMillis();
        for (int i = 0; i < ttimes; i++) {
            String s = s2 + s2 +s2;
        }
        long over = System.currentTimeMillis();
        System.out.println(" 操作字符串对象引用相加类型使用的时间为： " + " 类型使用的时间为： "
                + (over - begin) + " 毫秒 ");
    }

    
    // String测试,对String直接进行字符串拼接
    public void test3() {
        
        long begin = System.currentTimeMillis();
        for (int i = 0; i < ttimes; i++) {
            String s = "abcdefg" + "abcdefg" +"abcdefg";
        }
        long over = System.currentTimeMillis();
        System.out.println("操作字符串对象引用相加类型使用的时间为： " + " 类型使用的时间为： "
                + (over - begin) + " 毫秒 ");
    }

    
    
    // StringBuffer测试
    public void test(StringBuffer s) {
        long begin = System.currentTimeMillis();
        for (int i = 0; i < ttimes; i++) {
            s.append("add");
        }
        long over = System.currentTimeMillis();
        System.out.println(" 操作 " + s.getClass().getName() + " 类型使用的时间为： "
                + (over - begin) + " 毫秒 ");
    }

    // StringBuilder测试
    public void test(StringBuilder s) {
        long begin = System.currentTimeMillis();
        for (int i = 0; i < ttimes; i++) {
            s.append("add");
        }
        long over = System.currentTimeMillis();
        System.out.println(" 操作 " + s.getClass().getName() + " 类型使用的时间为： "
                + (over - begin) + " 毫秒 ");
    }

        String s1 ="abc";
        StringBuffer sb1 = new StringBuffer("abc");
        StringBuilder sb2 = new StringBuilder("abc");
        Main t = new Main();
        t.test(s1);
        t.test(sb1);
        t.test(sb2);
        t.test2();
        t.test3();

  操作 java.lang.String 类型使用的时间为： 47 毫秒 
 操作 java.lang.StringBuffer 类型使用的时间为： 2 毫秒 
 操作 java.lang.StringBuilder 类型使用的时间为： 1 毫秒 
 操作字符串对象引用相加类型使用的时间为：  类型使用的时间为： 6 毫秒 
操作字符串相加类型使用的时间为：  类型使用的时间为： 0 毫秒 

实验证明：
StringBuffer与StringBuilder速度相差不大，两者速度明显高于String；
String直接使用字符串相加时，JVM会默认为把几个字符串加在一起，运行速度较快，但是使用引用相加时需要创建新的对象，比较耗时。