黑马Java笔记第8讲—常用API

🎨 个人介绍

👉大家好，我是：知识的搬运工旺仔

👉认真分享技术，记录学习过程的点滴，如果我的分享能为你带来帮助，请支持我奥🍻

👉你的支持，是我每天更新的动力。

👉赞点：👍 留言：✍ 收藏：⭐

👉个人格言：想法一步一步的落实，才是你我前进最佳选择。

1. String类

1.1 String类概述

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

1.2 String类的特点

1. 字符串不可变，它们的值在创建后不能被更改
2. 虽然String的值不可变的，但是它们可以被共享
3. 字符串效果上相当于字符数组（char[])，但是，底层原理是字节数组（byte[]）

1.3 String 类的构造方法

1 ）常用的构造方法

2 ）代码实例

 public static void main(String[] args) {
     //创建一个空白字符串对象，不含有任何内容
     String s1 = new String();
     System.out.println(s1);
​
     //根据字符数组的内容，来创建字符串对象
     char[] chs = {'a','b','c'};
     String s2 = new String(chs);
​
     //根据字节数组的内容，来创建字符串对象
     byte[] bys = {97,98,99};
     String s3 = new String(bys);
     System.out.println("s3" + s3);
​
     //直接赋值的方式创建字符串对象，内容就是abc
     String s4 = "abc";
     System.out.println("s4" + s4);
 }   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1.4 创建字符串对象两种方式的区别

1 ）通过构造方法创建

通过new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容分相同，但是地址值不同

2 ）直接赋值方式创建

以”方式给出的字符串，只要字符串序列相同（顺序和大小写），JVM都会建立一个String对象，并在字符串池中维护

1.5 字符串的比较

1.5.1 “==” 号的作用

1. 比较基本数据类型：比较的是基本的值
2. 比较引用数据类型：比较的是对象地址值

1.5.2 equals 方法的作用

1. 方法介绍

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

2. 实例代码

public static void main(String[] args) {
    //构造方法的方式得到对象
    char[] chs = {'a','b','c'};
    String s1 = new String(chs);
    String s2 = new String(chs);
​
    //直接赋值的方式得到对象
    String s3 = "abc";
    String s4 = "abc";
​
    //比较字符串的地址是否相同
    System.out.println(s1==s2);
    System.out.println(s1==s3);
    System.out.println(s3==s4);
    System.out.println("----------");
​
    //比较字符串内容是否相同
    System.out.println(s1.equals(s2));
    System.out.println(s1.equals(s3));
    System.out.println(s3.equals(s4));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

1.6 用户登录的案例

1.6.1 案例需求

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

1.6.2 思路

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

2.6.2 代码实现

 public static void main(String[] args) {
     //已知用户名和密码，定义两个字符串表示即可
     String username = "itheima";
     String password1 = "czbk";
​
     //键盘输入类
     Scanner input = new Scanner(System.in);
​
     //用循环实现多次机会，这里的次数明确，采用fro循环实现，并登录成功，使用break结束循环
     for (int i = 0; i < 3; i++) {
         System.out.println("请输入用户名");
         String name = input.nextLine();
​
         System.out.println("请输入密码");
         String pwd = input.nextLine();
​
         // 进行判断
         if (name.equals(username) && pwd.equals(password1)) {
             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

1.7 变量字符串案例

1.7.1 案例需求

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

1.7.2 思路

1. 键盘录入一个字符串，用Scanner实现

2. 遍历字符串，首先要能够获取到字符串中的每一个字符

   public char charAt(int index) : 返回指定索引处的char值，字符串的索引也是从0开始的

3. 遍历字符串，其次要能够获取到字符串的长度

   • public int length()：返回此字符串的长度
   • 数组的长度：数组名.length
   • 字符串的长度：字符串对象.length()

4. 遍历字符串的通用格式

1.7.3 代码实现

 public static void main(String[] args) {
     //键盘录入类
     Scanner input = new Scanner(System.in);
​
     //录入字符串对象
     System.out.println("请输入一个字符串");
     String line = input.nextLine();
​
     for (int i = 0; i < line.length(); i++) {
         System.out.println(line.charAt(i));
     }
 }
1
2
3
4
5
6
7
8
9
10
11
12

1.8 统计字符串次数案例

1.8.1 案例需求

键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符串出现的次数（不考虑其他字符）

1.8.2 思路

1. 键盘录入一个字符串，用Scanner 实现

2. 要统计三种类型的字符个数，需定义三个统计变量，初始值为0

3. 遍历字符串，得到每个字符

4. 判断该字符属于那种类型，然后对应类型的统计量+1

   • 大写字母 ： ch>=‘A’ && ch<= ‘Z’
   • 小写字母：ch >= ‘a’ && ch<=‘z’
   • 数字： ch >=‘0’ && ch <=‘9’

5. 输出三种类型的字符串个数

1.8.3 代码实现

public static void main(String[] args) {
    //键盘录入一个字符串
    Scanner input = new Scanner(System.in);
​
    System.out.println("请输入一个字符串");
    String line = input.nextLine();
​
    //要统计三种类型字符串个数，需定义三个通奸变量
    int bigCount = 0;
    int smallCount = 0;
    int numberCount = 0;
​
    //遍历字符串，得到每一个字符串
    for (int i = 0; i < line.length(); i++) {
        char ch = line.charAt(i);
​
        //进行判断
        if (ch >= 'A' && ch <= 'Z') {
            bigCount++;
        } else if (ch >= 'a' && ch <= 'z') {
            smallCount++;
        } else if (ch >= '0' && ch <= '9') {
            numberCount++;
        }
    }
​
    //输出三种类型的字符个数
    System.out.println("大写字母："+bigCount+"个");
    System.out.println("小写字母："+smallCount+"个");
    System.out.println("数字："+numberCount+"个");
}
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

1.9 字符串拼接案例

1.9.1 案例需求

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

1.9.2 思路

1. 定义一个int 类型的数组，把静态初始化完成数组元素的初始化

2. 定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回

   • 返回值类型 String ,参数列表 int[] arr

3. 在方法中遍历数组，按照要求进行拼接

4. 调用方法，用一个变量接收结果

5. 输出结果

1.9.3 代码实现

 public static void main(String[] args) {
     //定义一个int 类型的数组 ，用静态初始化完成数组元素的初始化
     int[] arr = {1,2,3};
​
     //调用方法，用一个变量接收结果
     String s = arrayToString(arr);
​
     //输出结果
     System.out.println("s :" + s);
 }
​
private static String arrayToString(int[] arr) {
    //使用StringBuilder 进行字符串的拼接
    StringBuilder s = new StringBuilder();
​
    s.append("[");
​
    for (int i = 0; i < arr.length; i++) {
        if(i == arr.length-1) {
            s.append(arr[i]);
        }else {
            s.append(arr[i]).append(",");
        }
    }
    s.append("]");
    return s.toString();
}
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

1.10 字符串反转案例

1.10.1 案例需求

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

1.10.2 思路

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

1.10.3 代码实现

public static void main(String[] args) {
    //键盘录入一个字符串，用Scanner 实现
    Scanner input = new Scanner(System.in);
​
    System.out.println("请输入一个字符串：");
    String line = input.nextLine();
​
    //调用方法，用一个变量接收
    String s = recerse(line);
​
    //输出结果
    System.out.println("s:" + s);
}
​
private static String recerse(String line) {
    StringBuilder s = new StringBuilder();
​
    for (int i = line.length() - 1; i >= 0; i--) {
        s.append(line.charAt(i));
    }
​
    return s.toString();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

1.11 帮助文档查看String 常用方法

2. StringBuilder 类

3.1 StringBuilder 类概述

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

3.2 StringBuilder 类和String 类的区别

1. String 类：内容是不可变的
2. StringBuilder 类：内容是可变的

3.3 StringBuilder 类的构造方法

1 ）常用的构造方法

2 ）实例代码

public static void main(String[] args) {
    //创建一个空白可变的字符串，不含任何内容
    StringBuilder sb = new StringBuilder();
    System.out.println("sb:" + sb);
    System.out.println("sb.length(): " + sb.length());

    //根据字符内容，来创建可变字符对象
    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

2.4 StringBuilder 类添加和反转

1 ）添加和反转的方法

2 ）实例代码

public static void main(String[] args) {
    // 创建对象
    StringBuilder sb = new StringBuilder();

    //链式编程
    sb.append("hello").append("world").append("java").append(100);

    System.out.println("sb: " + sb);

    // 返回相反的字符串序列
    sb.reverse();
    System.out.println("sb:"+ sb);

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

2.5 StringBuilder 和 String相互转换

1 ）StringBuilder 转化为 String

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

2 ）String 转换为 StringBuilder

public StringBuilde(String s) : 通过构造方法就可以实现String 转换为 StringBuilder

3 ）代码实现

public static void main(String[] args) {
    //将String 转化为 String
    StringBuilder sb = new StringBuilder();
    sb.append("hello");

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

    // 将String 转化为 StringBuilder
    StringBuilder sb1 = new StringBuilder(s);

    System.out.println("sb1； " + sb1);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

2.6 字符串反转升级案例

2.6.1 案例需求

1.10.1 案例需求

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

1.10.2 思路

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

1.10.3 代码实现

public static void main(String[] args) {
    //键盘录入一个字符串
    Scanner input = new Scanner(System.in);

    System.out.println("请输入一个字符串");
    String line = input.nextLine();

    //调用一个方法，实现字符串的反转
    String s = myReverse(line);

    System.out.println("s :" + s);
}

private static String myReverse(String line) {
    return new StringBuffer(line).reverse().toString();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

🎈看完了不妨给我点个赞吧，👉你的支持，是我每天更新的动力…