String源码分析

前言：String类在日常开发过程中使用频率非常高，平时大家可能看过String的源码，但是真的认真了解过它么，笔者在一次笔试过程中要求写出String的equals方法，瞬间有点懵逼，凭着大致的理解，算是写出来了，可是下来一翻String的源码顿悟，原来自己写得是多么的low，所以有必要把这些基础知识点记录下来，加深印象。

注：本文jdk源码版本为jdk1.8.0_172

---

1.String类的基本概念

首先String是不可变对象，其体现主要在String类是被final关键字修饰，因此该对象不能被继承，不能被修改。那你可能要问了为什么我们在日常操作过程中不是可以很方便的修改String的内容吗？其实我们修改其内容是new了一个对象，原来的内容并没有改变。

String内部是通过char数组来存储的内容，从以下源码中可以发现：

注：这里的char数组也是被final修饰。

2.String的构造函数

不知道你注意没，String的构造函数非常的多：

这里挑选几个笔者认为有特点的构造函数进行分析，其它构造函数请查看相应源码。

#1.默认构造函数：

 public String() {
        this.value = "".value;
    }

注：默认构造函数的实现非常简单，就是返回空字符串的数组形式。

#2.入参为char数组：

 public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
    }

分析：如果传入char数组，是通过Arrays#copyOf方法进行拷贝的。

#3.入参为String对象：

  public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }

分析：如果入参为String对象，则直接进行相应的赋值即可（value和hash值）。

#4.入参为StringBuffer：

   public String(StringBuffer buffer) {
        synchronized(buffer) {
            this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
        }
    }

分析：这里对StringBuffer进行了加锁，然后再进行拷贝操作。为什么要对StringBuffer加锁呢？StringBuffer不是线程安全的吗？其实这里对其进行加锁正是为了保证在多线程环境下只能有一个线程去操作StringBuffer对象，这里需要注意一下。

#5.入参为StringBuilder：

  public String(StringBuilder builder) {
        this.value = Arrays.copyOf(builder.getValue(), builder.length());
    }

分析：对比StringBuffer入参，如果用StringBuilder作为入参是不加锁操作的，因为StringBuilder本身线程不安全，但会提升性能，并且其源码上也做出了相应注释。

注意：以StringBuffer和StringBuilder为入参的构造函数这里要特别关注一下：StringBuffer线程安全，为了保证在String中也线程安全所以需要加锁，而StringBuilder非线程安全，因此不需要加锁操作，直接进行拷贝即可。

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

分析：String的hashCode方法还是比较简单的，它是遍历char数组以31为基数做一个累加操作。注意这里是以31来作为的基数，为什么取31作为基数可参考：String hashCode 方法为什么选择数字31作为乘子

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

分析：首先会判断是否是同一个对象，如果是，则直接返回true；其次判断传入对象是否为String对象，如果对象不匹配直接返回false，否则依次比较两个对象的char，只要发现一个不相等，则直接返回false，停止循环。这里的写法还是比较简洁的，在日常开发中可以利用起来。

5.关于不可变对象

关于不可变对象，这里看一段源码就清楚了

  public String substring(int beginIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        int subLen = value.length - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
    }

截取函数，直接看第9行代码处，如果beginIndex==0，返回的是当前对象，否则这里是new的一个新对象，其实String中的很多函数都是这样的操作，具体可翻看源码阅读一下。

---

总结

#1.String类在日常开发中经常使用，但可能对其源码并不是十分了解，通过分析其源码，了解更多看似简单的知识点。

#2.String类的构造函数非常多，需要注意一下，特别是StringBuffer和StringBuilder为入参的构造函数。

#3.String是不可变对象。

#4.String#hashCode的计算方式，以31为计算基数。

by Shawn Chen，2019.08.20日，上午。