对 String 字符串的理解

1、通过构造方法创建的字符串对象和直接赋值方式创建的字符串对象区别？

通过构造方法创建字符串对象是在堆内存。
直接赋值方式创建对象是在方法区的常量池。

==：
	基本数据类型，比较的是基本数据类型的值是否相同。
	引用数据类型，比较的是引用数据类型的地址值是否相同。

public class StringDemo {
    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = "hello";
        System.out.println("s1==s2：" + (s1 == s2));//false

        String s3 = "hello";
        System.out.println("s1==s3:" + (s1 == s3)); //false
        System.out.println("s2==s3:" + (s2 == s3)); //true
    }
}

画图解释：

main 方法进栈开辟空间，栈内存中执行 String s1 , new String() 出来的东西肯定是在堆内存，即有一个地址值 001 指向堆内存，

但是 “hello” 字符串不是存在于堆内存中，是存在于方法区的常量池中(原因如图)，在方法区中为 “hello” 开辟空间(也有地址值)，地址

值 002 赋值给了堆内存中的对象，也就是说 001 地址值中包含了一个 002 地址值，所以当输出 s1 时，栈内存中 001 指向堆内存的

001，001 又包含了 002，然后堆内存中地址值 002 指向了方法区的产量池的地址值 002 ；

当 String s2 时候，没有 new 动作，所以 s2 直接是在方法区的常量池把地址值 002 拿过来，所以 s2 直接指向方法区。

但是此时两个对象，s1 存储的是地址值 001，s2 存储的是地址值 002，所以打印 false。

当 String s3时候，没有 new 动作，所以 s3 直接是在方法区的常量池把地址值 002 拿过来，所以s3直接指向方法区。

所以此时 s2和s3的地址值是一样的 002，所以打印出 true。

总之一句话，new 的动作在堆内存，直接赋值的是在方法区的常量池。

2、Java中对字符串的优化处理

我们会经常使用 String 对象，String 对象是 java 中重要的数据类型。其设计者也对String做了大量的优化工作，

这些也是String对象的特点：不变性，常量池优化和String类的final定义。

A、不变性
	String对象的状态在其被创建之后就不在发生变化。其设计者使用了 java 模式中不变模式。
	作用：在一个对象被多线程共享，而且被频繁的访问时，可以省略同步和锁的时间，从而提高性能。

B、 常量池优化
	如同我上面的解释，即当两个 String 对象拥有同一个值的时候，它们都只是引用了常量池中的同一个地址。

C、final 定义
	String类以final进行了修饰，主要是为了“效率” 和 “安全性” 的缘故。若 String允许被继承, 由于它的高度
	被使用率, 可能会降低程序的性能，所以String被定义成final。

3、String常量的累加操作优化方法。

public class StringDemo2 {
    public static void main(String[] args) {
        String s = "";

        long beginTime = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            s += "s";
        }
        long endTime = System.currentTimeMillis();
        System.out.println("s拼接100000遍s耗时："+(endTime-beginTime)+"ms");

        StringBuffer s1=new StringBuffer();
        long s1BeginTime = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            s1.append("s");
        }
        long s1EndTime = System.currentTimeMillis();
        System.out.println("s1拼接100000遍s耗时："+(s1EndTime-s1BeginTime)+"ms");

        StringBuilder s2=new StringBuilder();
        long s2BeginTime = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            s2.append("s");
        }
        long s2EndTime = System.currentTimeMillis();
        System.out.println("s2拼接100000遍s耗时："+(s2EndTime-s2BeginTime)+"ms");
    }
}

消耗时间：
	s拼接100000遍s耗时：3586ms
	s1拼接100000遍s耗时：3ms
	s2拼接100000遍s耗时：0ms

如代码所示，使用 + 拼接字符串时候，效率很低，而使用 Stringbuffer 和 StringBuilder 的 appedn() 方法时，效率
高出 + 成百上千倍，StringBuffer 的效率比 StringBuilder 低，这是由于StringBuffer实现了线程安全，效率较低不
可避免的。所以在字符串的累加操作中，建议结合线程问题选择，应避免使用+号拼接字符串。

public class StringDemo3 {
    public static void main(String[] args) {

        Integer num = 0;
        int loop = 100000;
        long beginTime = System.currentTimeMillis();
        for (int i = 0; i < loop; i++) {
            String s = num + "";
        }
        long endTime = System.currentTimeMillis();
        System.out.println("+\"\"的方式耗时："+(endTime-beginTime)+"ms");

        beginTime = System.currentTimeMillis();
        for (int i = 0; i < loop; i++) {
            String s = String.valueOf(num);
        }
        endTime = System.currentTimeMillis();
        System.out.println("String.valueOf()方式耗时："+(endTime-beginTime)+"ms");

        beginTime = System.currentTimeMillis();
        for (int i = 0; i < loop; i++) {
            String s = num.toString();
        }
        endTime = System.currentTimeMillis();
        System.out.println("toString 方式耗时："+(endTime-beginTime)+"ms");
    }
}

消耗时间：
	+""的方式耗时：20ms
	String.valueOf()方式耗时：6ms
	toString 方式耗时：4ms

如代码所示，String.valueOf() 直接调用了底层的 Integer.toString() 方法，不过其中会先判空；+”“ 由 StringBuilder
实现，先调用了 append() 方法，然后调用了 toString() 方法获取字符串；num.toString() 直接调用了 Integer.toString()
方法，所以效率是: num.toString() 方法最快，其次是 String.valueOf(num)，最后是 num+”“ 的方式。