String源码:基于jdk1.8
public final class String implements Serializable, Comparable<String>, CharSequence { /** The value is used for character storage. */ private final char[] value; /** Cache the hash code for the string */ private int hash; public String() { this.value = "".value; } public String(String var1) { this.value = var1.value; this.hash = var1.hash; } public String(char[] var1) { this.value = Arrays.copyOf(var1, var1.length); } public String(byte bytes[], int offset, int length) { checkBounds(bytes, offset, length); this.value = StringCoding.decode(bytes, offset, length); } }
主要参数:
1、char[] value,用来存储数据的char类型数组
2、int hash,字符串的hash
结论:
1、String是final修饰的,证明是不可变的
2、实现了Comparable接口,可以通过CompareTo()进行比较,实现里Serializable接口,可以在网络中传输
3、通过数组保存数据
常用方法:
//获取String中第index个字符,首位为0 public char charAt(int index) { if ((index < 0) || (index >= value.length)) { throw new StringIndexOutOfBoundsException(index); } return value[index]; } //当前字符串和另一个字符串比较,比较同每个位置字符的大小,'A':65,'Z':90,'a':97,'z':122 public int compareTo(String anotherString) { int len1 = value.length; int len2 = anotherString.value.length; int lim = Math.min(len1, len2); char v1[] = value; char v2[] = anotherString.value; int k = 0; while (k < lim) { char c1 = v1[k]; char c2 = v2[k]; if (c1 != c2) { return c1 - c2; } k++; } return len1 - len2; } //拼接字符串 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); } //是否包含某个字符串 public boolean contains(CharSequence s) { return indexOf(s.toString()) > -1; } //根据数组生成一个字符串 public static String copyValueOf(char data[]) { return new String(data); } //是否以某个字符串结尾 public boolean endsWith(String suffix) { return startsWith(suffix, value.length - suffix.value.length); } //比较两个字符串是否相等 public boolean equals(Object anObject) { if (this == anObject) { //首先通过==比较,==比较的是对象,如果相等,返回true return true; } if (anObject instanceof String) { //判断是否是String类型的实例,如果不是,返回false String anotherString = (String)anObject; //强转成String 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; } //返回该字符串的hash值 //空字符串返回0,否则计算公式如下:s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] 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; } //判断是否包含字符串,和contains相同,包含返回0,否则-1 public int indexOf(int ch) { return indexOf(ch, 0); } //本地方法 public native String intern(); //判断是否为空," "并不是空字符串 public boolean isEmpty() { return value.length == 0; } //匹配正则表达式 public boolean matches(String regex) { return Pattern.matches(regex, this); } //将字符串中某个字符替换为另一个字符 public String replace(char oldChar, char newChar) { if (oldChar != newChar) { //判断两个字符是否相同 int len = value.length; int i = -1; char[] val = value; /* avoid getfield opcode */ while (++i < len) { //判断是否包含这个字符 if (val[i] == oldChar) { break; } } if (i < len) { //包含该字符,生成一个新的char[],并把原字符之前的值复制进去 char buf[] = new char[len]; for (int j = 0; j < i; j++) { buf[j] = val[j]; } while (i < len) { //把新的字符及后面的字符放到数组中 char c = val[i]; buf[i] = (c == oldChar) ? newChar : c; i++; } return new String(buf, true); //生成一个新的String } } return this; } //截取字符串,首位为0 public String substring(int beginIndex) { if (beginIndex < 0) { throw new StringIndexOutOfBoundsException(beginIndex); } int subLen = value.length - beginIndex; if (subLen < 0) { throw new StringIndexOutOfBoundsException(subLen); } return (beginIndex == 0) ? this : new String(value, beginIndex, subLen); } //字符串中字符转小写 public String toLowerCase() { return toLowerCase(Locale.getDefault()); } //字符串中字符转大写 public String toUpperCase() { return toUpperCase(Locale.getDefault()); } //剔除字符串两端的空格字符 public String trim() { int len = value.length; int st = 0; char[] val = value; /* avoid getfield opcode */ while ((st < len) && (val[st] <= ' ')) { //从左到右找到第一个空格字符后面一个下标 st++; } while ((st < len) && (val[len - 1] <= ' ')) { //从右到左找到第一个空格字符前面一个下标 len--; } return ((st > 0) || (len < value.length)) ? substring(st, len) : this;//截取这两个下标的字符串 } //生成一个字符串 public static String valueOf(char c) { char data[] = {c}; return new String(data, true); }
结论:所有改变字符串的操作都是重新生成一个新的字符串,包括+,+=
深入理解:
public static void main(String[] args) { String str1 = "abc"; String str2 = new String("abc"); String str3 = "abc"; String str4 = new String("abc"); System.out.println(str1==str2); System.out.println(str1==str3); System.out.println(str2==str4); }
结果:
false true false
我们首先讲一下class常量池和字符串常量池的概念,之前在jvm已经讲过了,这里再简单讲一下
class常量池(Class Constant Pool):
我们写的每一个Java类被编译后,就会形成一份class文件,class文件中除了包含类的版本、字段、方法、接口等描述信息外,还有一项信
息就是常量池(constant pool table),用于存放编译器生成的各种字面量(Literal)和符号引用(Symbolic References);
字面量包括:
1.String 2.八种基本类型的值 3.被声明为final的常量等;
符号引用包括:
1.类和方法的全限定名 2.字段的名称和描述符 3.方法的名称和描述符。
字符串常量池(String Constant Pool):
在HotSpot VM里实现的string pool功能的是一个StringTable类,被所有的类共享。字符串常量由一个一个字符组成,放在了StringTable上。
Class常量池里面的字符串在类加载过程放到字符串常量池
在JDK1.7版本,字符串常量池从方法区移到了堆中了。
解释:
String str1 = "abc";和String str3 = "abc; 都在编译期间生成了字面量,保存在字符串常量池中。jvm每次先到常量池中查找是否存在这个
字符串,如果存在str3直接指向这个字符串
而通过new生成的是对象,保存在堆中。每次new都会生成一个对象,所以是不相等的
String、StringBuffer、StringBuilder
public static void main(String[] args) { String s = "aaa" ; s += "bbb"; System.out.println(s); }
反编译查看字节码
public class com.it.Test { public com.it.Test(); Code: 0: aload_0 1: invokespecial #1 // Method java/lang/Object."<init>":()V 4: return public static void main(java.lang.String[]); Code: 0: ldc #2 // String aaa 2: astore_1 3: new #3 // class java/lang/StringBuilder 6: dup 7: invokespecial #4 // Method java/lang/StringBuilder."<init>":()V 10: aload_1 11: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder; 14: ldc #6 // String bbb 16: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder; 19: invokevirtual #7 // Method java/lang/StringBuilder.toString:()Ljava/lang/String; 22: astore_1 23: getstatic #8 // Field java/lang/System.out:Ljava/io/PrintStream; 26: aload_1 27: invokevirtual #9 // Method java/io/PrintStream.println:(Ljava/lang/String;)V 30: return }
第三行能看到遇到+的时候,会new一个StringBuilder,然后append这个字符串,然后调用toString(),如果多次用+=,就会生成很多
StringBuilder对象,就会浪费内存
如果是这样使用+,就没问题
public static void main(String[] args) { String s = "aaa" + "bbb" + "ccc"; }
在编译期间直接生成一个字符串"aaabbbccc",是因为"aaa","bbb","ccc",都是编译器可知的常量,当然一般也不会这样用的
public static void main(String[] args) { String s1 = "bbb" ; String s = "aaa" + s1 + "ccc"; }
如果这样使用,也是不行的
String本身contact()效率也不高,每次生成一个新的char[],然后通过数组new一个String,所以需要拼接字符串的时候,可以使用StringBuilder
public static void main(String[] args) { StringBuilder builder = new StringBuilder("aaa"); builder.append("bbb"); }
public static void main(java.lang.String[]); Code: 0: new #2 // class java/lang/StringBuilder 3: dup 4: ldc #3 // String aaa 6: invokespecial #4 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V 9: astore_1 10: aload_1 11: ldc #5 // String bbb 13: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder; 16: pop 17: return }
而StringBuffer和StringBuilder都继承了AbstractStringBuilder,也是通过char[]进行保存数据,所以效率会好很多
StringBuilder和StringBuffer区别就是是否保证线程安全,StringBuffer通过synchronized保证线程安全
性能比较:
"aaa"+"ccc"这样直接字符串叠加,性能肯定是最好的
而其余情况下:StringBuilder>StringBuffer>String
所以字符串改动较少使用String,否则使用StringBuilder,多线程环境下使用StringBuffer
PS;这里说下,我们使用Hibernate/JPA的时候,需要在Dao层拼接SQL,没必要用StringBuffer好吗,不要老是想着并发的问题。一般的Dao都是无状态的bean,不存在
线程安全问题。而且方法的执行在栈中进行的,栈是线程私有,没有特殊情况,还是要使用StringBuilder。
面试题:来自下面的链接
public static void main(String[] args) { String s1 = "aaa2"; final String s2 = "aaa"; String s3 = "aaa"; String s4 = "aaa" + 2; String s5 = s3 + 2; String s6 = s2 + 2; System.out.println(s1 == s4); System.out.println(s1 == s5); System.out.println(s1 == s6); final String s7 = getHello(); String s8 = s6 + 2; System.out.println(s1 == s8); } public static String getHello() { return "hello"; }
结果:
true false true false
s1==s4为true:
"hello"+2在编译期间就已经被优化成"hello2",因此在运行期间,变量a和变量b指向的是同一个对象
s1==s5为false:
由于有符号引用的存在,所以 String c = b + 2;不会在编译期间被优化,不会把b+2当做字面常量来处理的,因此这种方式生
成的对象事实上是保存在堆上的。因此a和c指向的并不是同一个对象。javap -c得到的内容
s1==s6为true:
对于被final修饰的变量,会在class文件常量池中保存一个副本,也就是说不会通过连接而进行访问,对final变量的访问在编译
期间都会直接被替代为真实的值。那么String c = b + 2;在编译期间就会被优化成:String c = "hello" + 2;
s1==s8为false:
这里面虽然将b用final修饰了,但是由于其赋值是通过方法调用返回的,那么它的值只能在运行期间确定,因此a和c指向的不是同一个对象。
再来一个栗子:
public static void main(String[] args) { String a = "hello"; String b = new String("hello"); String d = b.intern(); System.out.println(b==d); System.out.println(a==d); }
结果:
false true
解释:
这里面涉及到的是String.intern方法的使用。在String类中,intern方法是一个本地方法,在JAVA7之前,intern方法会在运行时常量池
中查找是否存在内容相同的字符串,如果存在则返回指向该字符串的引用,如果不存在,则会将该字符串入池,并返回一个指向该字符串的引用。
因此,a和d指向的是同一个对象。
String str = new String("abc")创建了多少个对象?
反编译:
public static void main(java.lang.String[]); Code: 0: new #2 // class java/lang/String 3: dup 4: ldc #3 // String abc 6: invokespecial #4 // Method java/lang/String."<init>":(Ljava/lang/String;)V 9: astore_1 10: return }
结果是只创建一个对象
而这道题目让人混淆的地方就是这里,这段代码在运行期间确实只创建了一个对象,即在堆上创建了"abc"对象。
而为什么大家都在说是2个对象呢,这里面要澄清一个概念,该段代码执行过程和类的加载过程是有区别的。在类加载的过程中,确实在运行时
常量池中创建了一个"abc"对象,而在代码执行过程中确实只创建了一个String对象。
因此,这个问题如果换成 String str = new String("abc")涉及到几个String对象?合理的解释是2个。
个人觉得在面试的时候如果遇到这个问题,可以向面试官询问清楚”是这段代码执行过程中创建了多少个对象还是涉及到多少个对象“再根
据具体的来进行回答。
内容参考:https://www.cnblogs.com/dolphin0520/p/3778589.html和Java编程思想