String类源码

String类源码学习笔记

一、String类的组成

​ 一个 String 字符串实际上是一个 char 数组，我们常说String类是不可变的，是因为这个数组是final修饰的。但事实上只是数组的引用不可变，我们仍然可以通过反射来改变char数组中的元素值。

 private final char value[];

二、String类的方法

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

2. concat：先调用了Arrays.copyOf将原内容放入一个新长度的数组，然后调用String的getChars方法

   	public String concat(String str) {
           int otherLen = str.length();
           // 如果拼接的字符串长度为0，返回原字符串
           if (otherLen == 0) {
               return this;
           }
           int len = value.length;
           // 调用Arrays.copyOf方法
           // 返回一个新长度的数组，并将原数组内容放入新数组中
           char buf[] = Arrays.copyOf(value, len + otherLen);
           str.getChars(buf, len);
       	return new String(buf, true);
   }
   

   	public static char[] copyOf(char[] original, int newLength) {
          // 创建一个新长度的数组
          char[] copy = new char[newLength];
          // 参数的意义分别是：源数组，开始复制位置，目标数组，放的位置，放的长度
          // 将原来的数组放入一个更大的数组中
          System.arraycopy(original, 0, copy, 0,
                             Math.min(original.length, newLength));
          // 返回一个新的数组
          return copy;
      }
      
      void getChars(char dst[], int dstBegin) {
          // 将value字符串放入dst，放入的位置为dst原本的长度往后接，由此实现拼接
          System.arraycopy(value, 0, dst, dstBegin, value.length);
      }
      
   
   

3. indexOf：在数组中一个个匹配，用的是==，没匹配到返回-1

   public int indexOf(int ch) {
   	// 调用了indexOf(int ch, int fromIndex)方法
       return indexOf(ch, 0);
   

       public int indexOf(int ch, int fromIndex) {
       final int max = value.length;
       // 指定索引的位置如果小于0，从0开始搜索
       if (fromIndex < 0) {
           fromIndex = 0;
       } else if (fromIndex >= max) {
           // 指定的位置大于字符串长度，肯定找不到，返回-1
           return -1;
       }
   	// 一个char占用两个字节，如果ch小于2的16次方（65536），绝大多数字符都在此范围内
       if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
           final char[] value = this.value;
           // 从指定索引开始遍历查找，如果找到了返回下标值
           for (int i = fromIndex; i < max; i++) {
               if (value[i] == ch) {
                   return i;
               }
           }
           return -1;
       } else {
       	// 当字符大于 65536时，特殊处理
           return indexOfSupplementary(ch, fromIndex);
       }
   }
   

4. equals: 比较每一个字符，只要有一个字符不相同，返回false

       public boolean equals(Object anObject) {
       // 如果引用相等，那么肯定相同
       if (this == anObject) {
           return true;
       }
       // 比较的对象必须是String类型
       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) {
               	// 只要有一个字符不相同，返回false
                   if (v1[i] != v2[i])
                       return false;
                   i++;
               }
               return true;
           }
       }
       return false;
   }
   

5. charAt: 原理很简单，先检查索引是否合法，如果合法直接返回数组中该索引位置的元素，时间复杂度为0(1)。

   public char charAt(int index) {
        	// 检查索引的合法性
           if ((index < 0) || (index >= value.length)) {
               throw new StringIndexOutOfBoundsException(index);
           }
           // 返回数组中该索引位置的元素
           return value[index];
       }
   

6. substring:

       public String substring(int beginIndex, int endIndex) {
       	// 索引检查
           if (beginIndex < 0) {
               throw new StringIndexOutOfBoundsException(beginIndex);
           }
           if (endIndex > value.length) {
               throw new StringIndexOutOfBoundsException(endIndex);
           }
           // 截取后字符串的长度
           int subLen = endIndex - beginIndex;
           if (subLen < 0) {
               throw new StringIndexOutOfBoundsException(subLen);
           }
           // 调用构造函数返回截取后的字符串
           return ((beginIndex == 0) && (endIndex == value.length)) ? this
                   : new String(value, beginIndex, subLen);
       }
   

7. intern()：如果常量池中有该对象了，直接返回该字符串的引用（存在堆中就返回堆中，存在池中就返回池中），如果没有，则将该对象添加到池中，并返回池中的引用。

三、String常量池

    public static void main(String[] args) throws Exception {

        String str = "a"; // String对象在常量池中
        String otherStr = "a"; // 使用相同的字符常量，直接从常量池中取
        System.out.println(str == otherStr); // true，两个的引用是相同的，因为是同一个对象

        String str2 = new String("a"); // String对象在堆中
        System.out.println(str == str2); // false,一个在堆中，一个在常量池，引用肯定不同

        String str3 = "aa";
        // true 常量拼接，还是放在常量池，如果常量池有，直接引用
        System.out.println(("a" + "a") == str3); 
        // false 变量拼接，放入堆中（常量池也放入一份）
        System.out.println((str + otherStr) == str3); 
        System.out.println((str2 + "a") == str3); 
        
    }

四、String不可变的原因

安全

• 引发安全问题，譬如，数据库的用户名、密码都是以字符串的形式传入来获得数据库的连接，或者在socket编程中，主机名和端口都是以字符串的形式传入。因为字符串是不可变的，所以它的值是不可改变的，否则黑客们可以钻到空子，改变字符串指向的对象的值，造成安全漏洞。
• 保证线程安全，在并发场景下，多个线程同时读写资源时，会引竞态条件，由于 String 是不可变的，不会引发线程的问题而保证了线程。
• HashCode，当 String 被创建出来的时候，hashcode也会随之被缓存，hashcode的计算与value有关，若 String 可变，那么 hashcode 也会随之变化，针对于 Map、Set 等容器，他们的键值需要保证唯一性和一致性，因此，String 的不可变性使其比其他对象更适合当容器的键值。

性能

• 当字符串是不可变时，字符串常量池才有意义。字符串常量池的出现，可以减少创建相同字面量的字符串，让不同的引用指向池中同一个字符串，为运行时节约很多的堆内存。若字符串可变，字符串常量池失去意义，基于常量池的String.intern()方法也失效，每次创建新的 String 将在堆内开辟出新的空间，占据更多的内存。

参考文档：https://www.cnblogs.com/ysocean/p/8711071.html