String
String类头
public final class String extends Object implements Serializable, Comparable<String>,
CharSequence
子串
public String substring(int beginIndex, int endIndex)
String greeting = "Hello";
//修改字符串变量
greeting = greeting.substring(0,3);
substring第二个参数为不想赋值的第一个位置。此函数赋值0、1、2。
拼接
“+”可以实现String的拼接。当一个字符串与一个非字符串进行拼接时，后者被转换为字符串。
//拼接字符串
int age = 13;
String rating = "PG" + age;
System.out.println(rating);
关于 equal 和 ==
== 用于比较两个对象的时候，是来check 是否两个引用指向了同一块内存。equals() 是object的方法，默认情况下，它与== 一样，比较的地址。但是当equal被重载之后，根据设计，equal 会比较对象的value。而这个是java希望有的功能。
//测试equals和==
//以字面常量测试
String obj1 = "Hello";
String obj2 = "Hello";
if(obj1 == obj2){
System.out.println("obj1 == obj2: "+"true");
}
else {
System.out.println("obj1 == obj2: "+"false");
}
if(obj1.equals(obj2)){
System.out.println("obj1.equals(obj2): "+"true");
}
else {
System.out.println("obj1.equals(obj2): "+"false");
}
//以new创建对象测试
String obj3 = new String("Hello");
String obj4 = new String("Hello");
if(obj3 == obj4){
System.out.println("obj3 == obj4: "+"true");
}
else {
System.out.println("obj3 == obj4: "+"false");
}
if(obj3.equals(obj4)){
System.out.println("obj3.equals(obj2): "+"true");
}
else {
System.out.println("obj4.equals(obj2): "+"false");
}
运行结果：
obj1 == obj2: true
obj1.equals(obj2): true
obj3 == obj4: false
obj3.equals(obj2): true
常量池
如果使用字面量创建一个String对象时，它将返回一个位于字符串常量池中的引用，如果该字面量已经存在于常量池(String Pool)中，则无需重新新建，只需要已有的字面量，否则将新建一个字面量。
jdk1.7之前，String Pool位于堆中的永久去内，从jdk1.7开始，String Pool迁移到主堆中。
//测试String Pool
String s1 = new String("java");
String s2 = new String("java");
String s3 = "java";
String s4 = "java";
String Pool.png
s1 == s2: false
s1.equals(s2): true
s3 == s4: true
String & StringBuffer & StringBuilder
- String:是不可改变的量，也就是创建后就不能在修改了。
String.png
- StringBuffer:是一个可变字符串序列，它与 String 一样，在内存中保存的都是一个有序的字符串序列（char 类型的数组），不同点是 StringBuffer 对象的值都是可变的。
StringBuffer.png
- StringBuilder:与 StringBuffer 类基本相同，都是可变字符换字符串序列，不同点是 StringBuffer 是线程安全的，StringBuilder 是线程不安全的。
使用场景
- String:在字符串不经常变化的场景中可以使用 String 类，例如常量的声明、少量的变量运算。
- StringBuffer:在频繁进行字符串运算（如拼接、替换、删除等），并且运行在多线程环境中，则可以考虑使用 StringBuffer，例如 XML 解析、HTTP 参数解析和封装。
- StringBuilder:在频繁进行字符串运算（如拼接、替换、和删除等），并且运行在单线程的环境中，则可以考虑使用 StringBuilder，如 SQL 语句的拼装、JSON 封装等。
运行速度
StringBuilder > StringBuffer>String
在正常情况下，每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。
而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢。
final static int ttimes = 3000;// 设置循环次数
// String测试,对String使用‘+’添加字面常量
public void test(String s) {
long begin = System.currentTimeMillis();
for (int i = 0; i < ttimes; i++) {
s += "add";
}
long over = System.currentTimeMillis();
System.out.println(" 操作 " + s.getClass().getName() + " 类型使用的时间为： "
+ (over - begin) + " 毫秒 ");
}
// String测试,对String直接进行字符串拼接
public void test2() {
String s2 = "abcdefg";
long begin = System.currentTimeMillis();
for (int i = 0; i < ttimes; i++) {
String s = s2 + s2 +s2;
}
long over = System.currentTimeMillis();
System.out.println(" 操作字符串对象引用相加类型使用的时间为： " + " 类型使用的时间为： "
+ (over - begin) + " 毫秒 ");
}
// String测试,对String直接进行字符串拼接
public void test3() {
long begin = System.currentTimeMillis();
for (int i = 0; i < ttimes; i++) {
String s = "abcdefg" + "abcdefg" +"abcdefg";
}
long over = System.currentTimeMillis();
System.out.println("操作字符串对象引用相加类型使用的时间为： " + " 类型使用的时间为： "
+ (over - begin) + " 毫秒 ");
}
// StringBuffer测试
public void test(StringBuffer s) {
long begin = System.currentTimeMillis();
for (int i = 0; i < ttimes; i++) {
s.append("add");
}
long over = System.currentTimeMillis();
System.out.println(" 操作 " + s.getClass().getName() + " 类型使用的时间为： "
+ (over - begin) + " 毫秒 ");
}
// StringBuilder测试
public void test(StringBuilder s) {
long begin = System.currentTimeMillis();
for (int i = 0; i < ttimes; i++) {
s.append("add");
}
long over = System.currentTimeMillis();
System.out.println(" 操作 " + s.getClass().getName() + " 类型使用的时间为： "
+ (over - begin) + " 毫秒 ");
}
String s1 ="abc";
StringBuffer sb1 = new StringBuffer("abc");
StringBuilder sb2 = new StringBuilder("abc");
Main t = new Main();
t.test(s1);
t.test(sb1);
t.test(sb2);
t.test2();
t.test3();
操作 java.lang.String 类型使用的时间为： 47 毫秒
操作 java.lang.StringBuffer 类型使用的时间为： 2 毫秒
操作 java.lang.StringBuilder 类型使用的时间为： 1 毫秒
操作字符串对象引用相加类型使用的时间为： 类型使用的时间为： 6 毫秒
操作字符串相加类型使用的时间为： 类型使用的时间为： 0 毫秒
实验证明：
StringBuffer与StringBuilder速度相差不大，两者速度明显高于String；
String直接使用字符串相加时，JVM会默认为把几个字符串加在一起，运行速度较快，但是使用引用相加时需要创建新的对象，比较耗时。
