String.intern(),String.subString()

本文深入探讨了Java中String对象的内部实现机制,包括String.intern()方法的工作原理、String池的概念及其工作方式、String.subString()方法的行为以及字符串拼接的效率分析。

转载以供学习:http://www.cnblogs.com/dolphin0520/p/3778589.html

String.intern()

JDK中对String.intern()方法的解释如下:

public String intern()
返回字符串对象的规范化表示形式。
一个初始为空的字符串池,它由类 String 私有地维护。
当调用 intern 方法时,如果池已经包含一个等于此 String 对象的字符串(用 equals(Object) 方法确定),则返回池中的字符串。否则,将此 String 对象添加到池中,并返回此 String 对象的引用。
它遵循以下规则:对于任意两个字符串 s 和 t,当且仅当 s.equals(t) 为 true 时,s.intern() == t.intern() 才为 true。
所有字面值字符串和字符串赋值常量表达式都使用 intern 方法进行操作。字符串字面值在 Java Language Specification 的 §3.10.5 定义。
返回:
一个字符串,内容与此字符串相同,但一定取自具有唯一字符串的池。


String是特殊的封装类型,使用String时可以直接赋值,也可以用new来创建对象,但是这二者的实现机制是不同的。
String池:Java运行时在运行时常量池中维护一个String池,池中的String对象不可重复。String池不属于堆和栈,而是属于常量池。
String s1 = "abc";   
String s2 = "abc";
System.out.println(s1 == s2);//true
对于这两个语句,JVM做了什么操作呢?运行第一个语句时,相当于调用"abc".intern()方法,然后将方法返回的引用赋值给s1,第二条语句与第一条语句的过程一样,所以打印结果是true。

下面再列一下实例:
String str1 = "a";    //常量池中对象
String str2 = "bc";    //常量池中对象
String str3 = "a"+"bc";    //常量池中对象
String str4 = str1+str2;    //new String(value, 0, count),堆中对象,因为str1,str2是String。字面值与变量进行+,则值是一个堆中对象
     
System.out.println(str3==str4); //false   
str4 = (str1+str2).intern();//常量池中对象    

System.out.println(str3==str4); //true


String.subString()

String a = new String("asdffsafds");String b = a.substring(2,4);
在String类中,此方法有两个版本,此方法的返回值是一个全新的字符串,但对象内部引用的字符数组却是一样的,两个对象的不同是在字符数组中的起始位置和长度不同。如果想要得到一个与原对象引用字符数组不相同的字串,可以采用String c = new String(b)方法。这样,c与b引用的字符数组就不相同,a与b引用的字符数组相同,就可以释放对原字符数组的引用,便于GC。

字符串常量池

JAVA字符串常理池增加有两种情况:第一种情况发生在JAVA文件被编译器编译时。JAVA编译器会将常量字符串放到常量池中,编译完成后,所有文件中的相同字符串最终都指向同一个位于常量池中的对象,“a”+"b","a"都是常量字符串;第二种情况是在运行时调用字符串对象的intern()方法。

字符串拼接

JAVA6后,编译器会将字符串的+操作(只要+操作中有字符串变量出现,全是字符串常量的情况除外)转换成stringbuilder.append操作。
String s = "";
String a="a";
String b="b";
String c="c";
s+=a;
s+=b;
s+=c;
这段代码会生成三个StringBuilder对象,执行三次sb.append,sb.tostring操作
s=a+b+c;
这段代码会生成一个StringBuilder对象,执行三次append和一次tostring。
所以,如果要拼接的字符串已经全得到的情况下,显式用+进行拼接更直观,如果最张字符串要多次拼接的话,显式用stringbuilder.append操作性能更好。

String(String original)

new String(String orininal)此构造函数生成的新对象内部引用的字符数组有两种情况,判断依据是源字符串内的字符数组的长度,如果源字符串的长度等于内部字符数组的长度,那么新字符串对象与源字符串是两个对象但引用同一个字符数组,如果源字符数组的长度大于源字符串的长度,那么新字符串会引用一个新的字符数组。
<think>我们正在分析java.lang.String类的源码。根据引用[1]和[5],我们知道String类有多个构造方法,并且String是不可变的。 引用[5]详细解释了String不可变的原因:安全、线程安全、HashCode缓存以及性能(字符串常量池)。 引用[2]展示了一个String对象创建的字节码,其中使用了ldc指令从常量池加载字符串,然后调用String的构造方法。 引用[3]和[4]则提醒我们在类型转换时可能出现的ClassCastException,但这不是我们当前关注的重点。 因此,我们将从以下几个方面解析String类的源码: 1. String的不可变性(由final修饰的char数组实现) 2. 重要字段(value, hash等) 3. 构造方法(重点分析几个典型的) 4. 常用方法(substring, concat, replace等)的实现 5. 字符串常量池(intern方法) 注意:由于Java版本不同,String的实现可能有差异(例如,Java9开始使用byte数组代替char数组以节省空间),但基本思想一致。这里我们以Java8为例。 开始解析:</think>### Java `java.lang.String` 源码解析及内部实现机制 `String` 类是 Java 最核心的不可变字符序列,其设计直接影响 JVM 性能和安全。以下是关键实现机制分析: --- #### 一、底层存储结构(不可变性的基石) ```java // JDK 8 及之前版本(char 数组存储) private final char value[]; // JDK 9+(压缩存储优化) private final byte[] value; private final byte coder; // 0-LATIN1, 1-UTF16 ``` 1. **`final` 修饰**:数组引用不可变,但早期版本可通过反射修改数组内容(需 `setAccessible(true)`)[^5] 2. **JDK 9 压缩优化**: - 纯 ASCII 字符串用 `LATIN1`(1 字节/字符)存储 - 含非 ASCII 字符时自动切为 `UTF16`(2 字节/字符) - 节省 30%~50% 堆内存(实测 `"Hello"` 从 48 字节 → 24 字节)[^5] --- #### 二、构造方法解析(引用[1]) | 构造方法签名 | 作用 | 典型场景 | |--------------|------|----------| | `String()` | 创建空字符串 (`""`) | 默认初始化 | | `String(String original)` | 拷贝字符串 | 防御性编程 | | `String(char[] value)` | char 数组转字符串 | 动态构建字符串 | | `String(byte[] bytes, Charset charset)` | 字节数组解码 | 网络传输解码 | | `String(StringBuffer buffer)` | 同步拷贝 | 线程安全转换 | **关键实现逻辑**: ```java // String(String original) 源码 public String(String original) { this.value = original.value; // 共享底层数组 this.hash = original.hash; // 复用哈希值 } ``` > 此“拷贝”实为**浅拷贝**,新老字符串共享同一 `char[]`(因不可变性而安全)[^5] --- #### 三、不可变性(Immutability)设计 **实现原理**: 1. 所有修改操作(如 `concat()`、`replace()`)**返回新对象** 2. 内部状态无 `setter` 方法 ```java // substring() 典型实现(JDK8) public String substring(int beginIndex) { return new String(value, beginIndex, subLen); } ``` **不可变性的价值**: - **安全**:防止篡改(如数据库密码、网络主机名)[^5] - **线程安全**:无需同步锁 - **哈希缓存**:首次 `hashCode()` 计算后缓存结果(`private int hash;`) - **常量池优化**:`"A" + "B"` 编译期优化为 `"AB"`(字节码验证见引用[2]) --- #### 四、字符串常量池(String Pool) **堆内存中的特殊区域**,避免重复创建相同字面量: ```java String s1 = "Fly"; // 常量池查找/创建 String s2 = new String("Fly"); // 强制堆中新对象 System.out.println(s1 == s2); // false(引用不同) ``` **内存机制**: 1. 字面量赋值(`String s = "x"`)触发池化 2. `intern()` 方法主动入池 ```java String s3 = new String("Fly").intern(); System.out.println(s1 == s3); // true(指向同一对象) ``` --- #### 五、关键方法实现 1. **`equals()`** :先比较引用,再逐字符比对 ```java public boolean equals(Object anObject) { if (this == anObject) return true; if (anObject instanceof String) { String s = (String)anObject; int n = value.length; if (n == s.value.length) { char v1[] = value; char v2[] = s.value; for (int i = 0; i < n; i++) { if (v1[i] != v2[i]) return false; } return true; } } return false; } ``` 2. **`hashCode()`** :延迟计算并缓存 ```java public int hashCode() { int h = hash; if (h == 0 && value.length > 0) { for (char v : value) { h = 31 * h + v; // 多项式哈希减少碰撞 } hash = h; } return h; } ``` --- #### 六、类型转换陷阱(引用[3][4]) **错误示例**: ```java Object obj = 123; String s = (String) obj; // ClassCastException: Integer→String ``` **正确转换**: ```java // 安全转换路径 String s1 = String.valueOf(obj); // 调用obj.toString() String s2 = obj.toString(); // 需确保非null String s3 = "" + obj; // 编译优化为StringBuilder ``` --- ### 总结:String 设计哲学 | 特性 | 实现手段 | 价值 | |------|----------|------| | 不可变性 | `final char[]` + 无状态修改方法 | 线程安全、哈希缓存 | | 内存优化 | 常量池 + JDK9 压缩存储 | 减少堆内存占用 | | 安全性 | 禁止外部修改内部状态 | 防止敏感数据篡改 | | 性能 | 延迟哈希计算、编译期优化 | 提升运行时效率 | > 通过字节码可验证优化效果(如引用[2]中 `ldc` 指令直接加载常量池对象)[^2]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值