String 的底层是final char[]数组实现的 ,因此String中的绝大多数方法,具体的实现都和char有着密切的关系,包括常用的length(),isEmpty(),charAt(),
1.string之 equals 方法,==。
源码,先比较==,然后确定是不是string类型, 比较字符串长度, 然后比较内容,(string内部其实就是char[])
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
2.string的唯一一个静态内部类,
首先,代码复用,compareToIgnoreCase这个方法就是通过这个内部类实现的。
其次,源码定义了一个CASE_INSENSITIVE_ORDER变量,来使用这个类。
private static class CaseInsensitiveComparator
implements Comparator<String>, java.io.Serializable {
// use serialVersionUID from JDK 1.2.2 for interoperability
private static final long serialVersionUID = 8575799808933029326L;
public int compare(String s1, String s2) {
int n1 = s1.length();
int n2 = s2.length();
int min = Math.min(n1, n2);
for (int i = 0; i < min; i++) {
char c1 = s1.charAt(i);
char c2 = s2.charAt(i);
if (c1 != c2) {
c1 = Character.toUpperCase(c1);
c2 = Character.toUpperCase(c2);
if (c1 != c2) {
c1 = Character.toLowerCase(c1);
c2 = Character.toLowerCase(c2);
if (c1 != c2) {
// No overflow because of numeric promotion
return c1 - c2;
}
}
}
}
return n1 - n2;
}
/** Replaces the de-serialized object. */
private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
}
3,string 骚操作。
3.1string的另一特点就是final,不变的不被继承的,所以一些substr ,replac,contact 这些骚操作都是用在新生成,都是new string 。
3.2 字符串常量。
String a="abc";先查下常量池中是否已经有了"abc"了,如果没有就在常量池中创建一个。
String b="abc";先查下常量池中是否已经有了"abc"了,已经有了,那么b就指向常量池中“abc”这个地址。
所以a==b 是true的
String c =new String("abc"),当new一个对象的时候,也是先检测常量池中有没有“abc”,发现已经存在了,然后在接着去堆中进行创建这个对象,所以c指向的是堆中的“abc”地址;
所以c==a是false。
3.3 string +操作
String b="好好学习";
String c="天天向上";
String a1=“我要”+b+c; 是在堆中新创建一个对象;生成过程是 String a= StringBuilder("我要").append(“好好学习”)
.append(“天天向上”),toString();
String a2="我要好好学习"+"天天向上"; 编译期间运行的,被看做 “好好学习天天向上”;a1==a2 是false;
3.3 string stringbuffer
(1)可变与不可变:String是不可变字符串对象,StringBuilder和StringBuffer是可变字符串对象(其内部的字符数组长度可变)。
(2)是否多线程安全:String中的对象是不可变的,也就可以理解为常量,显然线程安全。StringBuffer 与 StringBuilder 中的方法和功能完全是等价的,只是StringBuffer 中的方法大都采用了synchronized 关键字进行修饰,因此是线程安全的,而 StringBuilder 没有这个修饰,可以被认为是非线程安全的。
final StringBuffer a = new StringBuffer("111"); final StringBuffer b = new StringBuffer("222"); a=b;//此句编译不通过 final StringBuffer a = new StringBuffer("111"); a.append("222");//编译通过
可见,final只对引用的"值"(即内存地址)有效,它迫使引用只能指向初始指向的那个对象,改变它的指向会导致编译期错误。至于它所指向的对象的变化,final是不负责的。