String类

目录

类说明：

类结构：

详细说明：

equals方法：

hashCode方法：

intern方法：

常量池：

new String和不用new的区别：

加法运算：

面试题目：

---

类说明：

      String对象是不可变对象。 因为String类被final关键字修饰，意味着String类不能被继承，并且它的成员方法都默认为final方法；字符串一旦创建就不能再修改。

类结构：

属性	说明
char value[]	该值用于字符存储。
int hash	缓存字符串的hash

方法	说明
boolean equals(Object anObject)	重写Object的equals方法，用于比较字符串是否相等
int hashCode()	重写Object的hashCode()方法：
native String intern()	返回字符串对象在常量池中的引用

详细说明：

equals方法：

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

hashCode方法：

public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

intern方法：

该方法是一个native修饰的方法，没有实现的代码。

调用intern方法时，判断常量池中的字符串是否和此字符串相等 【通过equals方法判断】

• 相等： 返回来自常量池中的字符串
• 不相等：将此对象添加到常量池中，并返回对此对象的引用

 

常量池：

• 背景：

            字符串的分配和其他对象分配一样，是需要消耗高昂的时间和空间的，而且字符串使用的非常多。JVM为了提高性能和减少内存的开销，在实例化字符串的时候进行了一些优化：使用字符串常量池。

•  使用：

              每当创建字符串常量时，JVM会首先检查字符串常量池。

             如果该字符串已经存在常量池中，那么就直接返回常量池中的实例引用。

             如果字符串不存在常量池中，就会实例化该字符串并且将其放到常量池中。

• 实现的基础

        实现该优化的基础是因为字符串是不可变的，可以不用担心数据冲突进行共享

        运行时实例创建的全局字符串常量池中有一个表，总是为池中每个唯一的字符串对象维护一个引用,这就意味着它们一直引用着字符串常量池中的对象，所以，在常量池中的这些字符串不会被垃圾收集器回收。

• 使用时机
  • String s = "AB";
  • String s = new String("AB").intern();

 

new String和不用new的区别：

String s = new String("ss") : 

     1. 在堆中创建一个字符串对象，同时，如果这个字符串在常量池里不存在，会在池创建这个对象

      2. 在栈中创建引用s ，指向堆中创建的字符串对象

String s ="ss";

      1. 程序先去字符串常量池检查，是否存在“ss”，如果不存在，则在常量池中开辟一个内存空间存放“ss”；如果存在的话，则不用重新开辟空间.

       2. 在栈中开辟一块空间，命名为“s”，存放的值为常量池中“ss”的内存地址（相当于指向常量池中的“ss”）

 

加法运算：

String的加法运算就是对字符串的拼接。

    public static void main(String[] args) {
        String s1 = "A";
        String s2 = "B";
        String s3 = "C";
        /**
         *  1. 【字符串常量】相加
         *  编译器会进行相应的优化，直接将两个字符串常量拼接好。String s4 = "AB";
         */
        String s4 = "A"+"B";
        /**
         *  2. 【字符串变量】相加
         *  JVM会隐式创建StringBuilder对象，然后使用StringBuilder进行拼接。
         *  如：new StringBuilder().append("A").append("B");
         *  注意：
         *     1） 一条语句中，字符串拼接会产生一个StringBuilder对象。如果多条语句，就会产生多个StringBuilder对象
         *     2） 在循环拼接时，应主动创建StringBuilder/StringBuffer(线程安全)对象，进行字符串的拼接。
         */
        String s5 = s1+s2;
        System.out.println(s5);

        String s6 = s5+s3;
        System.out.println(s6);
    }

 

面试题目：

 

public static void main(String[] args) {
        String s1 = "AB";
        String s2 = new String("AB");
        String s3 = "A";
        String s4 = "B";
        String s5 = "A" + "B";
        String s6 = s3 + s4;
        System.out.println(s1 == s2);  
        System.out.println(s1 == s5);
        System.out.println(s1 == s6);
        System.out.println(s1 == s6.intern()); 
        System.out.println(s2 == s2.intern());
}




答案：

/**
   *  System.out.println(s1 == s2);  //false
   *  System.out.println(s1 == s5); // true
   *  System.out.println(s1 == s6); //false
   *  System.out.println(s1 == s6.intern()); //true
   *  System.out.println(s2 == s2.intern()); //false
*/

图解：