目录
一.String类的基本概述
通过源码来看一下String类的基本情况:
1.1 String类的几个基本特征:
上图我们可以看出String有这么几个基本的特征:
- String字符串的底层实现是用一个“char[]数组”来存放的。
- 该数组是final类型的，说明是不可变的（下面我们展开理解这个不可变性）。
- String实现了Serializebal接口，说明是可序列化的。
关于Java的序列化机制，这里简单解释就是：允许把内存中的Java对象转换成平台无关的二进制流，进行一种传输，这里主要是在IO流的部分用到；凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量（就是上图中的一大串数字）。
1.2 创建String类的对象
有两种创建String类对象的方式，大家也都很熟悉。
分别是：字面量的方式和通过构造器的方式。
String类的构造器
Stirng类里是有多个构造器的。
有这么几种常用的（通过代码的形式体现）：
- 空参构造器: new String()
源码:
- new String(String original)
源码：
- new String(char[] value)
源码:
- 4. new String(char value[] , int offset , int count)
从指定的char[]数组中的指定位置offset开始，复制count个字符到字符串中。
源码:(涉及到一些逻辑的判断，难度也不算大)
二. 字符串的不可变性
我们通过字符串不同的创建方式，来体会字符串的这个不可变性(final)到底体现在哪里。
先通过一段代码来看一下。
2.1 不可变性的初步理解
上面这段代码在内存层面是怎么一回儿事呢？
这里我们需要对内存有个简单的了解
- 栈区主要用来存放 存储局部变量 ；堆区主要用来存放 对象实例 ； 而你用字面量方式（上图创建的字符串常量）都直接存放在常量池中（常量池中不会创建两个相同的实例变量）。
- 上图可以看出，一旦我们为s1初始化以后，这个实体变量（“qiqi”）就是不可变的，当我们想要修改s1指向的字符串的内容时候，只能为s1在常量池开辟一块儿新的内存，去存放新的内容。
2.2 两种创建方式的区别
String s = "abc";
String s1 = new String("abc");上面两种创建对象的方式有什么不同呢？
- 通过构造器创造对象的时候，会在堆区创建一个字符串非常量对象（字符串常量存储在字符串常量池，目的是共享；而字符串非常量对象存储在堆中）。
我们可以通过一个小练习来证明这一点。
String s1 = "nihao";
String s2 = "nihao";
String s3 = new String("nihao");
String s4 = new String("nihao");
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s1 == s4);
System.out.println(s3 == s4);一起来分析一下
再次印证了这一点:
字符串常量存储在字符串常量池，目的是共享；而字符串非常量对象存储在堆中。
来看不太那么一样的：
Person p1 = new Person("Jerry",21);
Person p2 = new Person("Jerry",21);
System.out.println(p1.name == p2.name);
所以这段小程序的结果就是：true（==比的是地址值）。
2.3 判断题目
String s1 = "hello";
String s2 = "world";
String s3 = "hello" + "world";
String s4 = s1 + "hello";
String s5 = s1 + s2;
String s6 = (s1 + "hello").intern();
String s7 = (s1 + s2).intern();
System.out.println(s3 == s4);
System.out.println(s3 == s5);
System.out.println(s3 == s7);
System.out.println(s4 == s5);看到这里是不是有点晕乎乎的
直接我们摆上结论：
结论：
常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
只要其中有一个是变量，结果就在堆中
如果拼接的结果调用intern()方法，返回值就在常量池中所以上面的结果就是：
三.String类中的常用方法
String类中的常用方法还是蛮多的，平常写代码的过程中有一些还是会经常用到，需要熟悉这些方法的使用 ，但我们也没必要去背这些方法，以后大家需要用到了，可以来这里查看一下就好啦。
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)：测试此字符串从指定索引开始的
子字符串是否以指定前缀开始
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)：返回指定子字符串在此字符串中最后
一次出现处的索引，从指定的索引开始反向搜索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与基本数据类型之间的转换
字符串--->基本数据类型
通过包装类里的方法:parseXxx()
String s = "12345";
int i = Integer.parseInt(s);
System.out.println(i);但是，下面这种情况可以转换成功吗？
String s = "abc123";
int i = Integer.parseInt(s);
System.out.println(i);
会报数据类型不匹配的异常，所以进行类型转换的时候并不是一切数据类型都可以转换的。
类似的， 像Byte,Long,Doubled；
String s = "123";
byte b = Byte.parseByte(s);
System.out.println(b);基本数据类型---->字符串
调用String类的方法，Valueof();
int i = 123;
String s = String.valueOf(i);
System.out.println(s);
double d = 123.5;
String s1 = String.valueOf(d);
System.out.println(s1);字符数组---->字符串
调用String类的构造器:new String(char[] arr) 和 new String(char[] arr , int offset , int length)。
char[] c = new char[]{'a','b','c'};
String s1 = new String(c);
String s2 = new String(c,1,2); //从1的索引位置开始，复制的长度为2
System.out.println(s1);
System.out.println(s2);字符串---->字符数组
toCharrArray()方法 和 getChars(int srcBegin , int srcEnd , char[] dest , int dstBegin)方法（将指定索引位置的字符串存放到数组中）
String s = "acvsdasdas";
char[] chars = s.toCharArray();
System.out.println(Arrays.toString(chars));
s.getChars(0, 5, chars, 2);
System.out.println(Arrays.toString(chars));字节数组---->字符串
调用String类的构造器:new String(byte[] arr) 和 new String(byte[] arr , int offset , int length)。
byte[] bytes = new byte[]{'a','b','c','d'};
String s = new String(bytes);
System.out.println(s);字符串---->字节数组
getBytes()方法(使用的是平台默认的字符集) 和 getBytes(String charSetName) 使用指定的字符集将String编码的byte[]数组中
String s1 = "adasdas";
byte[] bytes1 = s1.getBytes();
byte[] bytes2 = s1.getBytes("utf-8");
System.out.println(Arrays.toString(bytes1));
System.out.println(Arrays.toString(bytes2));五. StringBuffer类
StringBuffer类与String可最大的一个不同点就是:StringBuffer是可变的字符串序列 可以对字符串中的内容进行修改，且不会产生新的对象。
其它的很多方法与String都是类似的，毕竟两人儿从名儿上看也怪像哥俩的。
StringBuffer的基本特征
源码：
由上图可知：
- StringBuffer类也同样实现了Serializable接口，是可序列化的
- StringBuffer的底层也是用char[]数组存放，但数组的类型不再是final类型，是可变的。
- StringBuffer只能通过构造器来调用,调用它的空参构造器的时候，会创造一个容量为16的char[]数组
- StringBuffer支持方法链的操作
通过源码再来了解一下:
StringBuffer是继承与AbstractStringBuffer类的，调用StringBuffer的空参构造器的时候，其实是调用了父类的方法。
我们可以清晰的看到，底层初始化创建了一个长度为16的字符数组。
StringBuffer创建对象
只能通过构造器来创建对象，类内提供了三种构造器：
前面两种都很好理解，我们稍微来看一下第三个
public StringBuffer(String str) {
super(str.length() + 16);
append(str);
}该构造器接受一个字符串，调用父类的构造器，创造一个长度为“16+str.leng()”长度的char[]数组，再将该字符串添加到数组中。
问题随之而来：
一开始创建了一个长度为16的数组，那万一要是不够了，该怎么办？扩容吗？扩容是怎么扩的？
其实啊，StringBuffer类里有个方法，就是用来扩容的。
我们可以看到，这个方法还是线程安全的。
一路点进来，我们发现，其实调用的还是父类的方法
- 如果你当前传入的数组长度小于16，那就直接将字符串中的内容复制到数组中去；如果不够的话，这里扩容是扩大到了原来长度的两倍还多两个。
- 这里使用的是位运算符（效率比较快，我们写代码遇到扩容的问题时，也可以这样子做）: (value.length << 1) +2;
- 如果扩容之后还不够，就直接把字符串的长度赋值给数组。
- 下面还涉及到一些移位过程中涉及到的逻辑判断。
StringBuffer的可变性
在对String类的不可变性理解的基础上，StringBuffer的可变性就很好理解了。
StringBuffer s = new StringBuffer("我喜欢");
s.append("蜜枣的粽子");在这里追加的时候，并不会去创建新的对象，而是直接在原来的基础上追加的。(实体是可变的)
StirngBuffer的常用方法
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) 返回字符串str在所创建的字符串的所以位置，如果没有，返回-1
public String substring(int start,int end) 返回一个子串[start,end）左闭右开
public int length() 返回长度
public char charAt(int n ) 返回索引位置n上的字符
public void setCharAt(int n ,char ch) 将指定位置上的字符替换成ch
六. StringBuilder类
StringBuilder类和StringBuffer类类似，只不过StringBuffer效率比较低，是线程安全的的。
StringBuilder类效率比较高，线程不安全。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
