String源码学习

indexOf(String str)

先根据相应解码方式，选择对应的处理类。算法思路：先查找到第一个相同的字符，再查找余下的字符，时间复杂度O(n-m)*m，空间复杂度O(1),其中n代表原字符串长度，m代表要查找的字符串长度

 // String.java 
 // 根据相应解码方式，选择对应的处理
 public int indexOf(String str) {
     byte coder = coder();
     if (coder == str.coder()) {
         return isLatin1() ? StringLatin1.indexOf(value, str.value)
                           : StringUTF16.indexOf(value, str.value);
     }
     if (coder == LATIN1) {  // str.coder == UTF16
         return -1;
     }
     return StringUTF16.indexOfLatin1(value, str.value);
 }

 // StringUTF16.java 会调用indexOf(value, value.length, str, str.length, 0)
 // 算法思路：先查找到第一个相同的字符，再查找余下的字符，时间复杂度O(n-m)*m，空间复杂度O(1),其中n代表原字符串长度，m代表要查找的字符串长度
 public static int indexOf(byte[] value, int valueCount, byte[] str, int strCount, int fromIndex) {
     byte first = str[0];
     int max = (valueCount - strCount);
     for (int i = fromIndex; i <= max; i++) {
         // Look for first character.
         if (value[i] != first) {
             while (++i <= max && value[i] != first);
         }
         // Found first character, now look at the rest of value
         if (i <= max) {
             int j = i + 1;
             int end = j + strCount - 1;
             for (int k = 1; j < end && value[j] == str[k]; j++, k++);
             if (j == end) {
                 // Found whole string.
                 return i;
             }
         }
     }
     return -1;
 }

substring()

通过jvm进行数组复制重新生成结果String

   // String.java 
   // 根据相应解码方式，选择对应的处理
   public String substring(int beginIndex, int endIndex) {
       int length = length();
       checkBoundsBeginEnd(beginIndex, endIndex, length);
       if (beginIndex == 0 && endIndex == length) {
           return this;
       }
       int subLen = endIndex - beginIndex;
       return isLatin1() ? StringLatin1.newString(value, beginIndex, subLen)
                         : StringUTF16.newString(value, beginIndex, subLen);
   }

   // StringUTF16.java 
   // 交给Arrays.copyOfRange
   public static String newString(byte[] val, int index, int len) {
       if (len == 0) {
           return "";
       }
       return new String(Arrays.copyOfRange(val, index, index + len),
                         LATIN1);
   }
   // Arrays.java
   public static <T> T[] copyOfRange(T[] original, int from, int to) {
       return copyOfRange(original, from, to, (Class<? extends T[]>) original.getClass());
   }
   // 传过来的byte[]，所有会走Array.newInstance，创建一个数组
   public static <T,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType) {
       int newLength = to - from;
       if (newLength < 0)
           throw new IllegalArgumentException(from + " > " + to);
       @SuppressWarnings("unchecked")
       T[] copy = ((Object)newType == (Object)Object[].class)
           ? (T[]) new Object[newLength]
           : (T[]) Array.newInstance(newType.getComponentType(), newLength);
       System.arraycopy(original, from, copy, 0,
                        Math.min(original.length - from, newLength));
       return copy;
   }
   // Array.java newInstance()实际上是创建一个数据
   private static native Object newArray(Class<?> componentType, int length);
   // System.java
   public static native void arraycopy(Object src,  int  srcPos, Object dest, int destPos, int length);