Java中String类部分源码分析以及常见面试考点

Java面试中涉及到的面试题，最容易出错的就是各种字符串和String对象之间以及与其自身的比较、拼接、==、equals等。如果没有阅读String的源码，可能很多程序的运行结果与预想的结果不一致时，主要是因为String类对equals方法、hashCode方法、compareTo方法等进行了重写。

一、关键部分源码介绍

1. final修饰

String是被final修饰的，所以String是不可变的，它的值也不能被改变。有以下特点：

• 每当对String进行操作的时候，总是会创建新的字符串。
• String天生就线程安全，不用担心多线程下的字符串被随意修改。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence 

2. compareTo方法

String类实现了Comparable接口，所以它必然会重写compareTo方法，源码如下：

public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

3. Comparator比较器的实现

在String类种还实现了自己的比较器，即对Comparator接口的实现，该比较器CaseInsensitiveComparator主要是用于忽略大小写的比较两个字符串是否相等，在String类中的很多方法都用到了该比较器。源码如下：

private static class CaseInsensitiveComparator
            implements Comparator<String>, java.io.Serializable {
        // use serialVersionUID from JDK 1.2.2 for interoperability
        private static final long serialVersionUID = 8575799808933029326L;

        public int compare(String s1, String s2) {
            int n1 = s1.length();
            int n2 = s2.length();
            int min = Math.min(n1, n2);
            for (int i = 0; i < min; i++) {
                char c1 = s1.charAt(i);
                char c2 = s2.charAt(i);
                if (c1 != c2) {
                    c1 = Character.toUpperCase(c1);
                    c2 = Character.toUpperCase(c2);
                    if (c1 != c2) {
                        c1 = Character.toLowerCase(c1);
                        c2 = Character.toLowerCase(c2);
                        if (c1 != c2) {
                            // No overflow because of numeric promotion
                            return c1 - c2;
                        }
                    }
                }
            }
            return n1 - n2;
        }

        /** Replaces the de-serialized object. */
        private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
    }

该比较器不能直接被外部访问，但是String类对该比较器提供了一个final修饰的引用CASE_INSENSITIVE_ORDER：String类中的compareToIgnoreCase方法就是利用该比较器实现的。

public static final Comparator<String> CASE_INSENSITIVE_ORDER = new CaseInsensitiveComparator();

4. hashCode方法

String中的hashCode方法中用到了一个变量hash，该变量是String类的一个私有变量private int hash，默认是0，会在第一次调用hashCode方法时，将字符串的哈希code赋值给变量hash。

因为String类型是不可变的(final修饰)，根据hashCode() 方法中的判断条件，该方法在调用一次以后，接下来的每次调用都不会再重新计算字符串的哈希值。所以HashMap集合中的key都用String类型来表示，这样可以提高效率。

 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;
    }

5. equals方法

注意：equals方法一开始对传入的比较对象进行了检查，如果传进来的对象不是String类型，直接返回false。 所以，所有涉及到String或new String()与StringBuffer/StringBuilder类之间的比较，结果就是false。

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;
    }

二、String类的常见考点

首先需要了解一下==比较的是什么，如果是基本数据类型的变量，例如int，double等类型，==比较的是变量的值，int i=1，拿去比较的是1；如果是引用类型，==比较的是引用地址值。

2.1 字符串与变量引用之间的比较

public static void main(String[] args) {
        String s1 = "a";
        String s3 = "ab";
        String s4 = s1 + "b";
        String s5 = "a"+"b";

        System.out.println(s3 == s4); //false
        System.out.println(s3 == s5); //true
        System.out.println(s3.intern() == s5); //true
        System.out.println(s3.intern() == s5.intern()); //true
}

解释：

• 第一个输出结果：所以s3 = “ab”,此时字符串"ab"是会被放到常量池里面,但是s4 = s1 + “b”,中的s4是由变量s1和"b"共同组成的,所以s4其实是一个变量,所以不会被储存在常量池里面,而是储存在堆内存中.

• 第二个输出结果: s3和s5都能被确定下来,所以被储存在常量池里面.

• 第三和第四个输出结果 : 字符串调用intern()的执行过程是,判断字符串常量池里面是否含有当前字符串,如果含有则直接返回,如果不含有,则把当前字符串放到字符串常量池里面,并返回.(intern()方法之后"=="的结果与字符串调用equals方法的结果一样)

2.2 String对象的特殊之处

• 使用双引号直接创建对象。
• 用new String()的方式创建的字符串，一开始并不存储于字符串池。可以通过调用intern()方法将该字符串对象存储在字符串池，如果字符串池已经有了同样值的字符串，则返回引用。

 public static void main(String[] args) {

        String s1 = "hello";
        String s2 = "hello";
        String s3 = new String("hello");

        System.out.println(s1==s2);//true
        System.out.println(s1==s3);//false
        System.out.println(s1 == s3.intern());//true

    }

• 上面例子中s3返回的是一个堆内存中的引用地址。
• s3.intern()返回的是将"hello"字符串放入字符串池中后返回的字符串引用。