Java OOP中的字符串篇

字符串的三大特征：

 

• String 字符串常量
• StringBuffer 字符串变量（线程安全）
• StringBuilder 字符串变量（非线程安全）

一、定义

查看 API 会发现，String、StringBuffer、StringBuilder 都实现了 CharSequence 接口，内部都是用一个char数组实现，虽然它们都与字符串相关，但是其处理机制不同。

• String：是不可改变的量，也就是创建后就不能在修改了。
• StringBuffer：是一个可变字符串序列，它与 String 一样，在内存中保存的都是一个有序的字符串序列（char 类型的数组），不同点是 StringBuffer 对象的值都是可变的。
• StringBuilder：与 StringBuffer 类基本相同，都是可变字符换字符串序列，不同点是 StringBuffer 是线程安全的（支持多线程），StringBuilder 是线程不安全的（支持单线程）。

使用场景

使用 String 类的场景：在字符串不经常变化的场景中可以使用 String 类，例如常量的声明、少量的变量运算。

使用 StringBuffer 类的场景：在频繁进行字符串运算（如拼接、替换、删除等），并且运行在多线程环境中，则可以考虑使用 StringBuffer，例如 XML 解析、HTTP 参数解析和封装。

使用 StringBuilder 类的场景：在频繁进行字符串运算（如拼接、替换、和删除等），并且运行在单线程的环境中，则可以考虑使用 StringBuilder，如 SQL 语句的拼装、JSON 封装等。

分析

在性能方面，由于 String 类的操作是产生新的 String 对象，而 StringBuilder 和 StringBuffer 只是一个字符数组的扩容而已，所以 String 类的操作要远慢于 StringBuffer 和 StringBuilder。

简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象。所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC（垃圾回收） 就会开始工作，那速度是一定会相当慢的。

而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。

而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer 快的，例如下例：

String S1 = “This is only a" + “ simple" + “ test";
StringBuffer Sb = new StringBuilder(“This is only a").append(“ simple").append(“ test");

你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个

String S1 = “This is only a" + “ simple" + “test";

其实就是：

String S1 = “This is only a simple test";

所以当然不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，譬如：

String S2 = "This is only a";
String S3 = "simple";
String S4 = "test";
String S1 = S2 +S3 + S4;

这时候 JVM 会规规矩矩的按照原来的方式去做。因为每个变量都在内存中开辟了新的空间,最终指针指向的是字符串拼接后的那块地址。所以没有指针指向的空间就成了垃圾，GC在回收的时候就会影响性能。

 对于上述的理解我们在对于字符串的创建上再来具体延伸一下，具体内容如下。

1.创建对象

  对于java程序中的字符串直接常量，JVM 会使用一个字符串池来保存它们。当第一次使用某个字符串直接常量时，JVM会将它放入字符串池中进行缓存。在一般情况下，字符串池中的字符串对象不会被垃 圾回收。当程序再次需要使用该字符串时，无需重新创建一个新的字符串就可以直接让引用变量直接指向字符串中已有的字符串。而使用new操作创建的字符串对象不指向字符串池中的对象，但是可以使用intern()方法使其指向字符串池中的对象。

 实例1：

String s1 = "abc";     
//↑ 在字符串池创建了一个对象  
String s2 = "abc";     
//↑ 字符串pool已经存在对象“abc”(共享),所以创建0个对象，累计创建一个对象  
System.out.println("s1 == s2 : "+(s1==s2));    
//↑ true 指针指向同一个对象，  
System.out.println("s1.equals(s2) : " + (s1.equals(s2)));    
//↑ true  值相等（equals比较的是值不是指针） 

 实例2：

String s1 ="abc";
String s2 =new String("abc");
System.out.println(s1==s2);
//↑ false 没有指向同一地址. s2 new的是一块新的空间.值虽然相同但是地址不同.

 实例3：

String s1 = new String("abc");  
//↑ 创建了两个对象，一个存放在字符串池中，一个存在与堆区中；  
//↑ 还有一个对象引用s1存放在栈中  
String s2 = new String("abc");  
//↑ 字符串池中已经存在“abc”对象，所以只在堆中创建了一个对象  
System.out.println("s1 == s2 : "+(s1==s2));  
//↑false   s1和s2栈区的地址不同，指向堆区的不同地址；  
System.out.println("s1.equals(s2) : "+(s1.equals(s2)));  
//↑true  s3和s4的值相同  

 实例4：

String s1 = "abc";
String s2 = new String("abc");
		
System.out.println("s1 + s2 :" + (s1 == s2));
//↑false 存放的地区多不同，一个栈区，一个堆区  

 实例5：

String s1 = "ab" + "cd";  //1个对象  
String s2 = "abcd";   
System.out.println("s1 = s2 : "+ (s1 == s2));  
//* 在这里，"ab"和"cd"都是常量，实际上JVM在后台实现的是s1 = "abcd";因此s2的值等同于s1的值的时候,常量池不会开辟新空间,指针指向同一个地址而已.

实例6： 

String a = "ray";
String b = a.concat("long");
String c = a+b;
System.out.println("a+b == c:" + (a+b == c));

//↑false a开辟一块空间。b相当于向a中+"long"这个值而已，其本身也同样是开辟了一块空间。a+b虽然值显示相同。但是a,b都属于不同的内存地址所以不等于c.

System.out.println(b); System.out.println("b == c :" + (b ==c));

//↑false  同上b的地址属于其本身，c的地址是a+b的地址所以不相等。

 注释：.concat为字符串累加的一个方法，其用法同“+”的效果相同，性能上没有任何区别。

2. String 类中== 于 equlas的区别

==比较的是堆中字符串所指向的内存地址，而equlas是用来比较堆中字符串的值。

package com.java.demo_6;

public class StrTest2 {
	public static void main(String[] args) {
	    //案例1：
	    String str1 = new String("str");
	    String str2 = new String("str");
	    System.out.println("==比较 ："+ (str1 == str2));
	    System.out.println("equal比较："+ str1.equals(str2));

　　　　　　 //案例2：
	    String str3 = "str1";
	    String str4 = "str1";
	    System.out.println("==比较 ："+ (str3 == str4));
	    System.out.println("equal比较："+ str3.equals(str4));
		
	}
	
}

结果为：
 ==比较 ：false
equal比较：true
==比较 ：true
equal比较：true

根据打印的可以发现使用equal比较时无论是使用自动装箱来实例化还是用new来实例化，返回的都true，而用==则不一样了，自动装箱来实例化的返回的是true，而用new来

实例化的返回的确实false;先不急着解决为什么，先来了解下equals和==的区别，到时候就可以知道答案了

equals方法最初是在所有类的基类Object中进行定义的，源码是

 public boolean equals(Object obj) {
    return (this == obj);
    }

可以看出这里定义的equals与==是等效的，但上面的怎么还会不一样呢？
原因就是String类对equals进行了重写: