Java_String

整理一下java中关于String的内容。Spring应该是java中使用最频繁的类了，那么今天我们仔细研究下关于Spring的内容。

定义：

　　String类是一个字符串类型的类，使用"   "定义的内容都是字符串。 

实例化：

　　(1)直接赋值实例化：String str ="Hello World!";

　　(2)使用构造方法实例化：String str = new String("Hello World!");

注意：

1）单独使用""引号创建的字符串都是常量，编译期就已经确定存储到String Pool中；

2）使用new String("")创建的对象会存储到堆中，是运行期创建的；

new创建字符串时首先查看String Pool中是否有相同的字符串，如果有，则拷贝一份到堆中，然后返回堆中的地址；如果池中没有，则在堆中创建一份，然后返回堆中的地址(注意，此时不需要从堆中复制一份到池中，否则，将使得堆中的字符串永远是池中的子集，浪费池的空间)；

3）使用只包含常量的字符串连接符如"aa"+"bb"创建的也是常量，编译期就能确定，存储在String Pool中；

4）使用包含变量的字符串连接符如s1+"aa"创建的对象是运行期才创建的，存储在heap中。

 

字符串的比较：

　　如果我们想知道两个int类型变量是否相等，可以使用 == 进行验证，那么String中使用 == 是否可以验证呢，来看一个栗子：

　　

package javaEE;
/** 
 * @author 047493 
 * @version 2018年8月31日 
 * 类说明 
 */
public class Test12 {
    public static void main(String[] args) {
        
        String str1 = "Hello";
        String str2 = new String("Hello");
        String str3 = str2;
        
        System.out.println(str1 == str2);
        System.out.println(str2 == str3);
        System.out.println(str1 == str3);
        
    }
}

运行结果：

false
true
false

造成此原因的内存关系图如下：

通过上图分析可知，== 比较的不是字符串对象包含的内容，而是两个对象所在的内存对象的数值。即 == 属于数值比较，比较的是内存地址。

如果想比较字符串的内容，可以使用equals()。栗子如下：

package javaEE;
/** 
 * @author 047493 
 * @version 2018年8月31日 
 * 类说明 
 */
public class Test12 {
    public static void main(String[] args) {
        
        String str1 = "Hello";
        String str2 = new String("Hello");
        String str3 = str2;
        
        System.out.println(str1.equals(str2));
        System.out.println(str2.equals(str3));
        System.out.println(str1.equals(str3));
        
    }
}

运行结果如下：

true
true
true

字符串常量是匿名对象：
一个栗子，验证如下:

package javaEE;
/** 
 * @author 047493 
 * @version 2018年8月31日 
 * 类说明 
 */
public class Test12 {
    public static void main(String[] args) {
        
        String str1 = "Hello";
        System.out.println("Hello".equals(str1));
    }
}

运行结果如下：

true

匿名对象可以调用类中的方法和属性，而以上字符串调用了String类的equals()，所以它一定是一个对象。

String类对象两种实例化方式的区别：

(1)直接赋值的实例化方式：String str ="Hello";

内存关系图如下：

举个栗子：

package javaEE;
/** 
 * @author 047493 
 * @version 2018年8月31日 
 * 类说明 
 */
public class Test12 {
    public static void main(String[] args) {
        
        String str1 = "Hello";
        String str2 = "Hello";
        String str3 = "Hello";
        
        System.out.println(str1 == str2);
        System.out.println(str2 == str3);
        System.out.println(str3 == str1);

    }
}

运行结果如下：

true
true
true

我们发现以上所有直接赋值的String类对象的内存地址完全相同，内存分配图如下：

在设计String类的时候采用了一种共享设计模式的概念。在运行的JVM底层存在一个字符串的对象池(object pool)，如果用户才用了直接赋值的方式，会将字符串的内容放入池保存，如果以后其他字符串对象继续使用直接赋值方式实例化，且设置了同样的内容，那么将不会分配新的堆内存空间，而是使用已有对象的引用进行分配继续使用。如果新声明的字符串内容不在对象池中，则会分配一个新的，然后继续放到池中以供下次使用。由于String对象的不可变性，我们可以十分肯定字符串常量池中一定不存在两个相同的字符串。

(2)构造方法实例化方式：String str = new String("Hello");

构造方法实例化使用new关键字，而一旦使用new关键字就表示要分配新的内存空间。

内存分配图如下：

首先产生匿名对象"Hello"，然后new关键字再次产生"Hello"，并且str指向该字符串，原来的匿名对象变成垃圾，由GC回收。

可以发现，分配了两块内存空间，其中一块是垃圾。这样除了内存的浪费外，使用构造方法定义的String对象，其内容不会保存在对象中(因为重新分配了一块堆内存)。

现在希望使用构造方法定义的String类对象，其内容要保存在对象中，改怎么办？我们可以使用intern()，手工入池。

举个栗子：

package javaEE;
/** 
 * @author 047493 
 * @version 2018年8月31日 
 * 类说明 
 */
public class Test12 {
    public static void main(String[] args) {
        
        String str1 = new String("Hello").intern();
        String str2 = "Hello";
        String str3 = "Hello";
        
        System.out.println(str1 == str2);
        System.out.println(str2 == str3);
        System.out.println(str3 == str1);
    }
}

运行结果如下：

true
true
true

注意：在实际开发中我们不会采用构造方法进行字符串的实例化。

两种实例化方式的区别：

　　(1)直接赋值方式：只会分配一块堆内存空间，并且对象内容自动入池，以供重复使用；

　　(2)构造方法方式：会分配两块堆内存空间，其中有一块是垃圾，并且不会自动入池，可以调用intern()自动入池。

 

字符串的内容一旦定义则不可改变：

一个栗子：

package javaEE;
/** 
 * @author 047493 
 * @version 2018年8月31日 
 * 类说明 
 */
public class Test12 {
    public static void main(String[] args) {
        
        String str = "Hello ";
        str +="World ";
        str +="!!!";
        System.out.println(str);
    }
}

运行结果如下：

Hello World !!!

内存分析图如下：

通过内存分析图得知，字符串内容的改变，实际上改变的是字符串对象的引用过程，并且会伴随着大量的内存垃圾出现，在实际开发中应该避免。

那，如果我们要改变字符串的长度，应该怎么做呢？

可以使用可变字符串StringBuilder或StringBuffer。

StringBuilder和StringBuffer构建可变字符串对象都是通过new操作符调用构造方法，两者的区别在于StringBuilder应用于单线程环境，而StringBuffer应用于多线程环境。

StringBuilder的主要方法：

package javaEE;
/** 
 * @author 047493 
 * @version 2018年8月31日 
 * 类说明 
 */
public class Test12 {
    public static void main(String[] args) {
        
        StringBuilder sb = new StringBuilder();
        sb.append("String is changed");
        System.out.println(sb);
        sb.insert(0, 123);  //在字符串下标0处插入123
        System.out.println(sb);
        sb.delete(0, 3);  //删除前3位字符串
        //sb.delete(sb.length()-3, sb.length());  //删除sb字符串后面的3位字符
        System.out.println(sb);
        sb.replace(0, 3, "!!!");  //替换前3位字符串
        System.out.println(sb);
        sb.reverse();  //字符串翻转
        System.out.println(sb);
        sb.setCharAt(0, 'A');  //设置某个小标的字符内容
        System.out.println(sb);
    }
}

运行结果如下：

String is changed
123String is changed
String is changed
!!!ing is changed
degnahc si gni!!!
Aegnahc si gni!!!

即，凡是需要大量拼接字符串的地方都应该尽量使用可变字符串来完成，效率高且不占内存空间。

 

关于String类，面试中所常遇到的问题？

1）String str = new String("Hello"); "Hello"在内存中是怎么分配的？程序创建了几个对象？

这个题考察的是java中字符串常量池和JVM运行时数据区的相关概念。

内存分布可以参考下图：

那么创建了几个对象呢？答案是2个。

首先，出现了字面量“Hello”，那么先要在String Pool中查找是否存在相同的字符串，因为程序就这一行代码所以肯定没有，那么就在堆内存中用字面量“Hello”首先创建一个Hello对象；

接着，new String("Hello")，关键字new又在堆中创建了一个对象，然后调用接收String参数的构造器进行了初始化，最后str引用这个String对象。

2）String，StringBuffer，StringBuilder区别？

首先我们知道String是不可变的，当我们对操作String时，总会创建新的字符串，很耗费资源，所以java提供了两个工具类来操作String，StringBuffer，StringBuilder。

StringBuffer与StringBuilder都是可变类，功能相似。唯一不同的是StringBuffer是线程安全的，而StringBuilder是线程不安全的。所以在多线程对同一个字符串进行操作的时候，我们应该选择StringBuffer。但如果是单线程的情况下，StringBuilder的效率要高于StringBuffer。

 

关于字符串在各种情况下的比较，可以参考博主平凡希的文章，写的很详细：https://www.cnblogs.com/xiaoxi/p/6036701.html

参考资料：

https://blog.csdn.net/wei_zhi/article/details/52761081

https://www.cnblogs.com/fwnboke/p/8529453.html