Java中String、StringBuffer和StringBuilder比较

String

1. String声明为final的，不可被继承
2. String实现了Serializable接口：表示String是支持序列化的
3. String实现了Comparable接口：表示String可以比较大小
4. String内部定义了final char[ ] value用于存储字符串数据
5. String代表不可变的字符序列（不可变性）
   • 当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值
   • 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
   • 当调用String的replace()方法修改指定字符或字符串时，不能使用原有的value进行赋值

        String s1 = "abc";//字面量的定义方式
        String s2 = "abc";
        System.out.println(s1==s2);//true
        s1="hello";
        System.out.println(s1);//hello
        System.out.println(s2);//abc
        System.out.println("**********************");
        String s3 = "abc";
        s3 += "def";
        System.out.println(s3);//abcdef
        System.out.println(s2);//abc
        System.out.println("**********************");
        String s4 = "abc";
        String s5 = s4.replace('a', 'm');
        System.out.println(s4);//abc
        System.out.println(s5);//mbc
        System.out.println(s4==s5);//fasle

可以看见：

• s1和s2指向同一地址（常量池）
• s3并没有修改常量池中"abc"的值（不可变性），而是新创建了一个字符串
• s4调用replace()方法依然是创建了一个新的字符串常量，返回值给s5，s4和s5指向的是不同的地址

6. 通过字面量方式（区别与new）给一个字符串赋值，此时字符串声明在字符串常量池中
7. 字符串常量池中不会存储相同内容的字符串

String的实例化方式

• 方式一：通过字面量的方式：s1和s2的数据声明在方法区的字符串常量池中
• 方式二：通过new+构造器的方式：s3和s4保存的地址值是在堆空间中开辟以后对应的地址值

        //通过字面量的方式：s1和s2的数据声明在方法区的字符串常量池中
        String s1 = "javaEE";
        String s2 = "javaEE";
        //通过new+构造器的方式：s3和s4保存的地址值是在堆空间中开辟以后对应的地址值
        String s3 = new String("javaEE");
        String s4 = new String("javaEE");

        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
        System.out.println(s1 == s4);//false
        System.out.println(s3 == s4);//false

• 两者的区别
  

几道面试题

• 面试题（一）

public class Person {
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }
    public void setName(String name) {
        this.name = name;
    }
}

Person p1 = new Person("Tom", 12);
Person p2 = new Person("Tom", 12);
System.out.println(p1.name.equals(p2.name));//true
System.out.println(p1.name == p2.name);//true
p1.setName("Bob");
System.out.println(p1.name.equals(p2.name));//false

其内存模型如下：

p1和p2虽然是两个不同的对象，但是他们的内容都是在常量池中的Tom。如果p1修改了它的name值则会新常量池中新创建份数据（String的不可变性），则他们不相等了。

• 面试题（二）
  问：String s = new String(“abc”)方式创建对象，在内存中创建了几个对象？
  答：两个：一个是对空间中new结构，另一个是char[]对应的常量池中的数据
• 面试题（三）

        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
        System.out.println(s3 == s6);//false
        System.out.println(s3 == s7);//false
        System.out.println(s5 == s6);//false
        System.out.println(s5 == s7);//false
        System.out.println(s6 == s7);//false
        
        String s8 = s5.intern();//返回值在常量池中
        System.out.println(s3 == s8);//true

• 结论：
  1. 常量与常量的拼接结果在常量池，且常量池中不会存在相同内容的常量
  2. 只要其中有一个是变量，结果就在堆中
  3. 如果拼接的结果调用intern()方法，其结果就在常量池中
     
• 面试题（四）

    String str = new String("good");
    char[] ch = {'t','e','s','t'};
    public void change(String str,char ch[]){
        str = "test ok";
        ch[0] = 'b';
    }
    public static void main(String[] args) {
        MyStringTest myStringTest = new MyStringTest();
        myStringTest.change(myStringTest.str,myStringTest.ch);
        System.out.println(myStringTest.str);//good
        System.out.println(myStringTest.ch);//best
    }

• 方法传递的是地址值， String有不可变性，所以str没有变，而ch的值变了
• 面试题(五)

        String s1 = "javaEEhadoop";
        String s2 = "javaEE";
        String s3 = s2 + "hadoop";
        System.out.println(s1 == s3);//false
        final String s4 = "javaEE";
        String s5 = s4 + "hadoop";
        System.out.println(s1 == s5);//true

• 加了final之后s4为常量，常量+常量仍为常量

常用方法

• int length()：返回字符串的长度： return value.length
• char charAt(int index)： 返回某索引处的字符return value[index]
• boolean isEmpty()：判断是否是空字符串：return value.length == 0
• String toLowerCase()：使用默认语言环境，将 String 中的所有字符转换为小写
• String toUpperCase()：使用默认语言环境，将 String 中的所有字符转换为大写
• String trim()：返回字符串的副本，忽略前导空白和尾部空白
• boolean equals(Object obj)：比较字符串的内容是否相同
• boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写
• String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+”
• int compareTo(String anotherString)：比较两个字符串的大小
• String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从.beginIndex开始截取到最后的一个子字符串。
• String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
• boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
• boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
• boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始
• String replace(char oldChar, char newChar)：返回一个新的字符串，它是
  通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
• String replace(CharSequence target, CharSequence replacement)：使
  用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
• String replaceAll(String regex, String replacement) ： 使 用 给 定 的,replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
• String replaceFirst(String regex, String replacement) ： 使 用 给 定 的,replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
• boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。
• String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
• String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此
  字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

String其他数据类型之间的转换

• String—>基本数据类型、包装类：调用包装类的静态方法：parseXxx(Str)
• 基本数据类型、包装类—>String：调用String的重载的valueOf(xxx)

        String str1 = "123";
        int num = Integer.parseInt(str1);//123
        String str2 = String.valueOf(num);//"123"

• String—> char[]：调用String的toCharArray()
• char[]—＞String：调用String的构造器

        String str1 = "abc123";
        char[] charArray = str1.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            System.out.println(charArray[i]);
        }
        char[] chars = new char[]{'h','e','l','l','o'};
        String str2 = new String(chars);
        System.out.println(str2);//"hello"

• String —> byte[]:调用String的getBytes()
• byte[] —> String:调用String的构造器
  转换时注意编码集

        String s1 = "abc中国";
        byte[] bytes = s1.getBytes();
        System.out.println(Arrays.toString(bytes));
        //[97, 98, 99, -28, -72, -83, -27, -101, -67]
        byte[] bytes1 = {'a','b','c','d'};
        String s2 = new String(bytes);
        System.out.println(s2);//abc中国

String、StringBuffer和StringBuilder（重要）

• String：不可变（final）的字符序列，底层使用char[]存储
• StringBuffer：可变的字符序列，线程安全，效率低，底层使用char[]存储
• StringBuilder：可变的字符序列，(jdk5.0)线程不安全，效率高，底层使用char[]存储
• StringBuffer和StringBuilder的扩容：默认情况扩容为原来容量的2倍+2，同时将原数组中的元素复制到新的数组中去。

StringBuffer的常用方法

• StringBuffer append(xxx)：提供了很多的- append()方法，用于进行字符串拼接
• StringBuffer delete(int start,int end)：删除指定位置的内容
• StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str
• StringBuffer insert(int offset, xxx)：在指定位置插入xxx
• StringBuffer reverse() ：把当前字符序列逆转
• indexOf(String str)
• substring(int start,int end)
• length()
• charAt(int n)
• setCharAt(int n ,char ch)