String
- 典型回答
- String 源码几个重要的方法

String

String类 - 图2

典型回答

以主流的 JDK 版本 1.8 来说，String 内部实际存储结构为 char 数组，源码如下：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    // 用于存储字符串的值
    private final char value[];
    // 缓存字符串的 hash code
    private int hash; // Default to 0
    // ......其他内容
}

String 源码几个重要的方法

多构造方法

String 字符串有以下 4 个重要的构造方法：

// String 为参数的构造方法
public String(String original) {
        this.value = original.value;
    this.coder = original.coder;
    this.hash = original.hash;
}

// char[] 为参数的构造方法
public String(char value[]) {
        this(value, 0, value.length, null);
}

// StringBuffer 为参数的构造方法
public String(StringBuffer buffer) {
        this(buffer.toString());
}
---
// JDK8
public String(StringBuffer buffer) {
        synchronized(buffer) {
                this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
    }
 }

// StringBuilder 为参数的构造方法
public String(StringBuilder builder) {
        this(builder, null);
}
---
// JDK8
public String(StringBuilder builder) {
        this.value = Arrays.copyOf(builder.getValue(), builder.length());
}

equals() 比较两个字符串是否相等

会将字符转化为char数组进行一一对比

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String aString = (String)anObject;
        if (coder() == aString.coder()) {
            return isLatin1() ? StringLatin1.equals(value, aString.value)
                              : StringUTF16.equals(value, aString.value);
        }
    }
    return false;
}
---
// JDK8
public boolean equals(Object anObject) {
    // 对象引用相同直接返回true
    if(this == anObject) {
        return true;
    }
    // 判断需要对比的值是否为String类型，如果不是直接返回true
    if(anObject instanceof String) {
        String anotherString =(String)anObject;
        int n = value.length;
        if(n == anotherString.value.length) {
            // 把两个字符都转化为char数组对比
            char v1[]= value;
            char v2[]= anotherString.value;
            int i = 0;
            // 循环对比两个字符串的每一个字符
            while(n-- != 0) {
                // 如果其中有一个不相等就返回false，否则继续对比
                if(v1[i]!= v2[i])
                return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

instanceof 的使用

instanceof 运算符只能用作对象的判断

Object oString = "123";
Object oInt = 123;
oString instanceof String  // true
oInt instanceof String  // false

compareTo

compareTo()方法会循环对比所有的字符
当两个字符串中有任意一个字符不相同时
则 return charl-char2

public int compareTo(String anotherString) {
    byte v1[] = value;
    byte v2[] = anotherString.value;
    if (coder() == anotherString.coder()) {
        return isLatin1() ? StringLatin1.compareTo(v1, v2)
                          : StringUTF16.compareTo(v1, v2);
    }
    return isLatin1() ? StringLatin1.compareToUTF16(v1, v2)
                      : StringUTF16.compareToLatin1(v1, v2);
}
---
// JDK8
public int compareTo(String anotherString) {
    int len1 = value.length;
    int len2 = anotherString.value.length;
    // 获取到两个字符串长度两个最短的int值
    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;
}

compareTo()和equals()区别

compareTo()方法和equals()方法都是用于比较两个字符串的
但有两点不同：
- quals()可以接收一个Object类型的参数，而compareTo()只能接收一个String类型的参数
- equals()返回值为Boolean,而compareTo()的返回值则为int都可以用于两个字符串的比较当equals()方法返回true时，或是compareTo()方法返回0时
  则表示两个字符串完全相同
  
  其他主要方法
  
  问题：
- 为什么String类型要用final修饰？
- ==和equals的区别是什么？
- String和StringBuilder、StringBuffer有什么区别？
- String的intern()方法有什么含义？
- String类型在JVM(Java虚拟机）中是如何存储的？编译器对String做了哪些优化？
- ==和equals的区别是什么?
  ==对于基本数据类型来说，是用于比较“值”是否相等的，
  而对于引用类型来说，是用于比较引用地址是否相同的。
```java // Object 类的 public boolean equals(Object obj) { return (this == obj); }

// JDK11 String重写 public boolean equals(Object anObject) { if (this == anObject) { return true; } if (anObject instanceof String) { String aString = (String)anObject; if (coder() == aString.coder()) { return isLatin1() ? StringLatin1.equals(value, aString.value) : StringUTF16.equals(value, aString.value); } } return false; }

// JDK8 String重写 public boolean equals(Object anObject) { // 对象引用相同直接返回true if (this == anObject) { return true; } // 判断对比的值是否为String类型，不是直接返回false if (anObject instanceof String) { String anotherString = (String)anObject; int n = value.length; if (n == anotherString.value.length) { // 把两个字符串转换为char数组对比 char v1[] = value; char v2[] = anotherString.value; int i = 0; // 循环对比两个字符串的每一个字符 while (n— != 0) { // 如果其中一个值不相等就返回true，否则继续对比 if (v1[i] != v2[i]) return false; i++; } return true; } } return false; }

<a name="o5YWc"></a>
## final修饰的好处<br /><br />
_Java语言之父James Gosling_的回答是：<br />他会更倾向于使用final，因为它能够缓存结果，当你在传参时不需要考虑谁会修改它的值。<br />如果是可变类的话，则有可能需要重新拷贝出来一个新值进行传参，这样在性能上就会有一定的损失。<br />迫使String类设计成不可变的另一个原因是安全<br />![](https://gitee.com/dafran/pic-go/raw/master/img/Untitled.png#crop=0&crop=0&crop=1&crop=1&id=z9mUe&originHeight=538&originWidth=1331&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=) 
<a name="WqLlJ"></a>
## String和StringBuilder、StringBuffer的区别
- String类型是不可变的
- 所以在字符串拼接的时候如果使用String的话性能会很低
- 因此就需要使用另一个数据类型 **StringBuffer**
- 它提供了append和insert方法可用于字符串的拼接
- 它使用synchronized来保证线程安全

@Override public synchronized StringBuffer append(Object obj) { toStringCache = null; super.append(String.valueOf(obj)); return this; }

@Override public synchronized StringBuffer append(String str) { toStringCache = null; super.append(str); return this; }

@Override public StringBuilder append(Object obj) { return append(String.valueOf(obj)); }

@Override public StringBuilder append(String str) { super.append(str); return this; }

String常见的创建方式有两种：<br />①“String s1="Java";"直接赋值的方式<br />② "String s2=new String("Java");"的方式<br />![](https://gitee.com/dafran/pic-go/raw/master/img/Untitled%201.png#crop=0&crop=0&crop=1&crop=1&id=SRi7s&originHeight=579&originWidth=1128&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)同时JVM对String做了优化 
```java
String s1 = "Ja" + "va";
String s2 = "Java";
//s1 == s2

String类