紧凑字符串和Indify字符串连接

# find -iname \*.java -exec grep charAt {} \; | wc -l
2157
Simplest use case:
for (int i = 0; i < s.length(); i++) {
   char c = s.charAt(i);
   System.out.println(c);
}

final class StringLatin1 {
    public static char charAt(byte[] value, int index) {
        checkIndex(index, value.length);
        return (char)(value[index] & 0xff);
    }
}
final class StringUTF16 {

    // Return a new byte array for a UTF16-coded string for len chars
    // Throw an exception if out of range
    public static byte[] newBytesFor(int len) {
        return new byte[newBytesLength(len)];
    }

    // Check the size of a UTF16-coded string
    // Throw an exception if out of range
    public static int newBytesLength(int len) {
        if (len < 0) {
            throw new NegativeArraySizeException();
        }
        if (len >= MAX_LENGTH) {
            throw new OutOfMemoryError("UTF16 String size is " + len +
                                       ", should be less than " + MAX_LENGTH);
        }
        return len << 1;
    }
     static void putChar(byte[] val, int index, int c) {
        assert index >= 0 && index < length(val) : "Trusted caller missed bounds check";
        index <<= 1;
        val[index++] = (byte)(c >> HI_BYTE_SHIFT);
        val[index]   = (byte)(c >> LO_BYTE_SHIFT);
    }

    @IntrinsicCandidate
    // intrinsic performs no bounds checks
    static char getChar(byte[] val, int index) {
        assert index >= 0 && index < length(val) : "Trusted caller missed bounds check";
        index <<= 1;
        return (char)(((val[index++] & 0xff) << HI_BYTE_SHIFT) |
                      ((val[index]   & 0xff) << LO_BYTE_SHIFT));
    }

    public static int length(byte[] value) {
        return value.length >> 1;
    }
}

//String类在JVM中的布局javaClass.hpp
class java_lang_String : AllStatic {
 private:
  static int _value_offset;
  static int _hash_offset;
  static int _hashIsZero_offset;
  static int _coder_offset;
  static int _flags_offset;
  
  // Coders
  enum Coder {
    CODER_LATIN1 =  0,
    CODER_UTF16  =  1
  };
  //javaClasses.inline.hpp
  void java_lang_String::set_coder(oop string, jbyte coder) {
   string->byte_field_put(_coder_offset, coder);
  }
  void java_lang_String::set_value(oop string, typeArrayOop buffer) {
   string->obj_field_put(_value_offset, buffer);
  }
  bool java_lang_String::is_latin1(oop java_string) {
    assert(is_instance(java_string), "must be java_string");
    jbyte coder = java_string->byte_field(_coder_offset);
    assert(CompactStrings || coder == CODER_UTF16, "Must be UTF16 without CompactStrings");
    return coder == CODER_LATIN1;
  }
  //jni.cpp
  JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len))
     HOTSPOT_JNI_NEWSTRING_ENTRY(env, (uint16_t *) unicodeChars, len);
      jstring ret = NULL;
      DT_RETURN_MARK(NewString, jstring, (const jstring&)ret);
      oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL);
      ret = (jstring) JNIHandles::make_local(THREAD, string);
    return ret;
  JNI_END
  //创建String，javaClasses.cpp
  Handle java_lang_String::basic_create(int length, bool is_latin1, TRAPS) {
    assert(_initialized, "Must be initialized");
    assert(CompactStrings || !is_latin1, "Must be UTF16 without CompactStrings");

    // Create the String object first, so there's a chance that the String
    // and the char array it points to end up in the same cache line.
    oop obj;
    obj = vmClasses::String_klass()->allocate_instance(CHECK_NH);

    // Create the char array.  The String object must be handlized here
    // because GC can happen as a result of the allocation attempt.
    Handle h_obj(THREAD, obj);
    int arr_length = is_latin1 ? length : length << 1; // 2 bytes per UTF16.
    typeArrayOop buffer = oopFactory::new_byteArray(arr_length, CHECK_NH);;

    // Point the String at the char array
    obj = h_obj();
    set_value(obj, buffer);
    // No need to zero the offset, allocation zero'ed the entire String object
    set_coder(obj, is_latin1 ? CODER_LATIN1 : CODER_UTF16);
    return h_obj;
 }
 oop java_lang_String::create_oop_from_unicode(const jchar* unicode, int length, TRAPS) {
    Handle h_obj = create_from_unicode(unicode, length, CHECK_NULL);
    return h_obj();
  }
 Handle java_lang_String::create_from_unicode(const jchar* unicode, int length, TRAPS) {
    bool is_latin1 = CompactStrings && UNICODE::is_latin1(unicode, length);
    Handle h_obj = basic_create(length, is_latin1, CHECK_NH);
    typeArrayOop buffer = value(h_obj());
    assert(TypeArrayKlass::cast(buffer->klass())->element_type() == T_BYTE, "only byte[]");
    if (is_latin1) {
        for (int index = 0; index < length; index++) {
        buffer->byte_at_put(index, (jbyte)unicode[index]);
      }
    } else {
    for (int index = 0; index < length; index++) {
      buffer->char_at_put(index, unicode[index]);
    }
  }
  //utf8.cpp  检查给定的字符数组（base）是否只包含Latin-1字符
  bool UNICODE::is_latin1(const jchar* base, int length) {
    for (int index = 0; index < length; index++) {
      if (base[index] > 0x00FF) { //只要有字符编码大于255，就包含非Latin1
        return false;
      }
    }
    return true;
  }