一个服务器能放多少网站,名牌网站设计的图片,亚马逊网站运营怎么做,wordpress企业主题带后台目录
String的基本特性
String的内存分配
字符串拼接操作
intern()的使用 String的基本特性 String#xff1a;字符串#xff0c;使用一对引起来表示 String声明为final的#xff0c;不可被继承 String实现了Serializable接口#xff1a;表示字符串是支持…目录
String的基本特性
String的内存分配
字符串拼接操作
intern()的使用 String的基本特性 String字符串使用一对引起来表示 String声明为final的不可被继承 String实现了Serializable接口表示字符串是支持序列化的。 String实现了Comparable接口表示string可以比较大小 String在jdk8及以前内部定义了final char[] value用于存储字符串数据。JDK9时改为byte[] String代表不可变的字符序列。简称不可变性。 当对字符串重新赋值时需要重写指定内存区域赋值不能使用原有的value进行赋值。 当对现有的字符串进行连接操作时也需要重新指定内存区域赋值不能使用原有的value进行赋值。 当调用string的replace()方法修改指定字符或字符串时也需要重新指定内存区域赋值不能使用原有的value进行赋值。 通过字面量的方式区别于new给一个字符串赋值此时的字符串值声明在字符串常量池中。
字符串常量池是不会存储相同内容的字符串的
String的String Pool是一个固定大小的Hashtable默认值大小长度是1009。如果放进String Pool的String非常多就会造成Hash冲突严重从而导致链表会很长而链表长了后直接会造成的影响就是当调用String.intern时性能会大幅下降。 使用-XX:StringTablesize可设置StringTable的长度 在jdk6中StringTable是固定的就是1009的长度所以如果常量池中的字符串过多就会导致效率下降很快。StringTablesize设置没有要求 在jdk7中StringTable的长度默认值是60013StringTablesize设置没有要求 在JDK8中设置StringTable长度的话1009是可以设置的最小值 String的内存分配
在Java语言中有8种基本数据类型和一种比较特殊的类型String。这些类型为了使它们在运行过程中速度更快、更节省内存都提供了一种常量池的概念。
常量池就类似一个Java系统级别提供的缓存。8种基本数据类型的常量池都是系统协调的String类型的常量池比较特殊。它的主要使用方法有两种。 直接使用双引号声明出来的String对象会直接存储在常量池中。 如果不是用双引号声明的String对象可以使用String提供的intern()方法。这个后面重点谈
Java 6及以前字符串常量池存放在永久代
Java 7中 Oracle的工程师对字符串池的逻辑做了很大的改变即将字符串常量池的位置调整到Java堆内 所有的字符串都保存在堆Heap中和其他普通对象一样这样可以让你在进行调优应用时仅需要调整堆大小就可以了。 字符串常量池概念原本使用得比较多但是这个改动使得我们有足够的理由让我们重新考虑在Java 7中使用String.intern()。
Java8及以后字符串常量池在堆中。
Java语言规范里要求完全相同的字符串字面量应该包含同样的Unicode字符序列包含同一份码点序列的常量并且必须是指向同一个String类实例。
class Memory {public static void main(String[] args) {int i 1;Object obj new Object();Memory mem new Memory();mem.foo(obj);}private void foo(Object param) {String str param.toString();System.out.println(str);}
} 字符串拼接操作 常量与常量的拼接结果在常量池原理是编译期优化 常量池中不会存在相同内容的变量 只要其中有一个是变量结果就在堆中。变量拼接的原理是StringBuilder 如果拼接的结果调用intern()方法则主动将常量池中还没有的字符串对象放入池中并返回此对象地址
举例1: public static void test1() {// 都是常量前端编译期会进行代码优化// 通过idea直接看对应的反编译的class文件会显示 String s1 abc; 说明做了代码优化String s1 a b c; String s2 abc; // true由上述可知s1和s2实际上指向字符串常量池中的同一个值System.out.println(s1 s2); }
举例2
public static void test5() {String s1 javaEE;String s2 hadoop;
String s3 javaEEhadoop;String s4 javaEE hadoop; String s5 s1 hadoop;String s6 javaEE s2;String s7 s1 s2;
System.out.println(s3 s4); // true 编译期优化System.out.println(s3 s5); // false s1是变量不能编译期优化System.out.println(s3 s6); // false s2是变量不能编译期优化System.out.println(s3 s7); // false s1、s2都是变量System.out.println(s5 s6); // false s5、s6 不同的对象实例System.out.println(s5 s7); // false s5、s7 不同的对象实例System.out.println(s6 s7); // false s6、s7 不同的对象实例
String s8 s6.intern();System.out.println(s3 s8); // true intern之后s8和s3一样指向字符串常量池中的javaEEhadoop
}
举例3
public void test6(){String s0 beijing;String s1 bei;String s2 jing;String s3 s1 s2;System.out.println(s0 s3); // false s3指向对象实例s0指向字符串常量池中的beijingString s7 shanxi;final String s4 shan;final String s5 xi;String s6 s4 s5;System.out.println(s6 s7); // true s4和s5是final修饰的编译期就能确定s6的值了
} 不使用final修饰即为变量。如s3行的s1和s2会通过new StringBuilder进行拼接 使用final修饰即为常量。会在编译器进行代码优化。
举例4
public void test3(){String s1 a;String s2 b;String s3 ab;String s4 s1 s2;System.out.println(s3s4);//false
}
我们拿例4的字节码进行查看可以发现s1 s2实际上是new了一个StringBuilder对象并使用了append方法将s1和s2添加进来最后调用了toString方法赋给s4
0 ldc #2 a2 astore_13 ldc #3 b5 astore_26 ldc #4 ab8 astore_39 new #5 java/lang/StringBuilder
12 dup
13 invokespecial #6 java/lang/StringBuilder.init
16 aload_1
17 invokevirtual #7 java/lang/StringBuilder.append
20 aload_2
21 invokevirtual #7 java/lang/StringBuilder.append
24 invokevirtual #8 java/lang/StringBuilder.toString
27 astore 4
29 getstatic #9 java/lang/System.out
32 aload_3
33 aload 4
35 if_acmpne 42 (7)
38 iconst_1
39 goto 43 (4)
42 iconst_0
43 invokevirtual #10 java/io/PrintStream.println
46 return 字符串拼接效率对比
public class Test
{public static void main(String[] args) {int times 50000;
// Stringlong start System.currentTimeMillis();testString(times);long end System.currentTimeMillis();System.out.println(String: (end-start) ms);
// StringBuilderstart System.currentTimeMillis();testStringBuilder(times);end System.currentTimeMillis();System.out.println(StringBuilder: (end-start) ms);
// StringBufferstart System.currentTimeMillis();testStringBuffer(times);end System.currentTimeMillis();System.out.println(StringBuffer: (end-start) ms);}
public static void testString(int times) {String str ;for (int i 0; i times; i) {str test;}}
public static void testStringBuilder(int times) {StringBuilder sb new StringBuilder();for (int i 0; i times; i) {sb.append(test);}}
public static void testStringBuffer(int times) {StringBuffer sb new StringBuffer();for (int i 0; i times; i) {sb.append(test);}}
}
// 结果
String: 7963ms
StringBuilder: 1ms
StringBuffer: 4ms
本实验进行5万次循环String拼接方式的时间是StringBuilder.append方式的约8000倍StringBuffer.append()方式的时间是StringBuilder.append()方式的约4倍
可以看到通过StringBuilder的append方式的速度要比直接对String使用“”拼接的方式快的不是一点半点
那么在实际开发中对于需要多次或大量拼接的操作在不考虑线程安全问题时我们就应该尽可能使用StringBuilder进行append操作
StringBuilder空参构造器的初始化大小为16。那么如果提前知道需要拼接String的个数就应该直接使用带参构造器指定capacity以减少扩容的次数扩容的逻辑可以自行查看源代码
/*** Constructs a string builder with no characters in it and an* initial capacity of 16 characters.*/
public StringBuilder() {super(16);
}
/*** Constructs a string builder with no characters in it and an* initial capacity specified by the {code capacity} argument.** param capacity the initial capacity.* throws NegativeArraySizeException if the {code capacity}* argument is less than {code 0}.*/
public StringBuilder(int capacity) {super(capacity);
} new String(“ab”)会创建几个对象
2个
一个对象是new关键字在堆空间创建的
另一个对象是字符串常量池中的对象ab new String(“a”) new String(“b”)创建几个对象呢
5个在常量池中是没有ab存在的
对象1new StringBuilder()
对象2 new String(“a”)在堆中
对象3 常量池中的a
对象4 new String(“b”)在堆中
对象5 常量池中的b intern()的使用
当调用intern方法时如果池子里已经包含了一个与这个String对象相等的字符串正如equals(Object)方法所确定的那么池子里的字符串会被返回。否则这个String对象被添加到池中并返回这个String对象的引用。
由此可见对于任何两个字符串s和t当且仅当s.equals(t)为真时s.intern() t.intern()为真。
s.intern()返回一个与此字符串内容相同的字符串但保证是来自一个唯一的字符串池。
intern是一个native方法调用的是底层C的方法
public native String intern();
如果不是用双引号声明的String对象可以使用String提供的intern方法它会从字符串常量池中查询当前字符串是否存在若不存在就会将当前字符串放入常量池中。
String myInfo new string(I love Java).intern();
也就是说如果在任意字符串上调用String.intern方法那么其返回结果所指向的那个类实例必须和直接以常量形式出现的字符串实例完全相同。因此下列表达式的值必定是true
(abc).intern() abc
通俗点讲Interned string就是确保字符串在内存里只有一份拷贝这样可以节约内存空间加快字符串操作任务的执行速度。注意这个值会被存放在字符串内部池String Intern Pool String的intern()的使用
JDK1.6中将这个字符串对象尝试放入字符串常量池。 如果字符串常量池中有则并不会放入。返回已有的字符串常量池中的对象的地址 如果没有会把此对象复制一份就是将字符串字面量复制一份放入字符串常量池并返回字符串常量池中的对象地址
JDK1.7起将这个字符串对象尝试放入字符串常量池。 如果字符串常量池中有则并不会放入。返回已有的字符串常量池中的对象的地址 如果没有则会把对象在堆中的引用地址复制一份放入字符串常量池并返回字符串常量池中的引用地址它不会创建一个对象如果堆中已经有这个字符串那么会将堆中的引用地址赋给它
/*** ① String s new String(1)* 创建了两个对象* 堆空间中一个new对象* 字符串常量池中一个字符串常量1注意此时字符串常量池中已有1* ② s.intern()由于字符串常量池中已存在1* s 指向的是堆空间中的对象地址* s2 指向的是堆空间中常量池中1的地址* 所以不相等*/
String s new String(1);
s.intern();
String s2 1;
System.out.println(ss2); // jdk1.6 false jdk7/8 false/** ① String s3 new String(1) new String(1)* 等价于new String11但是常量池中并不生成字符串11** ② s3.intern()* 由于此时常量池中并无11所以把s3中记录的对象的地址存入常量池* 所以s3 和 s4 指向的都是一个地址
*/
String s3 new String(1) new String(1);
s3.intern();
String s4 11;
System.out.println(s3s4); //jdk1.6 false jdk7/8 true 举例1 举例2
