Java源码系列之String类（个人理解及感悟）

首先，在java中，一个类的基本机构如下：

• 属性
• 方法
• 构造器
• 类的声明
• 内部类(不必要)
• 块(不必要）

属性：可以理解为java对象的数据，又称成员变量
声明方式为:访问权限修饰符+数据类型+属性名（=初值）
例如：

private String name;

方法：即对象的行为，是表示对象行为的语句，其中无返回值的声明方式如下

public void test(){
    return;
}

这里主要略述了属性和方法，这是因为类的主要结构就是属性+方法，构造器其实也是一种方法，有意思的是，突然想起来另一种说法，就是类的属性+getter和setter方法才是完整的属性，例如上面的name属性需要加上getter和setter方法才是完整的类的一个属性。

好了，废话不多说，下面我们来看一下String类的整体结构(截图来自jdk1.8)：

• 属性：
  
• 方法(由于方法太多，这里只截取部分)：
  
• 内部类(只有一个)
  
• String类的声明

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

一 、从类的声明，我们看出，String类继承了Serializable,Comparable和CharSequence接口

• Serializable接口
  用以标识序列化的接口，是一个空的接口
• Comparable接口
  里面只有一个compareTo方法：

Compares this object with the specified object for order.  Returns a
negative integer, zero, or a positive integer as this object is less
than, equal to, or greater than the specified object.

该方法上的部分注释如上所示，翻译过来就是，将此对象与指定顺序的对象进行比较，返回值为int类型，即比较两个对象的大小。

• CharSequence接口
  接口中定义了一些字符串常用方法，length()，charAt()，subSequence()等等

二、主要属性

• value和hash

/** The value is used for character storage. */
    private final char value[];

/** Cache the hash code for the string */
    private int hash; // Default to 0

• CASE_INSENSITIVE_ORDER

从注释可以看出，value是一个字符数组，用来存储字符串，这说明在java中字符串的底层是用字符数组来存储的，hash是String的hash值缓存，方便比较。

而CASE_INSENSITIVE_ORDER变量则持有了String类中唯一的内部类。

三、内部类
在这里内部类中定义了一个compare方法，比较两个字符串是否相等，并且不区分大小写，通过CASE_INSENSITIVE_ORDER来调用这个方法

public static final Comparator CASE_INSENSITIVE_ORDER
                                         = new CaseInsensitiveComparator();
private static class CaseInsensitiveComparator
            implements Comparator, 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类中还有一个compareTo方法，这两个方法有一些区别，compare是比较传进来的两个字符串的，并且不区分大小写，而compareTo方法是比较当前value中存储的字符串与形参传进来的字符串，并且区分大小写。

四、方法

一.构造方法
首先是一系列的构造方法(14个)，由于Stirng类中是用字符数组来接收字符串的，所以这些构造方法都是对数组的操作，在源码中我们可以看到里面用到了一些Arrays类中的方法，还有StringCode类中的方法，当然操作对象是byte[]数组，从这些构造方法我们也可以看到，String类不仅可以接收字符串，还可以接收字节数组和整型数组，在接收到字节数组之后，会调用StringCode类中的方法来对该数组进行解码，用户可以自由指定解码数组的哪几个字节。

二. 其他方法


上面是一些常用方法，作用不再多说

这里是几个valueof方法，返回值为String，大家肯定非常熟悉了吧。由于方法太多，这里不再一一讲述，只是将其稍加整理(忽略了一些不太用的方法)，罗列出来：

• get类型方法
  

• 索引类
  

• 字符串操作，包括截取子串，字符串匹配，替换，添加，转化大小写等等
  

• valueof类型，返回值为String
  

• 格式化
  

• 比较类型
  有意思的是这里有两个compare方法，分别是compareTo和compareToIgnoreCase(忽略大小写的比较)。这两个方法的区别在文章的开始已经提出来了，compareToIgnoreCase方法的代码是这样的：
  在这里我们看到了一串熟悉的单词，也就是CASE_INSENSITIVE_ORDER，实际上，compareToIgnoreCase方法就是持有内部类的变量CASE_INSENSITIVE_ORDER调用内部类中的compare方法来实现的，我们来看一些这两个方法的实现代码。

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

• 取出两个字符串的长度，定义lim变量为两者长度较小者
• 复制到新数组进行比较
• 进循环依次比较各个位置的Unicode值大小，返回Unicode差值，如果都相等，则返回长度的产值或0

compareToIgnoreCase：

public int compareToIgnoreCase(String str) {
        return CASE_INSENSITIVE_ORDER.compare(this, str);
    }

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

从代码中可以看到，两个方法都是按照字典顺序依次比较各个字符的Unicode值大小，返回差值，区别是一个区分大小写，而另一个不区分大小写。

关于内部类：
CaseInsensitiveComparator翻译过来就是“大小写不敏感比较器”，而且是静态内部类。
关于String类中的内部类的作用这里有一个小小的疑问，既然内部类中只有一个方法，为什么不去掉这个内部类，直接把方法定义在外面呢？有人说这里是代码复用的一个例子，暂时不太理解，之后再来填坑。