String源码初了解

简单介绍

String是Java常见的数据类型。常说的不可变类。通过源码来看一下比较重要的方法。

类名定义

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

可以看到，首先final修饰了String类，表明了String类是不可被继承的。实现了CharSequence接口，也就需要实现charAt方法.

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

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

final修饰的字符数组。说明了String实际储存是字符数组，且无法改变。

构造方法

从提示上可以看到非常多的构造方法。但都是对value[]进行初始化的不同操作。

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

无参的构造方法就是给value[]进行了初始化，因为final修饰成员变量的初始化 要不直接赋值初始化，要不就在构造器里面初始化。

char[]参数的构造方法调用了Arrays.copyOf方法来进行拷贝，也说明了String在操作上的不可变。

常用方法

 equals

public boolean equals(Object anObject) {
　　　　　//1.如果内存地址相同，则返回true
        if (this == anObject) {
            return true;
        }
　　　　　//2.只有比较的对象是String的实例才能进行比较。否则直接false
        if (anObject instanceof String) {
　　　　　　
            String anotherString = (String)anObject;
            int n = value.length;
            //3.比较各自String的字符数组的长度是否相同
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
               //4.逐个比较字符是否相同
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

chatAt：也是利用字符数组的下标

public char charAt(int index) {
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return value[index];
    }

indexOf

public int indexOf(int ch) {
        return indexOf(ch, 0);
    }

当我们习惯于用单个字符作为参数去获得该字符在String的字符数组里面的下标的时候。

比如String s = "abc";   System.outprintln(s.indexOf('c'));  判断c是否在字符串中，在的话返回下标。

但是进到源码看到的是indexOf的参数是int而不是一开始想的那样是char，其实这里的int是目标字符的Unicode值，放单个字符的话也会转成字符在Unicode编码中对应的代码值。

所以下面的indexOf(int,fromIndex)就比较容易理解了。

public int indexOf(int ch, int fromIndex) {
        final int max = value.length;
        if (fromIndex < 0) {
            fromIndex = 0;
        } else if (fromIndex >= max) {
            // Note: fromIndex might be near -1>>>1.
            return -1;
        }
　　　　
        if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
            // handle most cases here (ch is a BMP code point or a
            // negative value (invalid code point))
            final char[] value = this.value;
            for (int i = fromIndex; i < max; i++) {
                if (value[i] == ch) {
                    return i;
                }
            }
            return -1;
        } else {
            return indexOfSupplementary(ch, fromIndex);
        }
    }

indexOf(int ch,int fromIndex)从指定索引开始搜索，返回在此字符串中第一次出现指定字符的索引。只不过上面的方法索引从0开始。

replace

public String replace(char oldChar, char newChar) {
        if (oldChar != newChar) {
            int len = value.length;
            int i = -1;
            char[] val = value; /* avoid getfield opcode */
　　　　　　　　//当找出第一个与想替换的字符时，跳出循环。
            while (++i < len) {
                if (val[i] == oldChar) {
                    break;
                }
            }
           
            if (i < len) {
　　　　　　　//定义一个新的字符数组来装String的值。然后这buf[]里面进行替换
                char buf[] = new char[len];
                for (int j = 0; j < i; j++) {
                    buf[j] = val[j];
                }
　　　　　　　　//替换的方法。逐个比较，相同则替换成新的，不同则还是c.三目运算
                while (i < len) {
                    char c = val[i];
                    buf[i] = (c == oldChar) ? newChar : c;
                    i++;
                }
　　　　　　　　　　//最后new了一个String返回。
                return new String(buf, true);
            }
        }
        return this;
    }

常用的替换单个字符。大概的过程注释代码写了。主要是这个方法最后会返回一个新的字符串（代码注释有），而不是改原来的String，所以使用的时候记得用String来接收。

concat 

public String concat(String str) {
        int otherLen = str.length();
        if (otherLen == 0) {
            return this;
        }
        int len = value.length;
        char buf[] = Arrays.copyOf(value, len + otherLen);
        str.getChars(buf, len);
        return new String(buf, true);
    }

拼接字符串的方法

一般用的字符串拼接的方法就是  String 的” + “” ,concat，StringBuffer和StringBuilder的append方法。

一般使用建议应该都是 + <concat<StringBuffer<StringBuilder。

String 的+  2个字符串拼接在编译的时候进行了优化，会生成一个StringBuilder对象来进行拼接。2个的+效率并不会低，但是关键在于每一次 +都会生成一个StringBuider对象。会造成内存的浪费。

//一般+ 
String str="";
        for(int i=0;i<10;i++){
           str+=i;
        }
//append
StringBuilder sb = new StringBuilder();
        for(int i=0;i<10;i++) {
            sb.append(i);
        }

所以建议使用StringBuilder进行字符串的操作。StringBuffer对方法进行了同步处理。所以多线程的情况下使用StringBuffer，单线程就使用StringBuilder比较高效。

字符串常量池

jdk1.7以后字符串常量池从方法区移动到堆内存中了。这里就简单介绍一个新建一个String的两种方法的区别。（具体的关于字符串常量池里面存储的到底是String对象还是对象的引用，我看了好几篇都没怎么看明白。暂且当初存储的是String对象）

        String s1 = "abc";
        String s2 = "abc";
        String s3 = new String("abc");
        System.out.println(s1==s2);//true
        System.out.println(s1==s3);//false

这是常见的关于字符串的题目了吧。涉及的就是字符串常量池的问题。

用双引号声明的对象，会先字符串常量池是否存在该字符串进行进行判断。如果存在该字符串，会直接指向字符串常量池的String对象。不存在的话，将该String对象存储在字符串常量池中，然后指向它。

所以s1 = s2 为true 便是 2个String引用都指向了字符串常量池的对象。

而new方法的话，比较好理解，直接在堆中开辟了一个内存来存储该字符串。所以和前面的内存地址就不一样了。所以s1==s3 为false

String的不可变性

我们常说的String是不可变的。但是真的是不可以变的吗。可以通过源码看到，String的设计为final类，实际存储字符的定义为private final字符数组，而且不提供方法来对属性修改。

可以比较明显的看到，实际数据是存储在value[] 字符数组中，虽然定义private final,不提供方法修改。但是私有的成员变量也是可以访问的，那就是反射。。反射出String对象的value，然后通过获取value的引用来改变数组的结构

只不过一般操作String并不会使用这种方法。所以说String是不可变的。

//创建字符串"Hello World"， 并赋给引用s
        String s = "Hello World";
         
        System.out.println("s = " + s); //Hello World
         
        //获取String类中的value字段
        Field valueFieldOfString = String.class.getDeclaredField("value");
         
        //改变value属性的访问权限
        valueFieldOfString.setAccessible(true);
         
        //获取s对象上的value属性的值
        char[] value = (char[]) valueFieldOfString.get(s);
         
        //改变value所引用的数组中的第5个字符
        value[5] = '_';
         
        System.out.println("s = " + s);  //Hello_World

参考文章：https://www.cnblogs.com/wuchanming/p/9201103.html