Java的String类详解

Java的String类

String类是除了Java的基本类型之外用的最多的类, 甚至用的比基本类型还多. 同样jdk中对Java类也有很多的优化

类的定义

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence{
   /** The value is used for character storage. */
    private final char value[];

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

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;

    /**
     * Class String is special cased within the Serialization Stream Protocol.
     *
     * A String instance is written into an ObjectOutputStream according to
     * <a href="{@docRoot}/../platform/serialization/spec/output.html">
     * Object Serialization Specification, Section 6.2, "Stream Elements"</a>
     */
    private static final ObjectStreamField[] serialPersistentFields =
        new ObjectStreamField[0];

    /**
     * Initializes a newly created {@code String} object so that it represents
     * an empty character sequence.  Note that use of this constructor is
     * unnecessary since Strings are immutable.
     */
    public String() {
        this.value = "".value;
    }

    /**
     * Initializes a newly created {@code String} object so that it represents
     * the same sequence of characters as the argument; in other words, the
     * newly created string is a copy of the argument string. Unless an
     * explicit copy of {@code original} is needed, use of this constructor is
     * unnecessary since Strings are immutable.
     *
     * @param  original
     *         A {@code String}
     */
    public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }

• Final 标识不允许集成重载. jdk中还多重要类都是final 标识, 防止应用程序继承重载以影响jdk的安全

• 继承Serializable 接口, 可以放心的序列化

• Comparable 接口, 可以根据自然序排序.

• CharSequence 字符串的重要接口

• char数组 value . Final 修饰.

• hash字段 int, 表示当前的hashCode值, 避免每次重复计算hash值

Comparable 接口的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;  //如果前面的长度字符串都一样, 则长度长的大
}

• 从左往右逐个char字符比较大小, 从代码可以看出 "S" > "ASSSSSSSSSSSSSSS"

• 也只是循环比较到长度短的那个字符串

• 如果前面的长度字符串都一样, 则长度长的大

  构造方法

/**
 * Initializes a newly created {@code String} object so that it represents
 * an empty character sequence.  Note that use of this constructor is
 * unnecessary since Strings are immutable.
 */
public String() {
    this.value = "".value;
}

/**
 * Initializes a newly created {@code String} object so that it represents
 * the same sequence of characters as the argument; in other words, the
 * newly created string is a copy of the argument string. Unless an
 * explicit copy of {@code original} is needed, use of this constructor is
 * unnecessary since Strings are immutable.
 *
 * @param  original
 *         A {@code String}
 */
public String(String original) {
    this.value = original.value;
    this.hash = original.hash;
}
/**
*
*/
 public String(byte bytes[], int offset, int length, Charset charset) {
        if (charset == null)
            throw new NullPointerException("charset");
        checkBounds(bytes, offset, length);
        this.value =  StringCoding.decode(charset, bytes, offset, length);
    }

• 空白构造方法其实是生成 "" 字符串

• 传入其他字符串的构造方式其实只是把其他字符串的value 和hash 值的引用复制一份, 不用担心两个字符串的value和hash 互相干扰. 因为String类中没有修改这两个值的方法, 并且这两个值是private final修饰的, 已经无法修改了

• 空白构造方法中没有设置hash的值, 则使用 hash的默认值 // Default to 0

• 传入字节数组的构造方法, 怎么将字节转成字符串是使用StringCoding.decode(charset, bytes, offset, length);方法

  StringCoding类的修饰符是default 并且里面都是default static 修饰的方法, 很遗憾, 我们无法直接使用其中的方法

StringCoding.decode 方法

static char[] decode(Charset cs, byte[] ba, int off, int len) {
    // (1)We never cache the "external" cs, the only benefit of creating
    // an additional StringDe/Encoder object to wrap it is to share the
    // de/encode() method. These SD/E objects are short-lifed, the young-gen
    // gc should be able to take care of them well. But the best approash
    // is still not to generate them if not really necessary.
    // (2)The defensive copy of the input byte/char[] has a big performance
    // impact, as well as the outgoing result byte/char[]. Need to do the
    // optimization check of (sm==null && classLoader0==null) for both.
    // (3)getClass().getClassLoader0() is expensive
    // (4)There might be a timing gap in isTrusted setting. getClassLoader0()
    // is only chcked (and then isTrusted gets set) when (SM==null). It is
    // possible that the SM==null for now but then SM is NOT null later
    // when safeTrim() is invoked...the "safe" way to do is to redundant
    // check (... && (isTrusted || SM == null || getClassLoader0())) in trim
    // but it then can be argued that the SM is null when the opertaion
    // is started...
    CharsetDecoder cd = cs.newDecoder();
    int en = scale(len, cd.maxCharsPerByte());
    char[] ca = new char[en];
    if (len == 0)
        return ca;
    boolean isTrusted = false;
    if (System.getSecurityManager() != null) {
        if (!(isTrusted = (cs.getClass().getClassLoader0() == null))) {
            ba =  Arrays.copyOfRange(ba, off, off + len);
            off = 0;
        }
    }
    cd.onMalformedInput(CodingErrorAction.REPLACE)
      .onUnmappableCharacter(CodingErrorAction.REPLACE)
      .reset();
    if (cd instanceof ArrayDecoder) {
        int clen = ((ArrayDecoder)cd).decode(ba, off, len, ca);
        return safeTrim(ca, clen, cs, isTrusted);
    } else {
        ByteBuffer bb = ByteBuffer.wrap(ba, off, len);
        CharBuffer cb = CharBuffer.wrap(ca);
        try {
            CoderResult cr = cd.decode(bb, cb, true);
            if (!cr.isUnderflow())
                cr.throwException();
            cr = cd.flush(cb);
            if (!cr.isUnderflow())
                cr.throwException();
        } catch (CharacterCodingException x) {
            // Substitution is always enabled,
            // so this shouldn't happen
            throw new Error(x);
        }
        return safeTrim(ca, cb.position(), cs, isTrusted);
    }
}

• 真正的byte[] 转成char[] 是使用CharsetDecoder虚拟类, 而这个类的对象是你传入的Charset字符编码类中生成的.

  看下UTF8的CharsetDecoder实现类.

  UTF8的CharsetDecoder 类是内部静态类, 实现了CharsetDecoder 和ArrayDecoder 接口, 接口中的方法很长,都是字节转字符的一些换算, 如果要看懂, 需要一些编码的知识. 追到这里结束

  private static class Decoder extends CharsetDecoder implements ArrayDecoder {
      private Decoder(Charset var1) {
          super(var1, 1.0F, 1.0F);
      }
       // 此处省略无关方法.......
        /**
        * 真正的字节转字符的方法
        */
        public int decode(byte[] var1, int var2, int var3, char[] var4) {
              int var5 = var2 + var3;
              int var6 = 0;
              int var7 = Math.min(var3, var4.length);
  
              ByteBuffer var8;
              for(var8 = null; var6 < var7 && var1[var2] >= 0; var4[var6++] = (char)var1[var2++]) {
              }
  
              while(true) {
                  while(true) {
                      while(var2 < var5) {
                          byte var9 = var1[var2++];
                          if (var9 < 0) {
                              byte var10;
                              if (var9 >> 5 != -2 || (var9 & 30) == 0) {
                                  byte var11;
                                  if (var9 >> 4 == -2) {
                                      if (var2 + 1 < var5) {
                                          var10 = var1[var2++];
                                          var11 = var1[var2++];
                                          if (isMalformed3(var9, var10, var11)) {
                                              if (this.malformedInputAction() != CodingErrorAction.REPLACE) {
                                                  return -1;
                                              }
  
                                              var4[var6++] = this.replacement().charAt(0);
                                              var2 -= 3;
                                              var8 = getByteBuffer(var8, var1, var2);
                                              var2 += malformedN(var8, 3).length();
                                          } else {
                                              char var15 = (char)(var9 << 12 ^ var10 << 6 ^ var11 ^ -123008);
                                              if (Character.isSurrogate(var15)) {
                                                  if (this.malformedInputAction() != CodingErrorAction.REPLACE) {
                                                      return -1;
                                                  }
  
                                                  var4[var6++] = this.replacement().charAt(0);
                                              } else {
                                                  var4[var6++] = var15;
                                              }
                                          }
                                      } else {
                                          if (this.malformedInputAction() != CodingErrorAction.REPLACE) {
                                              return -1;
                                          }
  
                                          if (var2 >= var5 || !isMalformed3_2(var9, var1[var2])) {
                                              var4[var6++] = this.replacement().charAt(0);
                                              return var6;
                                          }
  
                                          var4[var6++] = this.replacement().charAt(0);
                                      }
                                  } else if (var9 >> 3 != -2) {
                                      if (this.malformedInputAction() != CodingErrorAction.REPLACE) {
                                          return -1;
                                      }
  
                                      var4[var6++] = this.replacement().charAt(0);
                                  } else if (var2 + 2 < var5) {
                                      var10 = var1[var2++];
                                      var11 = var1[var2++];
                                      byte var12 = var1[var2++];
                                      int var13 = var9 << 18 ^ var10 << 12 ^ var11 << 6 ^ var12 ^ 3678080;
                                      if (!isMalformed4(var10, var11, var12) && Character.isSupplementaryCodePoint(var13)) {
                                          var4[var6++] = Character.highSurrogate(var13);
                                          var4[var6++] = Character.lowSurrogate(var13);
                                      } else {
                                          if (this.malformedInputAction() != CodingErrorAction.REPLACE) {
                                              return -1;
                                          }
  
                                          var4[var6++] = this.replacement().charAt(0);
                                          var2 -= 4;
                                          var8 = getByteBuffer(var8, var1, var2);
                                          var2 += malformedN(var8, 4).length();
                                      }
                                  } else {
                                      if (this.malformedInputAction() != CodingErrorAction.REPLACE) {
                                          return -1;
                                      }
  
                                      int var14 = var9 & 255;
                                      if (var14 <= 244 && (var2 >= var5 || !isMalformed4_2(var14, var1[var2] & 255))) {
                                          ++var2;
                                          if (var2 >= var5 || !isMalformed4_3(var1[var2])) {
                                              var4[var6++] = this.replacement().charAt(0);
                                              return var6;
                                          }
  
                                          var4[var6++] = this.replacement().charAt(0);
                                      } else {
                                          var4[var6++] = this.replacement().charAt(0);
                                      }
                                  }
                              } else {
                                  if (var2 >= var5) {
                                      if (this.malformedInputAction() != CodingErrorAction.REPLACE) {
                                          return -1;
                                      }
  
                                      var4[var6++] = this.replacement().charAt(0);
                                      return var6;
                                  }
  
                                  var10 = var1[var2++];
                                  if (isNotContinuation(var10)) {
                                      if (this.malformedInputAction() != CodingErrorAction.REPLACE) {
                                          return -1;
                                      }
  
                                      var4[var6++] = this.replacement().charAt(0);
                                      --var2;
                                  } else {
                                      var4[var6++] = (char)(var9 << 6 ^ var10 ^ 3968);
                                  }
                              }
                          } else {
                              var4[var6++] = (char)var9;
                          }
                      }
  
                      return var6;
                  }
              }
          }
  

**结论: 字节转换成字符串需要使用到工具类StringCoding 类的decode方法,此方法会依赖传入的Charset 编码类中的内部静态类StringDecode的decode方法来真正的把字节转成字符串. Java通过接口的定义很好的把具体的实现转移到具体的编码类中, 而String只要面向接口编程就可以了, 这样也方便扩展不同的编码 **

同样的String的getBytes方法也是把主要的工作转移到具体Charset 编码类的StringEncode 来完成

hashCode方法

重写了此方法, 并且值和每个字符有关

public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;
        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];   //为何旧值要乘以31
        }
        hash = h;
		}
		return h;
}

字符串的拼接concat方法和join静态方法

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);
}

• 直接在内存中复制一份新的数组, 在new 一个String对象. 线程安全. 性能较低.

• 也可以直接是用 + 拼接.

  参考 https://blog.csdn.net/youanyyou/article/details/78992978这个链接了解到. + 链接再编译成字节码后还是使用的StringBuiler 来拼接, 而concat 还是使用数组复制加上 new 新对象来拼接, 综合得出 还是使用 + 来拼接吧, 性能更好

join静态方法

public static String join(CharSequence delimiter, CharSequence... elements) {
    Objects.requireNonNull(delimiter);
    Objects.requireNonNull(elements);
    // Number of elements not likely worth Arrays.stream overhead.
    StringJoiner joiner = new StringJoiner(delimiter);
    for (CharSequence cs: elements) {
        joiner.add(cs);
    }
    return joiner.toString();
}

具体的代码需要追到StringJoiner类中

public final class StringJoiner {
    private final String prefix;
    private final String delimiter;
    private final String suffix;

    /*
     * StringBuilder value -- at any time, the characters constructed from the
     * prefix, the added element separated by the delimiter, but without the
     * suffix, so that we can more easily add elements without having to jigger
     * the suffix each time.
     */
    private StringBuilder value;

  /**
     * Adds a copy of the given {@code CharSequence} value as the next
     * element of the {@code StringJoiner} value. If {@code newElement} is
     * {@code null}, then {@code "null"} is added.
     *
     * @param  newElement The element to add
     * @return a reference to this {@code StringJoiner}
     */
    public StringJoiner add(CharSequence newElement) {
        prepareBuilder().append(newElement);
        return this;
    }

    private StringBuilder prepareBuilder() {
        if (value != null) {
            value.append(delimiter);
        } else {
            value = new StringBuilder().append(prefix);
        }
        return value;
    }

• 内部发现还是使用StringBuilder来实现, join 完全就是一个为了使用方便的一个工具方法

replace方法

public String replace(char oldChar, char newChar) 

• 使用数组遍历替换

public String replace(CharSequence target, CharSequence replacement)

• 使用正则表达式进行替换, 正则的源码在 接下来的文章分析

Format 静态方法, 可以格式换字符串, 主要用于字符串的国际化,

内部使用了Formatter类, 而Formatter 中也是使用了正则表达式,

toLowerCase方法

public String toLowerCase(Locale locale) 

• 遍历char 数组, 每个字符使用Character.toLowerCase 来小写

trim 方法

从前后遍历空白字符, 判断空白字符是使用的 char <=' ' 来判断的(学到一点), 后面在使用substring来截取非空白字符

substring方法

内部使用public String(char value[], int offset, int count) 构造方法来生成新的字符串, 在这个构造方法内部会有数组的赋值

valueOf方法

public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}
// 内部使用传入对象的自己的toString方法, 传入对象如果没有重载toString方法, 就使用默认的toString方法. 

public static String valueOf(char data[]) {
    return new String(data);
}
// 根据传入的数组来选择合适的构造方法来生成String对象

public static String valueOf(boolean b) {
    return b ? "true" : "false";
}
// 根据传入布尔值

static copyValueOf方法

public static String copyValueOf(char data[], int offset, int count) {
        return new String(data, offset, count);
    }
// 静态工具方法, 默认使用合适构造方法来截取和生成新新的字符串

native intern方法

这个方法涉及到String的内存和常量池, 具体会在其他文章中详解.

public native String intern();