目录
一：常用方法
1.1字符串构造
1.2String对象的比较
1. ==比较是否引用同一个对象
2. boolean equals(Object anObject) 方法：按照字典序比较
3.int compareTo(String s) 方法: 按照字典序进行比较。
4.int compareToIgnoreCase(String str) 方法
1.3字符串查找
1.4转化
1. 数值和字符串转化
2.大小写转换
3.字符串转数组
4.格式化
1.5字符串替换
1.6字符串拆分
1.7字符串截取
二：字符串常量池
2.1什么是字符串常量池？
2.2画图解释
2.2.1直接被双引号括起来的字符串
2.2.2new创建的字符串
2.3intern方法
三：StringBuilder和StringBuffer
一：常用方法
1.1字符串构造
我仅介绍最常用的三种构造方法。
public class TestDemo {
public static void main(String[] args) {
// 1.使用常量串构造
String s1 = "helloworld";
System.out.println(s1);
// 2.直接newString对象
String s2 = new String("helloworld");
System.out.println(s2);
// 3.使用字符数组进行构造
char[] array = {'h','e','l','l','o','w','o','r','l','d'};
String s3 = new String(array);
System.out.println(s3);
}
}运行结果如下：
1.2String对象的比较
1. ==比较是否引用同一个对象
注意：对于内置类型，==比较的是变量中的值；对于引用类型==比较的是引用中的地址。
public class TestDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 10;
// 对于基本类型变量，==比较两个变量中存储的值是否相同
System.out.println(a == b); // false
System.out.println(a == c); // true
// 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = new String("world");
String s4 = s1;
System.out.println(s1 == s2); // false
System.out.println(s2 == s3); // false
System.out.println(s1 == s4); // true
}
}运行结果如下：
2. boolean equals(Object anObject) 方法：按照字典序比较
字典序（dictionary order），又称字母序（alphabetical order），原意是表示英文单词在字典中的先后顺序，在计算机领域中扩展成两个任意字符串的大小关系。
字典序：字符大小的顺序。String类重写了父类Object中equals方法。
public class TestDemo {
public static void main(String[] args) {
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = new String("world");
// s1、s2、s3引用的是三个不同对象，因此==比较结果全部为false
System.out.println(s1 == s2); // false
System.out.println(s1 == s3); // false
// equals比较：String对象中的逐个字符
// 虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true
// s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false
System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // false
}
}
运行结果如下：
内容是否相同，返回值为boolean类型。
3.int compareTo(String s) 方法: 按照字典序进行比较。
public class TestDemo {
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("ac");
String s3 = new String("abc");
String s4 = new String("abcdefg");
System.out.println(s1.compareTo(s2)); // 第1个字符完全相同，输出长度差值-1
System.out.println(s1.compareTo(s3)); // 相同输出 0
System.out.println(s1.compareTo(s4)); // 前4个字符完全相同，输出长度差值-4
}
}
运行结果如下：
总结：S1.compareTo(S2)，就是比较字符串S1与S2的内容是否相同，返回值为int类型，返回值等于0，说明S1和S2内容相同；输出负数，说明S1字典序小于S2；输出正数，说明S1字典序大于S2。
4.int compareToIgnoreCase(String str) 方法
与compareTo方式相同，但是忽略大小写比较。
public class TestDemo {
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("ac");
String s3 = new String("ABc");
String s4 = new String("abcdef");
System.out.println(s1.compareToIgnoreCase(s2)); // 不同输出字符差值-1
System.out.println(s1.compareToIgnoreCase(s3)); // 相同输出 0
System.out.println(s1.compareToIgnoreCase(s4)); // 前k个字符完全相同，输出长度差值 -3
}
}
运行结果如下：
1.3字符串查找
String提供的常用查找方法有：
public class TestDemo {
public static void main(String[] args) {
String s = "aaabbbcccaaabbbccc";
System.out.println(s.charAt(3));
}
}
运行结果如下：
1.4转化
1. 数值和字符串转化
public class TestDemo {
public static void main(String[] args) {
// 数字转字符串
String s1 = String.valueOf(1234);
String s2 = String.valueOf(12.34);
String s3 = String.valueOf(true);
System.out.println(s1+1);
System.out.println(s2+1);
System.out.println(s3+1);
System.out.println("=================================");
// 字符串转数字
int data1 = Integer.parseInt("1234");
double data2 = Double.parseDouble("12.34");
System.out.println(data1+1);
System.out.println(data2+1);
}
}
运行结果如下：
2.大小写转换
public class TestDemo {
public static void main(String[] args) {
String s1 = "hello";
String s2 = "HELLO";
// 小写转大写
System.out.println(s1.toUpperCase());
// 大写转小写
System.out.println(s2.toLowerCase());
}
}
运行结果如下：
3.字符串转数组
public class TestDemo {
public static void main(String[] args) {
String s = "hello";
// 字符串转数组
char[] ch = s.toCharArray();
for (int i = 0; i < ch.length; i++) {
System.out.print(ch[i]);
}
System.out.println();
// 数组转字符串
String s2 = new String(ch);
System.out.println(s2);
}
}
运行结果如下：
总结：
1。字符串转数组——char[ ] ch = s.toCharArray();
2. 数组转字符串 String s2 = new String(ch);
4.格式化
public class TestDemo {
public static void main(String[] args) {
String s = String.format("%d-%d-%d", 2019, 9,14);
System.out.println(s);
}
}
运行结果如下：
1.5字符串替换
public class TestDemo {
public static void main(String[] args) {
String str = "helloworld";
System.out.println(str.replaceAll("l", "_"));
System.out.println(str.replaceFirst("l", "_"));
}
}
运行结果如下：
1.6字符串拆分
public class TestDemo {
public static void main(String[] args) {
String str = "hello world hello bai" ;
String[] result = str.split(" ") ; // 按照空格拆分
for(String s: result) {
System.out.println(s);
}
System.out.println("====================");
String str1 = "hello world hello bai" ;
String[] result1 = str.split(" ",2) ;//只拆成2部分
for(String s: result1) {
System.out.println(s);
}
}
}
运行结果如下：
特殊情况：拆分时含有特殊字符，需要进行转义，其规则如下：
1. 字符"|","*","+"都得加上转义字符，前面加上"\\" .
2. 而如果是"\" ，那么就得写成"\\\\" .
3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符.
public class TestDemo {
public static void main(String[] args) {
String str = "192.168.1.1" ;
String[] result = str.split("\\.") ;
for(String s: result) {
System.out.println(s);
}
}
}
运行结果如下：
多次拆分：很简单，对拆分的结果进行再拆分即可。
public class TestDemo {
public static void main(String[] args) {
String str = "name=zhangsan&age=18";
String[] result = str.split("&");
for (int i = 0; i < result.length; i++) {
System.out.println(result[i]);
}
System.out.println("===============");
for (int i = 0; i < result.length; i++) {
String[] temp = result[i].split("=");
System.out.println(temp[0] + " ## " + temp[1]);
}
}
}
运行结果如下：
1.7字符串截取
public class TestDemo {
public static void main(String[] args) {
String str = "helloworld" ;
System.out.println(str.substring(5));
System.out.println(str.substring(0, 5));
}
}
运行结果如下：
注意:
1. 索引从0开始；
2. 注意前闭后开区间的写法, substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标。
二：字符串常量池
2.1什么是字符串常量池？
在Java程序中，类似于：1， 2， 3，3.14，“hello”等字面类型的常量经常频繁使用，为了使程序的运行速度更快、更节省内存，Java为8种基本数据类型和String类都提供了常量池。
为了节省存储空间以及程序的运行效率，Java中引入了：
1. class文件常量池：每个.java源文件编译后生成的.class文件中会保存当前类中的字面常量以及符号信息；
2. 运行时常量池：在.class文件被加载时，.class文件中的常量池被加载到内存中称为运行时常量池，运行时常量池每个类都有一份；
3. 字符串常量池。注意：
1. 在JVM中字符串常量池只有一份，是全局共享的；
2. 刚开始字符串常量池是空的，随着程序不断运行，字符串常量池中元素会越来越多；
3. 当类加载时，字节码文件中的常量池也被加载到JVM中，称为运行时常量池，同时会将其中的字符串常量保存在字符串常量池中；
4. 字符串常量池中的内容：一部分来自运行时常量池，一部分来自程序动态添加。
2.2画图解释
2.2.1直接被双引号括起来的字符串
2.2.2new创建的字符串
总结：只要是new的对象，都是唯一的。
2.3intern方法
intern是一个native方法(Native方法指：底层使用C++实现的，看不到其实现的源代码)，该方法的作用是手动将创建的String对象添加到常量池中。
public class TestDemo {
public static void main(String[] args) {
char[] ch = new char[]{'a', 'b', 'c'};
String s1 = new String(ch);
s1.intern();// s1对象被添加到常量池中
String s2 = "abc"; // "abc" 在常量池中存在了，s2创建时直接用常量池中"abc"的引用
System.out.println(s1 == s2);
}
}
运行结果如下：
总结：
1.S.intern()方法，将创建的String对象S添加到常量池中。
2.只有常量池中没有时，才会入池。
注意:因为String内部的value被final修饰，所以字符串不能被修改.所有对字符串的操作，本质上都是创建了新的字符串。
三：StringBuilder和StringBuffer
在对String类进行修改时，效率是非常慢的，因此：尽量避免对String的直接需要，如果要修改建议尽量使用StringBuffer或者StringBuilder。
说明：所有对String适用的方法，也适用于StringBuilder和StringBuffer。
具体实例如下：
public class TestDemo1 {
public static void main(String[] args) {
StringBuilder sb1 = new StringBuilder("hello");
StringBuffer sb2 = new StringBuffer("hello");
sb1.append("world");
sb2.append("world");
System.out.println(sb1);
System.out.println(sb2);
sb1.reverse();
sb2.reverse();
System.out.println(sb1);
System.out.println(sb2);
}
}运行结果如下：
区别：
1.在执行速度方面的比较：StringBuilder> StringBuffer；
2.StringBuffer与StringBuilder，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作的，不像String一样创建一些对象进行操作，所以速度就快了；
3.StringBuilder：线程非安全的 StringBuffer：线程安全的建议：
1.如果要操作少量的数据用 String；
2.单线程操作字符串缓冲区下操作大量数据 StringBuilder；
3.多线程操作字符串缓冲区下操作大量数据 StringBuffer。
本课内容完！
