• String类由final修饰，不能继承
• String实现了Serializable接口表示字符串支持序列化
• String实现了Comparable接口表示字符串可以比较大小
• String内部定义了final char[ ] value用于存储字符串数据
• 字符串的值存储在字符串常量池中
• 字符串常量池不存储相同内容的字符串。

• 重新赋值字符串时，需要在指定的内存区域(字符串常量池)中写入新赋予的值，而不是原始值 value（char更改型数组)。
• 拼接现有字符串时，还需要在指定区域重新赋值，不能对原有字符串进行拼接value进行更改。
• 当调用String的replace() 修改指定字符或字符串时，还需要在指定区域重新赋值，不能对原始字符进行赋值value进行更改。

   String s1 = "Hello"; //字面量方式       String s2 = "World";        String s3 = "HelloWorld";       String s4 = "Hello"   "World";       String s5 = s1   "World"; ///有变量参与，可视为new方式创建       String s6 = "Hello"   s2;       String s7 = s1   s2;       String s8 = (s1   s2).intern();        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
      System.out.println(s4 == s8);	//True

- 如果拼接的结果调用intern()方法，返回值就在常量池中，如s8 - 只要其中有一个是变量，结果就在堆中，如：s5，s6 - 常量与常量的拼接结果在常量池，且常量池中不会存在相同内容的常量，如：s4

• 方式一：通过字面量定义的方式
• 方式二：通过new+构造器的方式

	String s1 = "Hello";
	
	String s2 = new String("Hello");

• 方式一：此时s1的数据“Hello”声明在方法区中的字符串常量池中
• 方式二：此种方式在内存中创建了两个对象，一个是堆空间中new的结构，储存的是数据在常量池中的地址值，另一个是char[ ]对应的常量池中的数据 “Hello”

• int length() ：返回字符串的长度 ->return value.length
• char charAt(int index)：返回索引处的字符 ->return value[index]
• boolean isEmpty()：判断是否是空字符
• String toLowerCase()：将String中所有的字符转换为小写
• String toUpperCase()：将String中所有的字符转换为大写
• String trim()：返回字符串的副本，忽略前导空白和尾部空白
• boolean equals(Object obj)：比较字符串的内容是否相同
• boolean equalsIgnoreCase(String anotherString)：比较字符串的内容是否相同，忽略大小写
• 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 offset)：测试此字符串从索引处开始的子字符串是否以指定前缀开始
• boolean contains(CharSequence s)：当且仅当此字符串包含指定的char值序列时，返回true
• int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
• int indexOf(String str,int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
• int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
• int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最右边出现处的索引，从指定的索引开始反向搜索 注：indexOf和lastIndexOf方法如果未找到，返回值都是-1
• 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个，如果超过了，剩下的全部都放在最后一个元素中

调用包装类的静态方法:parseXxx(str)

	String s9 = "123";
	int i1 = Integer.parseInt(s9);

注意：不可以使用强转！int i1 = (int)s9 是错误的

调用String重载的:valueOf(xxx)

	String s10 = String.valueOf(i1);
	String s11 = i1 + "";

调用String的toCharArray( )

	String str1 = "abc123";
	char[] charArray1 = str1.toCharArray();

调用String的构造器

	char[] charArray2 = new char[]{ 
        'a','b', 'c'};
	String str2 = new String(charArray2);

	String str1 = "abc123";
	byte[] bytes = str1.getBytes("utf-8");

getBytes()可提供参数以指定字符集进行编码，若未指定，则使用默认字符集

	String str2 = new String(bytes,"utf-8");

解码集和编码集必须一致，否则会出现乱码

调用StringBuffer、StringBuilder的构造器

	String str1 = "abc123";
	
	StringBuffer sb1 = new StringBuffer(str1);
	StringBuilder sb2 = new StringBuilder(str1);

• 调用String的构造器
• 调用StringBuffer、StringBuilder的 toString() 方法

	String str2 = new String(sb1);
	String str3 = new String(sb2);
	
	String str4 = sb1.toString();
	String str5 = sb2.toString();

• String：不可变的字符序列，底层使用char[ ]存储
• StringBuffer：可变的字符序列，线程安全的，效率低，底层使用char[ ]存储
• StringBuilder：可变的字符序列，线程不安全的，效率高，底层使用char[ ]存储

执行效率： StringBuilder > StringBuffer > String

此处以StringBuffer为例：

	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.length():0 (此处输出的是count，即非空的字符串长度)
	
	sb1.append('a');//value[0] = 'a';
	sb1.append('b');//value[1] = 'b';
	
	StringBuffer sb2 = new StringBuffer("abc"); // char[] value = new char["abc".length() + 16];
	System.out.println(sb2.length()); // 3

动态扩容：对于StringBuffer和StringBuilder，其底层的数组长度在未指定的情况下为原始数据长度+16，若在后续操作中需要添加的数据超过了该长度，即现有的底层数组无法容纳，则会进行扩容。默认情况下，扩容为原来容量的2倍+2，同时将原数组中的元素复制到新的数组中。我们可以在创建StringBuffer和StringBuilder的时候指定容量大小。

• 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)
• public int length()
• public char charAt(int n)
• public void setCharAt(int n, char ch)