JAVA零基础学习3（Scanner类，字符串，StringBuilder，StringJoinder，ArrayList成员方法）

Scanner类输入

在 Java 中，你可以使用 Scanner 类从控制台读取输入字符串。以下是一个简单的示例代码，展示如何读取和输出一个字符串：

示例代码

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 创建一个 Scanner 对象，用于从控制台读取输入
        Scanner scanner = new Scanner(System.in);

        // 提示用户输入一个字符串
        System.out.print("请输入一个字符串: ");

        // 读取用户输入的字符串
        String inputString = scanner.nextLine();

        // 输出读取到的字符串
        System.out.println("你输入的字符串是: " + inputString);

        // 关闭 Scanner 对象
        scanner.close();
    }
}

代码解释

1. 导入 Scanner 类：

   import java.util.Scanner;
   

   这行代码导入了 Scanner 类，使你可以使用它来读取输入。

2. 创建 Scanner 对象：

   Scanner scanner = new Scanner(System.in);
   

   Scanner 对象用来读取控制台输入。System.in 表示标准输入流（即控制台输入）。

3. 提示用户输入字符串：

   System.out.print("请输入一个字符串: ");
   

   这行代码在控制台上输出提示信息，提示用户输入字符串。

4. 读取用户输入的字符串：

   String inputString = scanner.nextLine();
   

   scanner.nextLine() 方法读取用户输入的一整行字符串，并将其存储在变量 inputString 中。

5. 输出读取到的字符串：

   System.out.println("你输入的字符串是: " + inputString);
   

   这行代码将用户输入的字符串输出到控制台。

6. 关闭 Scanner 对象：

   scanner.close();
   

   关闭 Scanner 对象，释放相关的资源。

完整代码

以下是完整的示例代码，你可以直接运行它来测试：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 创建一个 Scanner 对象，用于从控制台读取输入
        Scanner scanner = new Scanner(System.in);

        // 提示用户输入一个字符串
        System.out.print("请输入一个字符串: ");

        // 读取用户输入的字符串
        String inputString = scanner.nextLine();

        // 输出读取到的字符串
        System.out.println("你输入的字符串是: " + inputString);

        // 关闭 Scanner 对象
        scanner.close();
    }
}

运行这段代码后，程序会提示你输入一个字符串，并在你按下回车键后输出你输入的字符串。

Scanner 类的 nextLine() 方法用于读取用户输入的一整行字符串，并将其存储在变量中。不过，Scanner 类不仅限于读取字符串，还可以读取多种不同类型的输入。以下是一些常见的用法及其解释：

1. 读取字符串

使用 nextLine() 方法读取整行输入作为字符串。

Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个字符串: ");
String inputString = scanner.nextLine();
System.out.println("你输入的字符串是: " + inputString);

2. 读取整数

使用 nextInt() 方法读取一个整数。

Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数: ");
int inputInt = scanner.nextInt();
System.out.println("你输入的整数是: " + inputInt);

3. 读取浮点数

使用 nextFloat() 或 nextDouble() 方法读取浮点数。

Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个浮点数: ");
float inputFloat = scanner.nextFloat();
System.out.println("你输入的浮点数是: " + inputFloat);

System.out.print("请输入一个双精度浮点数: ");
double inputDouble = scanner.nextDouble();
System.out.println("你输入的双精度浮点数是: " + inputDouble);

4. 读取布尔值

使用 nextBoolean() 方法读取布尔值。

Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个布尔值 (true/false): ");
boolean inputBoolean = scanner.nextBoolean();
System.out.println("你输入的布尔值是: " + inputBoolean);

5. 读取单个单词

使用 next() 方法读取单个单词（以空格为分隔符）。

Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个单词: ");
String inputWord = scanner.next();
System.out.println("你输入的单词是: " + inputWord);

6. 读取长整型数

使用 nextLong() 方法读取长整型数。

Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个长整型数: ");
long inputLong = scanner.nextLong();
System.out.println("你输入的长整型数是: " + inputLong);

7. 读取短整型数

使用 nextShort() 方法读取短整型数。

Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个短整型数: ");
short inputShort = scanner.nextShort();
System.out.println("你输入的短整型数是: " + inputShort);

8. 读取字节数

使用 nextByte() 方法读取字节数。

Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个字节数: ");
byte inputByte = scanner.nextByte();
System.out.println("你输入的字节数是: " + inputByte);

注意事项

• 捕获异常：当用户输入的数据类型与预期不符时，会抛出 InputMismatchException。可以使用 try-catch 块来捕获并处理这种异常。

Scanner scanner = new Scanner(System.in);
try {
    System.out.print("请输入一个整数: ");
    int inputInt = scanner.nextInt();
    System.out.println("你输入的整数是: " + inputInt);
} catch (InputMismatchException e) {
    System.out.println("输入的不是整数！");
}

• 清除缓冲区：在读取不同类型的输入时（特别是读取字符串和其他类型的输入交替进行时），需要清除缓冲区中的换行符。

Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数: ");
int inputInt = scanner.nextInt();
scanner.nextLine();  // 清除缓冲区中的换行符

System.out.print("请输入一个字符串: ");
String inputString = scanner.nextLine();
System.out.println("你输入的字符串是: " + inputString);

总结

Scanner 类提供了多种方法来读取不同类型的用户输入，使得处理用户输入变得非常方便。在实际使用中，根据需要选择合适的方法，并注意处理异常和清除缓冲区中的换行符。

注意：

import java.util.Scanner;

public class PalindromeChecker {
    public static void main(String[] args) {
        // 创建 Scanner 实例
        Scanner scanner = new Scanner(System.in);
        
        // 提示用户输入
        System.out.println("输入颜色（String 类型）：");
        
        // 使用 Scanner 实例读取输入
        String colour = scanner.nextLine();
        
        // 打印输入的颜色
        System.out.println("你输入的颜色是: " + colour);
        
        // 关闭 Scanner 实例
        scanner.close();
    }
}

import java.util.Scanner;

public class PalindromeChecker {
    public static void main(String[] args) {
        // 创建 Scanner 实例
        Scanner sc = new Scanner(System.in);
        
        // 提示用户输入
        System.out.println("输入颜色（String 类型）：");
        
        // 使用 Scanner 实例读取输入
        String colour = sc.nextLine();
        // 打印输入的颜色
        System.out.println("你输入的颜色是: " + colour);
      
    }
}

  Scanner scanner = new Scanner(System.in);
  String colour = scanner.nextLine();


        Scanner sc = new Scanner(System.in);
        String colour = sc.nextLine();
        ／／相互对应。

        

API

字符串

字符串不可改变，他们的值在创建后不能被更改。
是的，您的陈述是正确的。在 Java 中，字符串（String）是不可变的（immutable）。一旦字符串对象被创建，它的值就不能被更改。任何对字符串进行修改的操作都会创建一个新的字符串对象，而不是在原有的字符串对象上进行修改。

解释

1. 不可变性：字符串对象一旦创建，它的内容就不能被改变。例如，当您对字符串进行连接、截取或替换操作时，实际上是创建了一个新的字符串对象。
2. 原因：不可变性有助于实现字符串池（string pool），提高内存利用效率。此外，它也增强了线程安全性，因为多个线程可以安全地共享不可变对象。

示例

以下是一个示例，演示字符串的不可变性：

public class Main {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = str1;

        // 尝试修改 str1
        str1 = str1 + ", world!";

        // 输出 str1 和 str2
        System.out.println("str1: " + str1); // str1: Hello, world!
        System.out.println("str2: " + str2); // str2: Hello
    }
}

解释

1. 初始值：str1 和 str2 都指向字符串 "Hello"。
2. 修改操作：str1 = str1 + ", world!"; 创建了一个新的字符串对象 "Hello, world!"，并将 str1 引用指向这个新对象。
3. 结果：str2 仍然指向原来的字符串 "Hello"，因为原来的字符串没有改变。

解决方法

如果需要对字符串进行频繁的修改，可以使用 StringBuilder 或 StringBuffer 类。这些类提供了可变的字符串对象，适合在需要多次修改字符串内容的场景中使用。

示例：使用 StringBuilder

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello");

        // 追加字符串
        sb.append(", world!");

        // 输出结果
        System.out.println(sb.toString()); // Hello, world!
    }
}

StringBuilder 是可变的，因此在原有对象上直接进行修改，不会创建新的对象。这在需要频繁修改字符串内容时可以显著提高性能。

char c = str.charAt(i); 这行代码从字符串 str 中获取索引为 i 的字符，并将其存储在变量 c 中。下面是详细的解释：

解释
str：这是一个字符串对象，通常类型为 String。
charAt(i)：这是 String 类中的一个方法，用于返回字符串中指定索引 i 处的字符。索引从 0 开始。
char c：这是一个字符类型的变量，用于存储从字符串中获取的字符。

StringBuilder怎么用，有什么需要注意的点

什么场景会用到StringBuilder()

1、字符串的拼接。
2、字符串的反转。

StringBuilder 是 Java 中的一个类，用于创建可变的字符串对象。它提供了很多方法，可以高效地对字符串进行各种操作，如追加、插入、删除和反转等。与 String 不同，StringBuilder 对象的内容是可变的，因此在需要对字符串进行频繁修改的场景中，StringBuilder 会更高效。

使用示例

public class Main {
    public static void main(String[] args) {
        // 创建一个空的 StringBuilder 对象
        StringBuilder sb = new StringBuilder();

        // 追加字符串
        sb.append("Hello");
        sb.append(", ");
        sb.append("world!");
        //变回字符串并且输出
        System.out.println(sb.toString()); // 输出: Hello, world!

        // 插入字符串
        sb.insert(5, " Java");
        System.out.println(sb.toString()); // 输出: Hello Java, world!

        // 删除部分字符串
        sb.delete(5, 10);
        System.out.println(sb.toString()); // 输出: Hello, world!

        // 替换部分字符串
        sb.replace(7, 12, "everyone");
        System.out.println(sb.toString()); // 输出: Hello, everyone!

        // 反转字符串
        sb.reverse();
        System.out.println(sb.toString()); // 输出: !enoyreve ,olleH
    }
}

注意点

1. 线程不安全：StringBuilder 是非线程安全的。如果在多线程环境中使用，可能会引发问题。如果需要线程安全的可变字符串类，可以使用 StringBuffer，它与 StringBuilder 类似，但提供了同步机制。

2. 初始容量：StringBuilder 有一个初始容量，当向 StringBuilder 对象追加内容时，如果内容超过了初始容量，它会自动扩展容量。这种扩展是自动的，但会有性能开销。可以在创建 StringBuilder 对象时指定初始容量，以减少扩展次数，从而提高性能：

   StringBuilder sb = new StringBuilder(50); // 指定初始容量为50
   

3. 方法链：StringBuilder 的很多方法返回的是 StringBuilder 本身，这允许使用方法链来简化代码：

   StringBuilder sb = new StringBuilder();
   sb.append("Hello").append(", ").append("world!");
   System.out.println(sb.toString()); // 输出: Hello, world!
   

4. 性能：StringBuilder 对象在进行频繁的字符串操作时，性能优于 String 对象，因为它不会像 String 那样在每次操作时都创建新的对象。

5. toString() 方法：StringBuilder 最终会使用 toString() 方法将内容转换为 String 对象：

   String result = sb.toString();
   

总结

StringBuilder 是一个高效且灵活的类，适用于需要频繁修改字符串的场景。正确使用 StringBuilder 可以显著提高代码的性能，特别是在循环中进行大量字符串操作时。但是他只是一个容器，并不是字符串，字符串可以利用这个类更方便的实现一些功能。

例子：

package palyStart;
import java.util.Scanner;
public class paly1 {
    public static void main(String[] args) {
     Scanner sc = new Scanner(System.in);
        System.out.println("请输入：");
        String str=sc.next();
//        StringBuilder sb = new StringBuilder();
//        sb.append(str);
//        sb.reverse();
//        String reverseStr=sb.toString();
        //链式编程
        String reverseStr=new StringBuilder().append(str).reverse().toString();
        System.out.println(str.equals(reverseStr));

    }
}

StringJoinder怎么用，有什么需要注意的点

StringJoiner 是 Java 8 引入的一个类，用于将多个字符串连接在一起，并可以在每个字符串之间插入一个定界符。它特别适用于需要动态构建带有定界符的字符串的场景。

使用示例

import java.util.StringJoiner;

public class Main {
    public static void main(String[] args) {
        // 创建一个 StringJoiner 对象，并指定定界符
        StringJoiner sj = new StringJoiner(", ");

        // 添加元素
        sj.add("Apple");
        sj.add("Banana");
        sj.add("Cherry");

        // 输出结果
        System.out.println(sj.toString()); // 输出: Apple, Banana, Cherry

        // 使用前缀和后缀
        StringJoiner sjWithPrefixSuffix = new StringJoiner(", ", "[", "]");
        sjWithPrefixSuffix.add("Apple");
        sjWithPrefixSuffix.add("Banana");
        sjWithPrefixSuffix.add("Cherry");

        // 输出结果
        System.out.println(sjWithPrefixSuffix.toString()); // 输出: [Apple, Banana, Cherry]
    }
}

注意点

1. 定界符：创建 StringJoiner 对象时需要指定定界符，这是连接各个字符串之间使用的符号，如逗号、空格等。

   StringJoiner sj = new StringJoiner(", ");
   

2. 前缀和后缀：可以在定界符的基础上再指定前缀和后缀，这样生成的字符串就会包含这些前缀和后缀。

   StringJoiner sj = new StringJoiner(", ", "[", "]");
   

3. 空值处理：如果 StringJoiner 没有添加任何元素，调用 toString() 方法时会返回空前缀和后缀（如果有指定）。可以使用 setEmptyValue 方法指定在这种情况下返回的字符串。

   StringJoiner sj = new StringJoiner(", ");
   sj.setEmptyValue("No elements");
   System.out.println(sj.toString()); // 输出: No elements
   

4. 添加元素：使用 add 方法添加元素，元素会按照添加的顺序连接起来。

   sj.add("Element");
   

5. 合并 StringJoiner：可以将两个 StringJoiner 对象合并，这样会将一个 StringJoiner 中的内容添加到另一个 StringJoiner 中。

   StringJoiner sj1 = new StringJoiner(", ");
   sj1.add("Apple").add("Banana");
   
   StringJoiner sj2 = new StringJoiner(", ");
   sj2.add("Cherry").add("Date");
   
   sj1.merge(sj2);
   
   System.out.println(sj1.toString()); // 输出: Apple, Banana, Cherry, Date
   

示例：动态构建带定界符的字符串

以下示例展示了如何使用 StringJoiner 动态构建一个带定界符的字符串：

import java.util.StringJoiner;

public class Main {
    public static void main(String[] args) {
        StringJoiner sj = new StringJoiner(", ", "{", "}");

        sj.add("one");
        sj.add("two");
        sj.add("three");

        System.out.println(sj.toString()); // 输出: {one, two, three}
    }
}

总结

StringJoiner 是一个非常方便的类，用于将多个字符串连接在一起，并可以在每个字符串之间插入定界符。它在处理需要定界符的字符串列表（如生成 CSV 或显示以特定格式分隔的列表）时特别有用。通过指定前缀和后缀，还可以灵活地生成所需格式的字符串。

这两行代码的作用是将字符 '5' 转换为整数 5，但它们使用不同的方法来实现这一点。让我们分别解释这两行代码的作用及其区别。

把字符型转换为整型，代码怎么写

1. 第一行代码：

   char c = '5';
   int num = c - '0';
   

   这一行代码将字符 '5' 转换为对应的整数值 5。

   • char c = '5';：定义一个字符变量 c 并赋值为字符 '5'。
   • int num = c - '0';：将字符 '5' 转换为对应的整数值。字符 '5' 的 ASCII 码值为 53，字符 '0' 的 ASCII 码值为 48。减法操作将这两个字符的 ASCII 码值相减，结果是 53 - 48 = 5。

   作用：将数字字符（例如 '0' 到 '9'）转换为对应的整数值。这在处理数字字符串时非常有用，例如将 '123' 转换为整数 123。

2. 第二行代码：

   int num = c - 48;
   

   这一行代码的效果与第一行代码相同，只是使用了字符 '0' 的 ASCII 码值 48 直接进行减法操作。

   • char c = '5';：定义一个字符变量 c 并赋值为字符 '5'。
   • int num = c - 48;：将字符 '5' 转换为对应的整数值。字符 '5' 的 ASCII 码值为 53，减去 48 的结果是 53 - 48 = 5。

   作用：将字符 '5' 转换为对应的整数值 5，直接使用 ASCII 码值 48。

编程思想

ArrayList成员方法

项目思想：