java基础学习----String

旨在从内存方面看String类的知识点：

1、为何不能被继承（final类）

2、字符拼接时，String类的内存分配问题。

3、String的intern()方法

关于String类经常出现的面试题：

问题1:

String s1 = “abc”;
String s2 = “abc”;
System.out.println(s1 == s2);

结果：true

问题2:

String s1 = new String(“abc”);
String s2 = new String(“abc”);
System.out.println(s1 == s2);

结果：false

问题3:

String s1 = “abc”;
String s2 = “a”;
String s3 = “bc”;
String s4 = s2 + s3;
System.out.println(s1 == s4);

结果：false

问题4:

String s1 = “abc”;
String s2 = “a” + “bc”;
System.out.println(s1 == s2);

结果：true

问题5:

String str = “abc”;
str.substring(3);
str.concat(“123″);
System.out.println(str);

结果：abc

对于以上问题的解答，需要综合jvm内存分配及规范、String的源代码

一、java虚拟机运行时数据区域：

1、程序计数器

2、java虚拟机栈

3、堆

4、方法区（the method area is logically part of the heap）

5、运行时常量池（Each run-time constant pool is allocated from the Java Virtual Machine's method area）

6、本地方法栈（类似于java虚拟机栈，主要运行native方法）





这里主要看下运行时常量池，在jvm规范（SE8）中有如下解释：

A run-time constant pool is a per-class or per-interface run-time representation of the constant_pool table in a class file (§4.4).

It contains several kinds of constants, ranging from numeric literals known at compile-time to method and field references that must be resolved at run-time.

可以看出它常量池（constant_pool table）主要用于存储编译期产生的常量和符号引用，并且在类加载时后存放到方法区的运行时常量池中（run-time constant pool）



(问题1 和 问题2解释)

对于常量表达式，在编译器的优化下，总是在编译时已计算完毕，类加载后放在运行时常量池。（比如说 “a”+ “bc”在编译后，与“abc”是同一个，加载后在运行时常量池中）（问题4在此解答）

常量表达式有如下几种：

A constant expression is an expression denoting a value of primitive type or a String that does not complete abruptly and is composed using only the following:

• Literals of primitive type and literals of type String //常量

• Casts to primitive types and casts to type String //转换类型

• The unary operators +, -, ~, and ! (but not ++ or –) //单目运算符

• The multiplicative operators *, /, and % //相关运算符

• The additive operators + and -

• The shift operators <<, >>, and >>>

• The relational operators <, <=, >, and >= (but not instanceof)

• The equality operators == and != (§15.21)
• The bitwise and logical operators &, ^, and |

• The conditional-and operator && and the conditional-or operator ||

• The ternary conditional operator ? :

• Parenthesized expressions whose contained expression is a constant expression.

• Simple names that refer to constant variables

• Qualified names of the form TypeName . Identifier that refer to constant variables

问题3为两个实例对象相加，会再产生一个堆区的实例对象，然后reference s4指向这个新产生的实例对象，所以会返回false;

问题5，查看下String源码对两个方法实现

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

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

从两个方法的实现上，可以看到，他们从String对象的value属性上获取信息，并未对value进行改动，String对象调用substring方法，就相当于从自己的value上复制一小部分内容，同理，concat方法，相当String对象复制一份一样的value给别人，并在复制的部分追加字符串，将结果返回。上述两个方法都是从String对象上查询信息，而不是改动信息。所以问题5的答案是false

特别指出：

String类有一个本地方法叫intern()-----Constant expressions of type String are always "interned" so as to share unique instances, using the method String.intern.

例如：

public class TestFinal{
public static void main(String[] args) {
String a = "abc";
String b = "ab";
String c = "c";
String d = (b+c).intern();
String e = (b+"c").intern();
System.out.println(a == c);
System.out.println(a == d);
System.out.println(a == e);
}
}

另外面试中常被问到，String类能不能被继承，通过查询String类的源码发现，它是final类的，是不能被继承的

引用如下文章：

《深入理解Java虚拟机++JVM高级特性与最佳实践.pdf》

oracle下载的官方文档：《jls8》《jvms8》

部分引用网上面试关于String的总结