String是Java基本的重要考点。可问的点多，并且许多点可以横向切到其他考点，或纵向深入JVM。

本文略过了String的根基内容，重点在于String#intern()。

String常量池

String常量大概会在两种机缘进入常量池：

1. 编译期：通过双引号声明的常量（包罗显示声明、静态编译优化后的常量，如”1”+”2”优化为常量”12”），在前端编译期将被静态的写入class文件中的“常量池”。该“常量池”会在类加载后被载入“内存中的常量池”，劳务派遣管理系统，也就是我们平时所说的常量池。同时，JIT优化也大概发生雷同的常量。

机缘1的行为是明晰的。道理可阅读class文件布局、类加载、编译期即运行期优化等内容。

机缘2在jdk6和jdk7中的行为差异，下面接头。

String#intern()

读者可直接阅读参考资料。下述总结仅为了猴子本身温习利便。

声明

/** 
 * Returns a canonical representation for the string object. 
 * <p> 
 * A pool of strings, initially empty, is maintained privately by the 
 * class <code>String</code>. 
 * <p> 
 * When the intern method is invoked, if the pool already contains a 
 * string equal to this <code>String</code> object as determined by 
 * the {@link #equals(Object)} method, then the string from the pool is 
 * returned. Otherwise, this <code>String</code> object is added to the 
 * pool and a reference to this <code>String</code> object is returned. 
 * <p> 
 * It follows that for any two strings <code>s</code> and <code>t</code>, 
 * <code>s.intern() == t.intern()</code> is <code>true</code> 
 * if and only if <code>s.equals(t)</code> is <code>true</code>. 
 * <p> 
 * All literal strings and string-valued constant expressions are 
 * interned. String literals are defined in section 3.10.5 of the 
 * <cite>The Java™ Language Specification</cite>. 
 * 
 * @return  a string that has the same contents as this string, but is 
 *          guaranteed to be from a pool of unique strings. 
 */  
public native String intern();

String#intern()是一个native要领。按照Javadoc，假如常量池中存在当前字符串, 就会直接返回当前字符串. 假如常量池中没有此字符串, 会将此字符串放入常量池中后, 再返回。

实现道理

JNI最后挪用了c++实现的StringTable::intern()要领：

oop StringTable::intern(Handle string_or_null, jchar* name,  
                        int len, TRAPS) {  
  unsigned int hashValue = java_lang_String::hash_string(name, len);  
  int index = the_table()->hash_to_index(hashValue);  
  oop string = the_table()->lookup(index, name, len, hashValue);  
  // Found  
  if (string != NULL) return string;  
  // Otherwise, add to symbol to table  
  return the_table()->basic_add(index, string_or_null, name, len,  
                                hashValue, CHECK_NULL);  
}
oop StringTable::lookup(int index, jchar* name,  
                        int len, unsigned int hash) {  
  for (HashtableEntry<oop>* l = bucket(index); l != NULL; l = l->next()) {  
    if (l->hash() == hash) {  
      if (java_lang_String::equals(l->literal(), name, len)) {  
        return l->literal();  
      }  
    }  
  }  
  return NULL;  
}

在the_table()返回的hash表中查找字符串，昆山软件开发，假如存在就返回，不然插手表。

StringTable是一个牢靠巨细的Hashtable，默认巨细是1009。根基逻辑与Java中HashMap沟通，也利用拉链法办理碰撞问题。

既然是拉链法，那么假如放进的String很是多，就会加剧碰撞，导致链表很是长。最坏环境下，String#intern()的机能由O(1)退化到O(n)。

jdk6中StringTable的长度牢靠为1009。

jdk7中，StringTable的长度可以通过一个参数-XX:StringTableSize指定，默认1009。

jdk6和jdk7下String#intern()的区别

引言

相信许多Java措施员都做雷同String s = new String("abc");这个语句建设了几个工具的题目。这种题目主要是为了考查措施员对字符串工具常量池的把握。上述的语句中建设了2个工具：

问题

来看一段代码：

public static void main(String[] args) {
    String s = new String("1");
    s.intern();
    String s2 = "1";
    System.out.println(s == s2);
    String s3 = new String("1") + new String("1");
    s3.intern();
    String s4 = "11";
    System.out.println(s3 == s4);
}

打印功效：

# jdk6下
false false
# jdk7下
false true