String、StringBuffer、StringBuilder三者的异同

String

String:字符串，使用一对""引起来表示。
1.String声明为final的，不可被继承
2.String实现了Serializable接口：表示字符串是支持序列化的。
实现了Comparable接口：表示String可以比较大小
3.String内部定义了final char[] value用于存储字符串数据
4.String:代表不可变的字符序列。简称：不可变性。
体现： 1.当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
2. 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
3. 当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
5.通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。
6.字符串常量池中是不会存储相同内容的字符串的。

面试题：

1.String s = new String(“abc”);//方式创建对象，在内存中创建了几个对象？

答：两个：一个是堆空间中new结构，另一个是char[]对应的常量池中的数据：“abc”

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

    public void test3(){
        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 = s6.intern();//返回值得到的s8使用的常量值中已经存在的“javaEEhadoop”
        System.out.println(s3 == s8);//true
    }
    public void test4(){
        String s1 = "javaEEhadoop";
        String s2 = "javaEE";
        String s3 = s2 + "hadoop";
        System.out.println(s1 == s3);//false

        final String s4 = "javaEE";//s4:常量
        String s5 = s4 + "hadoop";
        System.out.println(s1 == s5);//true

    }

2.输出的结果为？

public class StringTest {

    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) {
        StringTest ex = new StringTest();
        ex.change(ex.str, ex.ch);
        System.out.println(ex.str);//good
        System.out.println(ex.ch);//best
    }
}

常用API

• 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(不包含)的一个子字符串。

把字符串转换成int型
int num = Integer.parseInt(str);

String 与 char[]
String -->char[]
char[] ch = str.toCharArray();

字符串拼接问题：

1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
2.只要其中有一个变量，结果就在堆中。
3.如果拼接的结果调用intern()方法，返回值就在常量池中。

String、StringBuffer、StringBuilder三者的异同？

• String:不可变的字符序列；底层使用char[]存储

• StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储

• StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储

• 源码分析：
  String str = new String();//char[] value = new char[0];
  String str1 = new String(“abc”);//char[] value = new char[]{‘a’,‘b’,‘c’};
  StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组。
  System.out.println(sb1.length());//
  sb1.append(‘a’);//value[0] = ‘a’;
  sb1.append(‘b’);//value[1] = ‘b’;

  StringBuffer sb2 = new StringBuffer(“abc”);//char[] value = new char[“abc”.length() + 16];

• 问题1. System.out.println(sb2.length());//3

• 问题2. 扩容问题:如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
  默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中的元素复制到新的数组中。

• 指导意义：开发中建议大家使用：StringBuffer(int capacity) 或 StringBuilder(int capacity)
  

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() ：把当前字符序列逆转
• public int indexOf(String str)
• public String substring(int start,int end):（切割）返回一个从start开始到en索引结束的左闭右开区间的子字符串
• public int length()
• public char charAt(int n )
• public void setCharAt(int n ,char ch)

总结：

• 增：append(xxx)
• 删：delete(int start,int end)
• 改：setCharAt(int n ,char ch) / replace(int start, int end, String str)
• 查：charAt(int n )
• 插：insert(int offset, xxx)
• 长度：length();
• *遍历：for() + charAt() / toString()

对比String、StringBuffer、StringBuilder三者的效率：

从高到低排列：StringBuilder > StringBuffer > String

测试：

public void text01() {
        //初始设置
        long startTime = 0L;
        long endTime = 0L;
        String text = "";
        StringBuffer buffer = new StringBuffer("");
        StringBuilder builder = new StringBuilder("");
        //开始对比
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer的执行时间：" + (endTime - startTime));

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的执行时间：" + (endTime - startTime));

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的执行时间：" + (endTime - startTime));
    }

运行结果：

StringBuffer的执行时间：30
StringBuilder的执行时间：5
String的执行时间：1391

String的常用方法有哪些？（至少7个）

length() / charAt() / equals() / compareTo() / startsWith() / endsWith()
containts() / indexOf() / lastIndexOf() / getBytes() / toCharArray() / valueOf() / ….

JVM中字符串常量池存放位置说明:

• jdk 1.6 (jdk 6.0 ,java 6.0):字符串常量池存储在方法区（永久区)
• jdk 1.7:字符串常量池存储在堆空间
• jdk 1.8:字符串常量池存储在方法区(元空间)