String类和StringBuilder类

1. API
   1.1 API概述-帮助文档的使用
   问题：
   1.什么是API，使用API文档有什么好处？
   2.如何使用API文档，应该看文档的哪些内容？
   什么是API
   API (Application Programming Interface) ：应用程序编程接口
   官方写好的一个个可以被我们使用的对象工具的模板（类），每个类里面都有提供给我们的属性和功能
   什么是API文档：
   这么多的类和功能，我们不可能记得住，需要使用文档去查询他们的使用方式，这个文档就是API文档
   API帮助文档使用：
   打开帮助文档
   找到索引选项卡中的输入框
   在输入框中输入Random
   看类在哪个包下，因为不同包下可能有同名类
   看类的描述，要明白这个类是不是我们想要的工具
   看构造方法，如果是我们要的，那我们得知道如何创建它的对象
   看成员方法，我们要知道这个工具具体有哪些功能，使用的时候需不需要给条件
   1.2 键盘录入字符串
   问题：
   1.Scanner键盘录入字符串总共有几种方式？
   2.Scanenr使用next()方法录入字符串会存在什么问题？
   3.是否需要解决nextLine()方法存在的问题？
   Scanner类录入字符串的方法：
   next()：遇到了空格，就不再录入数据了，结束标记：空格，tab键
   nextLine()：可以将数据完整的接收过来，结束标记：回车换行符
   注意事项：
   next()方法录入字符串，字符串不能带空格，否则信息将录入不全
   nextLine()方法录入字符串，不要和nextInt()方法连用，否则会直接跳过，直接结束
   nextLine()和录入其他数据的问题解决方案：
   以后录入字符串都用next();
   如果非要录入带空格的字符串，如果是和录入其他数据混用，在录入其他数据之后，马上写一个sc.nextLine();不用变量接收。目的是消费掉回车
   总结：
   今天核心是API文档的使用，所以这个小结只是利用Scanner举例
   看文档的过程中，也会发现有自己不懂的内容，比如方法的参数中出现了一些没有学过的类，这通常都不需要关注，以后会接触
   看文档注意，先明确自己的需求，然后看方法名，猜测一下哪个方法是自己想要的。结合方法的参数和返回值一起去推测，参数告诉你执行这个功能需要什么条件，返回值告诉你执行完这个功能，我能给你什么数据
   案例练习：
   需求：
   已有学生类如下，请根据属性内容，补全其构造方法和setter\getter方法
   控制台提示录入4名学生的各项信息，将录入的信息封装成学生对象存入数组
   在控制台打印4名学生的信息
   效果图：
   键盘录入学生信息：
   

打印所有学生信息：

代码材料：
public class Student {
//学生id
private String id;
//学生姓名
private String name;
//学生年龄
private int age;
//学生评语
private String estimate;
}
代码实现：
//1.要键盘录入四名学生信息，存入数组，数组长度是4
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//创建一个长度为4的学生数组
Student[] stus = new Student[4];
//2.开始录入4名学生信息，录入的操作是重复的，重复的次数是明确的，使用for
for (int i = 0; i < stus.length; i++) {
//3.提示用户录入信息
System.out.println(“请输入第” + (i + 1) + “名学生信息”);
System.out.println(“请输入学生学号：”);
String id = sc.next();
System.out.println(“请输入学生姓名：”);
String name = sc.next();
System.out.println(“请输入学生年龄：”);
int age = sc.nextInt();
//加一个nextLine消费回车
sc.nextLine();
System.out.println(“请输入学生评语：”);
String estimate = sc.nextLine();
//4.学生信息录入了，但是都是零散的数据，要把这些零散数据统一管理
//根据信息创建学生对象
Student stu = new Student(id, name, age, estimate);
//5.存入数组
stus[i] = stu;
}
//6.循环结束，所有学生信息都存入了数组，开始遍历打印所有学生信息
for (int i = 0; i < stus.length; i++) {
//7.取出学生对象
Student student = stus[i];
System.out.println(“学号：” + student.getId() + “,姓名：” + student.getName() + “,年龄：” + student.getAge() + “,评语：” + student.getEstimate());
}
2. String类
2.1 String概述
问题：
1.如果使用的是java.lang包下的类，是否需要进行导包？
2.在创建String类对象的时候，它有什么特殊的地方？
3.String类的length()方法返回的长度是根据什么得到的？
String 类在java.lang包下，所以使用的时候不需要导包
String 类代表字符串，，Java 程序中所有的双引号字符串，都是 String 类的对象
字符串不可变，它们的值在创建后不能被更改，如果给一个字符串变量重新赋值了一个字符串常量，不是修改了对象，而是重新指向了一个新的对象
2.2 String类常见构造方法
问题：
1.有多少种常见的字符串对象创建方式？
2.哪种字符串创建方式，实际上是创建了两个字符串对象？
常用的构造方法

示例代码
//案例：分别用以上4种方式创建字符串对象，并且打印
​
2.3 创建字符串对象的区别对比
问题：
1.如何比较两个字符串对象在内存中的地址是否相同？==
2.在什么情况下，字符串不会重新创建，而是直接复用？赋值一个已经存在的字符串常量
3.字符串常量在内存中的哪个位置进行存储？字符串常量池
通过构造方法创建
通过 new 创建的字符串对象，每一次 new 都会申请一个堆内存空间，虽然内容相同，但是地址值不同
直接赋值方式创建
以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护
//案例：分别用构造方法创建的字符串和用“”方式给出的字符串，使用==进行比较
//用字符串常量赋值
String s1 = “hello”;
String s2 = “hello”;
//以上两个字符串对象在字符串常量池，s1和s2指向的地址相同
System.out.println(s1 == s2);//结果：true

String s3 = new String(“abc”);
String s4 = new String(“abc”);
//以上两个字符串对象不在字符串常量池，就直接在堆内存中
//s3和s4指向的地址不相同，有几个new，就有几个地址
System.out.println(s3 == s4);//结果：false
2.4 String特点：常见面试题
字符串变量直接赋值字符串常量，指向的地址是字符串常量池中的对象
字符串变量赋值的是一个字符串类型变量和其他字符串的拼接
底层在堆内存中会有StringBuilder对象做拼接，得到StringBuilder对象，然后调用它的toString方法得到一个String对象，这个String对象是在堆内存中，只是拿到了常量池中的字符串值
字符串变量赋值的是两个字符串常量拼接，会有常量优化机制，指向的还是常量池中的那个拼接后的字符串对象
//定义两个变量，接收相同字符串常量
String s1 = “abc”;
String s2 = “abc”;
System.out.println(s1 == s2);//true。都是指向常量池的"abc"字符串

String s3 = “ab”;
String s4 = s3 + “c”;
//底层在堆内存中会有StringBuilder对象做拼接，得到StringBuilder对象，然后调用它的toString方法
//得到String对象，这个String对象是在堆内存中，只是拿到了常量池中的字符串值
//所以s3指向的是常量池中的字符串对象，s4指向的是堆内存中的字符串对象，地址不一样
System.out.println(s4 == s1);//flase。

String s4=“ab”+“c”;
//如果字符串拼接都是用字符串常量，会有常量优化机制，底层不会用StringBuilder做拼接
//所以s1和s4都还是指向常量池中的字符串
System.out.println(s4 == s1);//true。

//给一个变量加上final关键字，就相当于这个变量变成了常量
final String s5 = “ab”;
String s6 = s5 + “c”;
System.out.println(s6 == s1);//true
2.5 字符串的比较
问题：
1.在实际开发中，字符串的比较一般使用什么方式？
2.如果要忽略大小写去比较两个字符串内容是否相同，用哪个方法？
== 比较基本数据类型：比较的是具体的值
== 比较引用数据类型：比较的是对象地址值
String类 : public boolean equals(String s) 比较两个字符串内容是否相同、区分大小写
代码 :
//equals练习：使用equals方法分别比较字符串常量、变量以及使用new创建的字符串对象

//equalsIgnoreCase练习：使用方法比较两个大小写不同的字符串
2.6 用户登录案例
案例需求 :
已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示
实现步骤 :
已知用户名和密码，定义两个字符串表示即可
键盘录入要登录的用户名和密码，用 Scanner 实现
拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。
字符串的内容比较，用equals() 方法实现
用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循
代码实现 :
//1.用户登录功能，实际上是用你录入的信息和系统中已存在的正确信息比较
//2.定义一对正确的用户名和密码
String usr = “admin”;
String pwd = “123”;
Scanner sc = new Scanner(System.in);
//3.开始键盘录入用户名和密码，有3次机会，重复录入，并且知道次数，使用for
for (int i = 0; i < 3; i++) {
System.out.println(“请输入用户名：”);
String username = sc.next();
System.out.println(“请输入密码：”);
String password = sc.next();
//4.有了键盘录入的信息，开始比较
if (username.equals(usr) && password.equals(pwd)) {
System.out.println(“登录成功”);
//登录成功，结束循环
break;
} else {
if (i2) {
System.out.println(“您今日登录次数已达上限，请明日再来”);
break;
}
System.out.println(“登录失败，您还有” + (2 - i) + “次机会”);
}
}
2.7 遍历字符串案例
案例需求 :
键盘录入一个字符串，使用程序实现在控制台遍历该字符串
实现步骤 :
键盘录入一个字符串，用 Scanner 实现
遍历字符串，首先要能够获取到字符串中的每一个字符, public char charAt(int index)：返回指定索引处的char值，字符串的索引也是从0开始的
遍历字符串，其次要能够获取到字符串的长度, public int length()：返回此字符串的长度
遍历打印
核心方法：
length()：这是返回字符串的长度，和数组的length不同，数组的那个是属性，这个是方法，要带小括号
charAt(int index)：返回字符串对应索引的字符，字符串索引也是从0开始
toCharArray()：返回的是字符串对应的字符数组
代码实现 :
//1.键盘录入一个字符串
System.out.println(“请输入：”);
Scanner sc = new Scanner(System.in);
String str = sc.next();
//2.先获取字符串长度，然后遍历，使用length()方法获取字符串长度
for (int i = 0; i < str.length(); i++) {
//3.要根据i的值获取字符串中的字符，推荐使用charAt方法
System.out.println(str.charAt(i));
}
System.out.println("=========================“);
//4.直接现将字符串转换成字符数组，推荐使用toCharArray
char[] chars = str.toCharArray();
//5.遍历字符数组
for (int i = 0; i < chars.length; i++) {
System.out.println(chars[i]);
}
2.8 统计字符次数案例
案例需求 :
键盘录入一个字符串，使用程序实现在控制台遍历该字符串
实现步骤 :
键盘录入一个字符串，用 Scanner 实现
将字符串拆分为字符数组 , public char[] toCharArray( )：将当前字符串拆分为字符数组并返回
遍历字符数
操作字符串中字符，一般情况下，先将字符串转换成字符数组，然后遍历操作
对于大写字母、小写字母、数字字符，这些字符对应的ASCII码表是连续的，判断范围可以直接用>=和<=
代码实现 :
//1.创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println(“请输入：”);
String str = sc.next();
//2.要统计字符串中大小写字符，数字字符的个数，你得先把字符串转换成数组
char[] chars = str.toCharArray();
//定义计数器，记录大小写字符和数字字符的个数
int bigCount = 0;
int smallCount = 0;
int numCount = 0;
//3.遍历字符数组
for (int i = 0; i < chars.length; i++) {
char c = chars[i];
//4.拿到字符之后，该判断这个字符是属于哪一个区间
if (c >= ‘0’ & c <= ‘9’) {
//5.统计小写字符出现的次数
numCount++;
} else if (c >= ‘a’ && c <= ‘z’) {
smallCount++;
//因为除了大小写字母和数字字符，还有其他字符，所以不能直接用else
} else if (c >= ‘A’ & c <= ‘Z’) {
bigCount++;
}
}
//6.循环结束，打印各个字符的个数
System.out.println(numCount);
System.out.println(smallCount);
System.out.println(bigCount);
2.9 手机号屏蔽-字符串截取
案例需求 :
以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽
​ 最终效果为：1561234
实现步骤 :
键盘录入一个字符串，用 Scanner 实现
截取字符串前三位
截取字符串后四位
将截取后的两个字符串，中间加上进行拼接，输出结果
substring(int index)：从字符串中截取，从index索引位置一直截取到最后
substring(int start,int end)：截取字符串，从start开始到end结束，但是含头不含尾
代码实现 :
//1.使用键盘录入
Scanner sc = new Scanner(System.in);
System.out.println(“请输入手机号：”);
String telPhone = sc.next();
//2.假设录入的字符串是13912341234，接下来开始针对这个字符串进行截取操作
//如果要替换中间四个数字，变为*，可以截取前三个和后四个，中间拼接****
//使用substring方法，截取前三个，调用方法截取后，调用方法的字符串不变，只是返回一个新的字符串
String start = telPhone.substring(0, 3);
//3.拿结尾的四个
String end = telPhone.substring(7);
//4.最后把头++尾进行拼接
System.out.println(start + "” + end);
2.10 敏感词替换-字符串替换
案例需求 :
键盘录入一个 字符串，如果字符串中包含（TMD），则使用***替换
实现步骤 :
键盘录入一个字符串，用 Scanner 实现
替换敏感词
String replace(CharSequence target, CharSequence replacement)
将当前字符串中的target内容，使用replacement进行替换，返回新的字符串

CharSquence：以后如果你看到方法的形式参数是它，说明就丢字符串进去就可以了。它是字符串的干爹。
输出结果
代码实现 :
//1.创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println(“请输入一句话：”);
String str = sc.next();
//2.把字符串中非法字符串使用替换，核心方法是replace
str = str.replace(“TMD”, "");
//3.打印替换后的字符串
System.out.println(str);
课后练习：
/**

• 需求：
• 1.键盘录入一个初始字符串，例如：I love heima，heiheimama love me
• 2.再使用键盘录入一个目标字符串，可以将初始字符串中的目标字符串删除
• 3.在控制台打印处理后的字符串内容，例如输入目标字符串：heima，控制台输出：
• I love ， love me
  */
  2.11 切割字符串
  案例需求 :
  以字符串的形式从键盘录入学生信息，例如：“张三 , 23”
  从该字符串中切割出有效数据,封装为Student学生对象
  实现步骤 :
  编写Student类，用于封装数据
  键盘录入一个字符串，用 Scanner 实现
  根据逗号切割字符串，得到（张三）（23）
  String[] split(String regex) ：根据传入的字符串作为规则进行切割
  注意：字符串regex如果是==.，请使用.==
  将切割后的内容存入字符串数组中，并将字符串数组返回
  从得到的字符串数组中取出元素内容，通过Student类的有参构造方法封装为对象
  调用对象getXxx方法，取出数据并打印。
  代码实现 :
  //1.键盘录入
  Scanner sc = new Scanner(System.in);
  System.out.println(“请输入：”);
  String str = sc.nextLine();
  //2.针对字符串做切割操作，以逗号座位分隔进行切割，按照题意，切出来有2个部分
  String[] strs = str.split(“,”);
  //结果返回的是一个字符串数组，说明切出来的是多个字符串，根据题意，切出来2个
  System.out.println(strs[0]);
  System.out.println(strs[1]);
  //3.一般情况下，在工作中，如果我们获取到了零散的数据，我们通常都会使用一个对象将其封装起来
  //专门用来封装数据的类，一般放在domain包下
  //创建学生对象，存储数据
  Student stu = new Student(strs[0], strs[1]);
  System.out.println(stu.getName() + “的年龄是” + stu.getAge());
  2.12 String方法小结
  String类的常用方法 :
  方法名 返回值类型 说明
  equals(Object anObject) boolean 比较字符串的内容，严格区分大小写
  equalsIgnoreCase(String anotherString) boolean 比较字符串的内容，忽略大小写
  length() int 返回此字符串的长度
  charAt(int index) char 返回指定索引处的 char 值
  toCharArray() char[] 将字符串拆分为字符数组后返回
  substring(int beginIndex, int endIndex) String 根据开始和结束索引进行截取，得到新的字符串（包含头，不包含尾）
  substring(int beginIndex) String 从传入的索引处截取，截取到末尾，得到新的字符串
  replace(CharSequence target, CharSequence replacement) String 使用新值，将字符串中的旧值替换，得到新的字符串
  split(String regex) String[] 根据传入的规则切割字符串，得到字符串数组

3. StringBuilder类
   3.1 StringBuilder类概述
   问题：
   1.使用StringBuilder有什么好处？
   2.如何获取1970-01-01 00:00:00到系统当前时间所经历的毫秒值？
   3.将一段代码抽取到方法中的快捷键是什么？
   概述 : StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的
   作用：提高字符串的操作效率
   System.currentTimeMillis()：获取1970年1月1日0时0分0秒到当前时间所经历过的毫秒值
   代码练习：
   //练习：分别用String和StringBuilder操作字符串，对比两者操作的时间
   public class Test01 {
   public static void main(String[] args) {
   //1.对比String和StringBuilder操作字符串消耗的时间
   method1();
   method2();
   }

   public static void method1() {
   //2.在操作字符串之前，获取系统当前时间的毫秒值
   long start = System.currentTimeMillis();
   String s = “”;
   for (int i = 0; i < 50000; i++) {
   s += i;
   }
   //操作之后，再去获取系统的毫秒值
   long end = System.currentTimeMillis();
   System.out.println(end - start);
   }

   public static void method2() {
   //2.在操作字符串之前，获取系统当前时间的毫秒值
   long start = System.currentTimeMillis();
   StringBuilder builder = new StringBuilder();
   for (int i = 0; i < 50000; i++) {
   builder = builder.append(i);
   }
   //操作之后，再去获取系统的毫秒值
   long end = System.currentTimeMillis();
   System.out.println(end - start);
   }
   }
   3.2 StringBuilder类的构造方法
   问题：
   1.打印用空参构造方法创建的StringBuilder对象，会有什么结果？
   2.打印用带参构造方法创建的StringBuilder对象，会有什么结果？
   常用的构造方法
   方法名 说明
   public StringBuilder() 创建一个空白可变字符串对象，不含有任何内容
   public StringBuilder(String str) 根据字符串的内容，来创建可变字符串对象
   示例代码
   public class StringBuilderDemo01 {
   public static void main(String[] args) {
   //public StringBuilder()：创建一个空白可变字符串对象，不含有任何内容
   StringBuilder sb = new StringBuilder();
   System.out.println(“sb:” + sb);
   System.out.println(“sb.length():” + sb.length());

    //public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象
    StringBuilder sb2 = new StringBuilder("hello");
    System.out.println("sb2:" + sb2);
    System.out.println("sb2.length():" + sb2.length());
   

   }
   }
   3.3 StringBuilder常用的成员方法
   问题：
   1.StringBuilder有哪几种常见的功能方法？
   2.StringBuilder对象是否可以添加不同的数据类型到容器中？
   3.StringBuilder的append方法返回对象自己，有什么作用？
   添加和反转方法
   方法名 说明
   public StringBuilder append(任意类型) 添加数据，并返回对象本身
   public StringBuilder reverse() 返回相反的字符序列
   public int length() 返回长度（字符出现的个数）
   public String toString() 把StringBuilder转换为String
   示例代码
   //需求：创建一个StringBuilder对象，分别调用几个成员方法，观察效果
   3.4 StringBuilder提高效率的原理
   原理图：
   字符串的加法拼接：
   

StringBuilder拼接：

StringBuilder类和String类的区别：
String类：内容是不可变的
StringBuilder类：内容是可变的
3.5 对称字符串案例：String和StringBuilder之间的相互转换
需求：键盘接收一个字符串，程序判断该字符串是否是对称字符串，并在控制台打印是或不是
思路：

代码实现：
//1.键盘录入
Scanner sc = new Scanner(System.in);
System.out.println(“请输入一个对称字符串：”);
String str = sc.nextLine();
//2.要判断一个字符串是不是对称字符串，把这个字符串反转一下，然后对比内容
//如果反转后的内容和反转前的内容一样，就属于对称字符串，比如123321
//要把字符串进行反转，这个时候我们就要想，字符串对象自己能不能做？
//查了api，发现不能做。这个时候要想，和字符串相关的工具还有哪些?想到了StringBuilder
//就去查api，发现了一个reverse方法可以做到
//3.通过构造方法把String变成StringBuilder
StringBuilder sb = new StringBuilder(str);
//4.调用reverse反转
sb.reverse();
//5.将反转后的字符串内容和原字符串内容比较
//注意，这里要保证都是字符串类型比较，所以sb要转成String
if (str.equals(sb.toString())) {
System.out.println(“是对称字符串”);
} else {
System.out.println(“不是对称字符串”);
}
StringBuilder转换为String
public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
String转换为StringBuilder
public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
3.6 StringBuilder拼接字符串案例
需求 :
定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，
并在控制台输出结果。例如，数组为int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]
实现步骤 :
定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。
返回值类型 String，参数列表 int[] arr
在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
调用方法，用一个变量接收结果
输出结果
代码实现 :
public class Test03 {
public static void main(String[] args) {
//1.静态初始化
int[] arr = {1, 2, 3};
String str = getStr(arr);
System.out.println(str);
}

public static String getStr(int[] arr) {
    //2.要操作字符串，就要创建StringBuilder对象，去做拼接
    //拼接的数据从数组中来，所以还要遍历数组
    StringBuilder sb = new StringBuilder("[");
    for (int i = 0; i < arr.length; i++) {
        //3.直接拼接不太好，因为字符串里面有特殊的格式，以中括号开始，而且是拼接数据之前
        //开始拼接数字，但是有区别，最后一个跟中括号的结束
        if (i == arr.length - 1) {
            //是最后一个元素，拼接的时候不能拼逗号
            sb.append(arr[i]).append("]");
        } else {
            sb.append(arr[i]).append(",");
        }
    }
    //4.方法返回的是字符串，要转一下
    return sb.toString();
}

}