常用API & String & StringBuilder

思维导图 (opens new window)

# 常用API

# 1 API概述（理解）

API (Application Programming Interface) ：应用程序编程接口
java中的API

指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。

# 2 如何使用API帮助文档 :

在线：官网在线官方文档（全英）：https://docs.oracle.com/javase/8/docs/api/index.html

本地：（推荐）jdk9 api下载链接：https://pan.baidu.com/s/1dpI7L8gY1Rf1QNdWv62STg 提取码：x7b3

打开帮助文档
找到索引选项卡中的输入框
在输入框中输入Random
看类在哪个包下
看类的描述
看构造方法
看成员方法

# 2.1 键盘录入字符串

Scanner类 :

next() : 遇到了空格, 就不再录入数据了 , 结束标记: 空格, tab键

nextLine() : 可以将数据完整的接收过来 , 结束标记: 回车换行符

代码实现 :

package com.itheima.api;

import java.util.Scanner;

public class Demo1Scanner {
    /*
        next() : 遇到了空格, 就不再录入数据了

                结束标记: 空格, tab键

        nextLine() : 可以将数据完整的接收过来

                结束标记: 回车换行符
     */
    public static void main(String[] args) {
        // 1. 创建Scanner对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        // 2. 调用nextLine方法接收字符串
        // ctrl + alt + v : 快速生成方法的返回值
        String s = sc.nextLine();

        System.out.println(s);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package com.itheima.api;

import java.util.Scanner;

public class Demo2Scanner {
    /*
        nextInt和nextLine方法配合使用的时候, nextLine方法就没有键盘录入的机会了

        建议: 今后键盘录入数据的时候, 如果是字符串和整数一起接受, 建议使用next方法接受字符串.
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入整数:");
        int num = sc.nextInt(); // 10 + 回车换行
        System.out.println("请输入字符串:");
        String s = sc.nextLine();


        System.out.println(num);
        System.out.println(s);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 2. String类

# 2.1 String概述（理解）

String 类在 java.lang 包下，所以使用的时候不需要导包
String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象

# 2.2 String类的特点

字符串不可变，它们的值在创建后不能被更改
虽然String的值是不可变的，但是它们可以被共享
字符串效果上相当于字符串数组(char[])，但是底层原理是字节数组(byte[])。【JDK8及以前是字符数组，JDK9及一行是字节数组】

# 2.3 String类的构造方法

# 2.3.1 常用的构造方法

1590939947722

# 2.3.2 示例代码

package com.itheima.string;

public class Demo2StringConstructor {
    /*
        String类常见构造方法:

            public String() : 创建一个空白字符串对象，不含有任何内容
            public String(char[] chs) : 根据字符数组的内容，来创建字符串对象
            public String(String original) : 根据传入的字符串内容，来创建字符串对象
            String s = “abc”;  直接赋值的方式创建字符串对象，内容就是abc

         注意:
                String这个类比较特殊, 打印其对象名的时候, 不会出现内存地址
                而是该对象所记录的真实内容.

                面向对象-继承, Object类
     */
    public static void main(String[] args) {
        // public String() : 创建一个空白字符串对象，不含有任何内容
        String s1 = new String();
        System.out.println(s1);

        // public String(char[] chs) : 根据字符数组的内容，来创建字符串对象
        char[] chs = {'a','b','c'};
        String s2 = new String(chs);
        System.out.println(s2);

        // public String(String original) : 根据传入的字符串内容，来创建字符串对象
        String s3 = new String("123");
        System.out.println(s3);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# 2.4 创建字符串对象的两种方式的区别（理解）

通过构造方法创建

通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同
```
char chs = {'a', 'b', 'c'};
String s1 = new String(chs);
String s2 = new String(chs);
```
1
2
3
上面的代码中，JVM会首先创建一个字符数组，然后每一次new的时候都会有一个新的地址，只不过s1和s2参考的字符串是相同的。
直接赋值方式创建

以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护
```
String s3 = "abc";
String s4 = "abc";
```
1
2
上面的代码中，针对第一行代码，JVM会建立一个String对象放在字符串池中，并给s3参考；第二行则让s4直接参考字符串池中的String对象，也就是说它们本质是同一个对象。

# 2.5 字符串的比较

# 2.5.1 字符串的比较

用 == 做比较

基本数据类型：比较的是具体的数据值
引用数据类型：比较的是对象地址值

字符串是对象，比较字符串的内容是否相同不能用 == ，而是用另一个方法：equals()

public boolean equals(String s) 比较两个字符串内容是否相同，区分大小写
public boolean equalsIgnoreCase(String s) 比较两个字符串内容是否相同，不区分大小写

代码 :

public class Demo1Equals {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "ABC";
        String s3 = "abc";

        // equals : 比较字符串内容, 区分大小写
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s3));

        // equalsIgnoreCase : 比较字符串内容, 忽略大小写
        System.out.println(s1.equalsIgnoreCase(s2));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 2.6 用户登录案例（应用）

# 2.6.1 案例需求 :

已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示

# 2.6.2 实现步骤 :

已知用户名和密码，定义两个字符串表示即可
键盘录入要登录的用户名和密码，用 Scanner 实现
拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。
字符串的内容比较，用 equals() 方法实现
用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环

# 2.6.3 代码实现 :

package day08;

import java.util.Scanner;
/*案例需求:
    已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示
  实现步骤:
    1. 已知用户名和密码，定义两个字符串表示即可
	2. 键盘录入要登录的用户名和密码，用 Scanner 实现
	3. 拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。
	4. 字符串的内容比较，用 equals() 方法实现
	5. 用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环
*/
public class StringDemo2 {
    public static void main(String[] args) {
        // 已知用户名和密码，定义两个字符串表示即可
        String username = "admin";
        String password = "123456";
        // 用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环
        for (int i = 0; i < 3; i++) {
            //键盘录入要登录的用户名和密码，用 Scanner 实现
            Scanner sc = new Scanner(System.in);
            //拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。
            System.out.println("请输入用户名");
            String name = sc.nextLine();
            System.out.println("请输入密码");
            String pwd = sc.nextLine();
            //字符串的内容比较，用 equals() 方法实现
            if (name.equals(username) && pwd.equals(password)) {
                System.out.println("登录成功");
                break;
            } else {
                if (2 - i == 0) {
                    System.out.println("你的账户被锁定，请与管理员联系");
                } else {
                    System.out.println("登录失败，你还有" + (2 - i) + "次机会");
                }
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

# 2.7 遍历字符串案例（应用）

# 2.7.1 案例需求 :

键盘录入一个字符串，使用程序实现在控制台遍历该字符串

# 2.7.2 实现步骤 :

键盘录入一个字符串，用 Scanner 实现
遍历字符串，首先要能够获取到字符串中的每一个字符, public char charAt(int index)：返回指定索引处的char值，字符串的索引也是从0开始的
遍历字符串，其次要能够获取到字符串的长度, public int length()：返回此字符串的长度
遍历打印

# 2.7.3 代码实现 :

package day08;

import java.util.Scanner;

/*
        需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串

        思路：
        1. 键盘录入一个字符串，用 Scanner 实现
        2. 遍历字符串，首先要能够获取到字符串中的每一个字符
            public char charAt(int index)：返回指定索引处的char值，字符串的索引也是从0开始的
        3. 遍历字符串，其次要能够获取到字符串的长度
            public int length()：返回此字符串的长度
        4. 遍历打印
9
     */
public class StringDemo4 {
    public static void main(String[] args) {
        //1.键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = sc.nextLine();
        //2.遍历字符串，首先要能够获取到字符串中的每一个字符
        //public char charAt(int index)：返回指定索引处的char值，字符串的索引也是从0开始的
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            System.out.println(c);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 2.8 统计字符次数案例（应用）

# 2.8.1 案例需求 :

键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数，和总的字符数量。

# 2.8.2 实现步骤 :

键盘录入一个字符串，用 Scanner 实现
要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
将字符串拆分为字符数组，总字符数为数组长度。 public char[] toCharArray( )：将当前字符串拆分为字符数组并返回
遍历字符数组，判断该字符属于哪种类型，然后对应类型的统计变量+1 要判断一个字符属于大写字母，小写字母，还是数字，直接判断该字符是否在对应的范围即可大写字母：ch>='A' && ch<='Z' 小写字母： ch>='a' && ch<='z' 数字： ch>='0' && ch<='9'
输出结果

# 2.8.3 代码实现 :

package day08;

import java.util.Scanner;
/*
   需求：键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数，和总的字符数量。
   思路：
   1. 键盘录入一个字符串，用 Scanner 实现
   2. 要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
   3. 将字符串拆分为字符数组，总字符数为数组长度。
      public char[] toCharArray( )：将当前字符串拆分为字符数组并返回
   4. 遍历字符数组，判断该字符属于哪种类型，然后对应类型的统计变量+1
        要判断一个字符属于大写字母，小写字母，还是数字，直接判断该字符是否在对应的范围即可
        大写字母：ch>='A' && ch<='Z'
        小写字母： ch>='a' && ch<='z'
        数字： ch>='0' && ch<='9'
    5. 输出结果
*/
public class StringDemo5 {
    public static void main(String[] args) {
        //1.键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = sc.nextLine();
        //2.定义三个统计变量，初始值都为0
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        //3.将字符串拆分为字符数组，总字符数为数组长度。
        char[] chars = s.toCharArray();
        int sum = chars.length;
        //4.遍历字符数组
        for (int i = 0; i < chars.length; i++) {
            if (chars[i] >= 'A' && chars[i] <= 'Z') {
                bigCount++;
            } else if (chars[i] >= 'a' && chars[i] <= 'z') {
                smallCount++;
            } else if (chars[i] >= '0' && chars[i] <= '9') {
                numberCount++;
            }
        }
        System.out.println("大写字母有" + bigCount + "个");
        System.out.println("小写字母有" + smallCount + "个");
        System.out.println("数字有" + numberCount + "个");
        System.out.println("一共有" + sum + "个字符");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

# 2.9 字符串截取-手机号屏蔽

# 2.9.1 案例需求

以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽最终效果为：156****1234

# 2.9.2 实现步骤

键盘录入一个字符串，用 Scanner 实现
截取字符串前三位

public String substring(int beginIndex, int endIndex) ：返回该字符串的子字符串。子字符串从beginIndex开始，并扩展到索引号为endIndex - 1的字符。因此子串的长度为endIndex-beginIndex 。
截取字符串后四位

public String substring(int beginIndex)：返回该字符串的子符串，以索引beginIndex处的字符开头并拓展到字符串的末尾。
将截取后的两个字符串，中间加上****进行拼接，输出结果

# 2.9.3 代码实现

package day08;

import java.util.Scanner;
/*
    需求：以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽，最终效果为：156****1234
    思路：
    1. 键盘录入一个字符串，用 Scanner 实现
    2. 截取字符串前三位
       public String substring(int beginIndex, int endIndex) ：返回该字符串的子字符串。 子字符串从beginIndex开始，并扩展到索引号为endIndex - 1的字符。
       因此子串的长度为endIndex-beginIndex 。
    3. 截取字符串后四位
       public String substring(int beginIndex)：返回该字符串的子符串，以索引beginIndex处的字符开头并拓展到字符串的末尾。
    4. 将截取后的两个字符串，中间加上****进行拼接，输出结果
 */
public class StringDemo6 {
    public static void main(String[] args) {
        //1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入手机号：");
        String phone = sc.nextLine();
        //2. 截取字符串前三位
        //   public String substring(int beginIndex, int endIndex) ：返回该字符串的子字符串。 子字符串从beginIndex开始，并扩展到索引号为endIndex - 1的字符。
        String start = phone.substring(0, 3);
        //3. 截取字符串后四位
        //   public String substring(int beginIndex)：返回该字符串的子符串，以索引beginIndex处的字符开头并拓展到字符串的末尾。
        String end = phone.substring(7);
        //4. 将截取后的两个字符串，中间加上****进行拼接，输出结果
        System.out.println(start + "****" + end);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 2.10 字符串替换-敏感词替换

# 2.10.1 案例需求

键盘录入一个字符串，如果字符串中包含（TMD），则使用***替换

# 2.10.2 实现步骤

键盘录入一个字符串，用 Scanner 实现
替换敏感词 String replace(CharSequence target, CharSequence replacement)：将当前字符串中的target内容，使用replacement进行替换，返回新的字符串
输出结果

# 2.10.3 代码实现

package day08;

import java.util.Scanner;

/*
    需求：键盘录入一个 字符串，如果字符串中包含（TMD），则使用***替换
    思路：
    1. 键盘录入一个字符串，用 Scanner 实现
    2. 替换敏感词
       String replace(CharSequence target, CharSequence replacement)：将当前字符串中的target内容，使用replacement进行替换，返回新的字符串
    3. 输出结果
 */
public class StringDemo7 {
    public static void main(String[] args) {
        //1.键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = sc.nextLine();
        //2.替换敏感词 String replace(CharSequence target, CharSequence replacement)
        String result = s.replace("TMD", "***");
        //3.输出结果
        System.out.println(result);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 2.11 切割字符串

# 2.11.1 案例需求

以字符串的形式从键盘录入学生信息，例如：“张三 , 23”

从该字符串中切割出有效数据,封装为Student学生对象

# 2.11.2 实现步骤

编写Student类，用于封装数据
键盘录入一个字符串，用 Scanner 实现
根据逗号切割字符串，得到（张三）（23）

String[] split(String regex) ：根据传入的字符串作为规则进行切割将切割后的内容存入字符串数组中，并将字符串数组返回
从得到的字符串数组中取出元素内容，通过Student类的有参构造方法封装为对象
调用对象getXxx方法，取出数据并打印。

# 2.11.3 代码实现

Student类：

public class Student {
    //成员变量
    private String name;
    private int age;

    //带参构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //set方法
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //get方法
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println("姓名为" + name + "，年龄为" + age);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

主类：

package day08;

import day07.Student;

import java.util.Scanner;
/*
     需求：以字符串的形式从键盘录入学生信息，例如：“张三 , 23”
            从该字符串中切割出有效数据,封装为Student学生对象
     思路：
        1. 编写Student类，用于封装数据
        2. 键盘录入一个字符串，用 Scanner 实现
        3. 根据逗号切割字符串，得到（张三）（23）
           String[] split(String regex) ：根据传入的字符串作为规则进行切割
           将切割后的内容存入字符串数组中，并将字符串数组返回
        4. 从得到的字符串数组中取出元素内容，通过Student类的有参构造方法封装为对象
        5. 打印数据。
 */
public class StringDemo8 {
    public static void main(String[] args) {
        //1.键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生信息，格式为[姓名，年龄]");
        String stuInfo = sc.nextLine();
        //2.根据逗号切割字符串，得到（张三）（23）String[] split(String regex)
        String[] sArr = stuInfo.split("，");
        System.out.println(sArr[0]);
        System.out.println(sArr[1]);
        //3.从得到的字符串数组中取出元素内容，通过Student类的有参构造方法封装为对象
        //使用Integer.parseInt()方法将字符串String转为int
        Student stu = new Student(sArr[0], Integer.parseInt(sArr[1]));
        //4.调用对象getXxx方法，取出数据并打印。
        stu.show();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# 2.12 字符串拼接案例（应用）

# 2.12.1 案例需求

定义一个方法，把int数组中的数据按照指定的格式拼接成一共字符串返回，调用该方法，并在控制台输出结果。例如，数组为int[] arr = {1,2,3};，执行方法后的输出结果为：[1,2,3]

# 2.12.2 实现步骤

定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。返回值类型 String，参数列表 int[] arr
在方法中遍历数组，按照要求进行拼接
调用方法，用一个变量接收结果
输出结果

# 2.12.3 代码实现

package day08;
/*
需求：
    定义一个方法，把int数组中的数据按照指定的格式拼接成一共字符串返回，调用该方法，并在控制台输出结果。例如，数组为int[] arr = {1,2,3};，执行方法后的输出结果为：[1,2,3]
思路：
    1. 定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
    2. 定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。 返回值类型 String，参数列表 int[] arr
    3. 在方法中遍历数组，按照要求进行拼接
    4. 调用方法，用一个变量接收结果
    5. 输出结果
 */
public class StringDemo9 {
    public static void main(String[] args) {
        //1. 定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        int[] arr = {1,2,3};
        //4.调用方法，用一个变量接收结果
        String s = arrayToString(arr);
        //5.输出结果
        System.out.println(s);
    }
    //2. 定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。 返回值类型 String，参数列表 int[] arr
    public static String arrayToString(int[] arr) {
        String s = "";
        //3. 在方法中遍历数组，按照要求进行拼接
        s += "[";
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length -1) {
                s += arr[i];
            } else {
                s += arr[i] + ",";
            }
        }
        s += "]";
        return s;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# 2.13 字符串反转案例（应用）

# 2.13.1 案例需求

定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果。

# 2.13.2 实现步骤

键盘录入一个字符串，用 Scanner 实现
定义一个方法，实现字符串反转。返回值类型 String，参数 String s
在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
调用方法，用一个变量接收结果
输出结果

# 2.13.3 代码实现

package day08;

import java.util.Scanner;

/*
需求：定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果。
思路：
    1. 键盘录入一个字符串，用 Scanner 实现
    2. 定义一个方法，实现字符串反转。返回值类型 String，参数 String s
    3. 在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
    4. 调用方法，用一个变量接收结果
    5. 输出结果
 */
public class StringDemo10 {
    public static void main(String[] args) {
        //1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String s = sc.nextLine();
        //4. 调用方法，用一个变量接收结果
        String result = reverse(s);
        //5.输出结果
        System.out.println(result);
    }
    //2. 定义一个方法，实现字符串反转。返回值类型 String，参数 String s
    public static String reverse(String s){
        String result = "";
        //在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
        for (int i = s.length() - 1; i >= 0; i--) {
            result += s.charAt(i);
        }
        return result;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# 2.14 判断字符串是否为回文

# 2.14.1 需求

键盘录入一个字符串，判断一个字符串是否为对称字符串（回文）

# 2.14.2 步骤

1.创建一个键盘录入对象，接收一个字符串数据s1 2.定义一个字符串s2用于接收反转后的字符串 3.将字符串逆向遍历，把反转后的字符串保存到s2中 4.把s1和s2进行比较

# 2.14.3 代码实现

import java.util.Scanner;

/*
    键盘录入一个字符串，判断一个字符串是否为对称字符串（回文）

    步骤：
    1.创建一个键盘录入对象，接收一个字符串数据s1
    2.定义一个字符串s2用于接收反转后的字符串
    3.将字符串逆向遍历，把反转后的字符串保存到s2中
    4.把s1和s2进行比较
 */
public class StringDemo11 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String s1 = sc.nextLine();

        //定义一个字符串s2用于接收反转后的字符串
        String s2 = new String();
        //将字符串逆向遍历，把反转后的字符串保存到s2中
        for (int i = s1.length() - 1; i >= 0; i--) {
            char c = s1.charAt(i);
            s2 += c;
        }

        if (s1.equals(s2)) {
            System.out.println(s1 + " 是对称字符串");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 2.15 String方法小结

String类的常用方法 :

public boolean equals(Object anObject) 比较字符串的内容，严格区分大小写
public boolean equalsIgnoreCase(String anotherString) 比较字符串的内容，忽略大小写
public int length() 返回此字符串的长度
public char charAt(int index) 返回指定索引处的 char 值
public char[] toCharArray() 将字符串拆分为字符数组后返回
public String substring(int beginIndex, int endIndex) 根据开始和结束索引进行截取，得到新的字符串（包含头，不包含尾）
public String substring(int beginIndex) 从传入的索引处截取，截取到末尾，得到新的字符串
public String replace(CharSequence target, CharSequence replacement) 使用新值，将字符串中的旧值替换，得到新的字符串
public String[] split(String regex) 根据传入的规则切割字符串，得到字符串数组

# 3 StringBuilder类

# 3.1 StringBuilder类概述

StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的。

# 3.2 StringBuilder类和String类的区别

String类内容是不可变的

StringBuilder类内容是可变的
String在拼接字符串的时候会创建大量的对象，会造成内存空间的浪费。

StringBuilder在拼接的过程中不会创建新的对象，更加节省空间。

# 3.3StringBuilder类的构造方法

常用的构造方法

方法名	说明
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());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

# 3.4 StringBuilder常用的成员方法

添加和反转方法

方法名说明

public StringBuilder append(任意类型) 添加数据，并返回对象本身

public StringBuilder reverse() 返回相反的字符序列
示例代码

方法名	说明
public StringBuilder append(任意类型)	添加数据，并返回对象本身
public StringBuilder reverse()	返回相反的字符序列

package day08;
/*
    StringBuilder 的添加和反转方法：
        public StringBuilder append(任意类型) ：添加数据，并返回数据本身
        public StringBuilder reserve() : 返回相反的字符序列
 */
public class StringBuilderDemo1 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();

        //public StringBuilder append(任意类型) ：添加数据，并返回数据本身
        //sb.append("hello");
        //sb.append("world");
        //sb.append("java");
        //sb.append(100);

        //链式编程
        sb.append("hello").append("world").append("java").append(100);
        System.out.println("sb:" + sb);

        //public StringBuilder reserve() : 返回相反的字符序列
        sb.reverse();
        System.out.println("sb的反转:" + sb);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 3.5 StringBuilder和String相互转换（应用）

StringBuilder转换为String

public String toString()：通过 toString() 就可以实现把StringBuilder 转换为 String
String转换为StringBuilder

public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
示例代码

package day08;
/*
public String toString()：通过 toString() 就可以实现把StringBuilder 转换为 String
public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
 */
public class StringBuilderDemo2 {
    public static void main(String[] args) {
        //StringBuilder 转换 String
        StringBuilder sb = new StringBuilder();
        sb.append("hello");

        String s = sb.toString();
        System.out.println(s);

        //String 转换 StringBuilder
        String s1 = "hello";
        StringBuilder sb2 = new StringBuilder(s1);
        System.out.println(sb2);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 3.6 StringBuilder拼接字符串升级版（应用）

# 3.6.1 案例需求

定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。例如，数组为int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]

# 3.6.2 实现步骤

定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。返回值类型 String，参数列表 int[] arr
在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
调用方法，用一个变量接收结果
输出结果

# 3.6.3 代码实现

package day08;
/*
    思路：
        1:定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        2:定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。
          返回值类型 String，参数列表 int[] arr
        3:在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
        4:调用方法，用一个变量接收结果
        5:输出结果
 */
public class StringBuilderDemo3 {
    public static void main(String[] args) {
        //1:定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        int[] arr = {1,2,3};
        //4:调用方法，用一个变量接收结果
        String s = arrayToString(arr);
        //5:输出结果
        System.out.println(s);
    }
    //2:定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。返回值类型 String，参数列表 int[] arr
    public static String arrayToString(int[] arr) {
        //3:在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append("，");
            }
        }
        sb.append("]");
        String s = sb.toString();
        return s;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# 3.7 StringBuilder字符串反转升级版（应用）

# 3.7.1 案例需求

定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果。例如，键盘录入abc，输出cba

# 3.7.2 实现步骤

键盘录入一个字符串，用 Scanner 实现
定义一个方法，实现字符串反转。返回值类型 String，参数 String s
在方法中用StringBuilder实现字符串的反转，并把结果转成String返回
调用方法，用一个变量接收结果
输出结果

# 3.7.3 代码实现

package day08;

import java.util.Scanner;

/*
思路：
    1. 键盘录入一个字符串，用 Scanner 实现
    2. 定义一个方法，实现字符串反转。返回值类型 String，参数 String s
    3. 在方法中用StringBuilder实现字符串的反转，并把结果转成String返回
    4. 调用方法，用一个变量接收结果
    5. 输出结果
 */
public class StringBuilderDemo4 {
    public static void main(String[] args) {
        //1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = sc.nextLine();
        //4. 调用方法，用一个变量接收结果
        String result = reserve(s);
        //5. 输出结果
        System.out.println(result);
    }
    //2. 定义一个方法，实现字符串反转。返回值类型 String，参数 String s
    public static String reserve(String s) {
        //3. 在方法中用StringBuilder实现字符串的反转，并把结果转成String返回
        StringBuilder sb = new StringBuilder(s);
        sb.reverse();
        String result = sb.toString();
        return result;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# 3.8 判断字符串是否为回文（StringBuilder升级版）

# 3.8.1 需求

键盘录入一个字符串，判断一个字符串是否为回文

# 3.8.2 步骤

创建一个键盘录入对象，接收一个字符串数据
把String类型转换为StringBuilder
通过StringBuilder的反转方法，实现内容的反转
再把反转之后的结果，转化为String
把一开始的字符串和反转之后的字符串进行比较

# 3.8.3 代码实现

import java.util.Scanner;
/*
    键盘录入一个字符串，判断一个字符串是否为对称字符串（回文）
        上海自来水来自海上

    步骤：
    1.创建一个键盘录入对象，接收一个字符串数据
    2.把String类型转换为StringBuilder
    3.通过StringBuilder的反转方法，实现内容的反转
    4.再把反转之后的结果，转化为String
    5.把一开始的字符串和反转之后的字符串进行比较
 */
public class StringBuilderDemo5 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String s1 = sc.nextLine();
        StringBuilder sb = new StringBuilder(s1);
        sb.reverse();
        String s2 = sb.toString();
        if (s1.equals(s2)) {
            System.out.println(s1 + " 是对称字符串");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 3.9 StringBuilder常用方法（记忆）

public StringBuilder append(任意类型) ：添加数据，并返回对象本身
public StringBuilder reserve() ：返回相反的字符序列
public int length() ：返回长度，实际存储值
public String toString() ：通过toString()就可以实现把StringBuilder转换为String

在Github中编辑

上次更新: 2021/11/29, 11:19:50

← 面向对象 ArrayList集合&学生管理系统→