Java基础——String

1、String的特点是什么？它有那些重要方法？

String 内部实际存储结构为 char 数组

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    //用于存储值的char数组
    private final char value[];

    //缓存字符串的 hash code
    private int hash; // Default to 0
    ......
}

String源码包含的重要方法：

多重构造方法

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

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

// StringBuffer 为参数的构造方法
public String(StringBuffer buffer) {

//加了锁，线程安全，但效率降低
 synchronized(buffer) {
        this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
    }
}

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

equals() 方法

//用来比较两个字符串是否相等，String 类型重写了 Object 中的 equals() 方法，和equals()方法相似的还有equalsIgnoreCase()方法，equalsIgnoreCase()方法：用于忽略字符串的大小写之后进行字符串对比
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;
            //判断对比的两个值长度是否相等，否，false
            if (n == anotherString.value.length) {
               //将要对比的值转化为char数组
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                //循环对比char数组，只要有一个字节不一样，就返回false
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }  

compareTo()

//用于比较两个字符串，返回的结果为 int 类型的值，和 compareTo() 比较类似的方法 compareToIgnoreCase()，用于忽略大小写后比较两个字符串。
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;
}

indexOf()：查询字符串首次出现的下标位置
lastIndexOf()：查询字符串最后出现的下标位置
contains()：查询字符串中是否包含另一个字符串
toLowerCase()：把字符串全部转换成小写
toUpperCase()：把字符串全部转换成大写
length()：查询字符串的长度
trim()：去掉字符串首尾空格
replace()：替换字符串中的某些字符
split()：把字符串分割并返回字符串数组
join()：把字符串数组转为字符串

延申的问题：

1、== 、equals和compareTo() 的区别是什么?

compareTo() 方法和 equals() 方法都是用来比较两个字符串值是否相等，但equals() 可以接收一个 Object 类型的参数，而 compareTo() 只能接收一个 String 类型的参数，equals() 返回值为 Boolean，而 compareTo() 的返回值则为 int

当 equals() 方法返回 true 时，或者是 compareTo() 方法返回 0 时，则表示两个字符串完全相同

== 对于基本数据类型来说，是用于比较 “值”是否相等的；而对于引用类型来说，是用于比较引用地址是否相同的

Object中equals()方法其实就是==，String 重写了 equals() 方法把它修改成比较两个字符串的值是否相等。

public boolean equals(Object obj) {
    return (this == obj);
}

//equals和==比较
public static  void main(String[] args){
       //引用类型
        String a = "123";
        String b = new String ("123");
        String c = a;
        String d = b ;
        String e = "123";
        String f = new String ("123");
        System.out.println(a == b); //false
        System.out.println(a == c); //true
        System.out.println(a == d); //false
        System.out.println(a.equals(b)); //true
        System.out.println(a.equals(c)); //true
        System.out.println(a.equals(d)); //true
        System.out.println(b == c); //fasle
        System.out.println(b == d); //true
        System.out.println(b.equals(c)); // true
        System.out.println(b.equals(d));//true
        System.out.println(c == d); //false
        System.out.println(c.equals(d)); //true
        System.out.println(a == e); // true
        System.out.println(a.equals(e)); //true
        System.out.println(b == f); //false
        System.out.println(b.equals(f)); //true
       //基础类型
       // int、byte、short、long、float、double、char、boolean
        int n = 1;
        int m = 1;
        int s = n;
        System.out.println(n == m); //true
        System.out.println(n == s); //true
        System.out.println(m == s); //true
    }

2、String用final修饰的好处是什么？

final 修饰的第一个好处是安全；第二个好处是高效

使用 final，因为它能够缓存结果，当你在传参时不需要考虑谁会修改它的值；如果是可变类的话，则有可能需要重新拷贝出来一个新值进行传参，这样在性能上就会有一定的损失。

迫使 String 类设计成不可变的另一个原因是安全，当你在调用其他方法时，比如调用一些系统级操作指令之前，可能会有一系列校验，如果是可变类的话，可能在你校验过后，它的内部的值又被改变了，这样有可能会引起严重的系统崩溃问题

例如：String s1 = "java" ,String s2 = "java" ,s1和s2的值相等，在字符串常量池中都指向一个值为“java”的常量（new出来的String对象会放到堆栈中），若String类可变的话，当你修改是s1的值的时候，s2的值也会随之改变

3、String 和 StringBuilder、StringBuffer 的区别

String 类型是不可变的，所以在字符串拼接的时候如果使用 String 的话性能会很低

StringBuffer，提供了 append 和 insert 方法可用于字符串的拼接，使用 synchronized 来保证线程安全，但相对的效率也会降低

StringBuilder，提供了 append 和 insert 的拼接方法，但它没有使用 synchronized 来修饰，因此在性能上要优于 StringBuffer，所以在非并发操作的环境下可使用 StringBuilder 来进行字符串拼接

4、String 类型在 JVM（Java 虚拟机）中是如何存储的？

String常见的赋值方法有两种，一种是直接赋值，String s1 = "123" ,另一种是new String() 的方式，String s2 = new String ("123")

直接赋值的方式会先去字符串常量池中查找是否已经有此值，如果有则把引用地址直接指向此值，否则会先在常量池中创建，然后再把引用指向此值

new String() 的方式一定会先在堆上创建一个字符串对象，然后再去常量池中查询此字符串的值是否已经存在，如果不存在会先在常量池中创建此字符串，然后把引用的值指向此字符串

注意：JDK 1.7 之后把永生代换成的元空间，把字符串常量池从方法区移到了 Java 堆上