当前位置:   article > 正文

java jls8_java基础学习----String

"、string s1=\"abc\"; string s2=\"a\"; string s3=s2+\"bc\", string s4\"a\"+\"bc%, 则 s"

旨在从内存方面看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方法)

4d16daf987b51e9fde4bca35e978f2e2.png

这里主要看下运行时常量池,在jvm规范(SE8)中有如下解释:

A run-time constant poolis 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)

923dd65182b5e3048974a52d180d8db7.png(问题1 和 问题2解释)

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

常量表达式有如下几种:

A constant expressionis 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. Identifierthat 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的总结

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/不正经/article/detail/155826
推荐阅读
相关标签
  

闽ICP备14008679号