Java语言中ACM模式输入输出- 1（大厂笔试题必备知识）

1. JAVA输入需要用到Scanner类

导入类     import java.util.Scanner;

Scanner类是Java中用于读取用户输入的一个工具类，它可以从标准输入、文件、字符串等来源读取数据。它提供了一系列方法来解析基本数据类型和字符串。

以下是Scanner类在输入输出中的常用API：

构造方法：
- Scanner(File source)：从文件中读取数据。
- Scanner(InputStream source)：从输入流中读取数据。
- Scanner(String source)：从字符串中读取数据。
读取数据：
- next()：读取字符串，遇到空格或换行符停止。
- nextInt()：读取整数。
- nextDouble()：读取双精度浮点数。
- nextLine()：读取一行字符串，包括换行符。
判断是否有下一个数据：
- hasNext()：判断是否有下一个字符串。
- hasNextInt()：判断是否有下一个整数。
- hasNextDouble()：判断是否有下一个双精度浮点数。
- hasNextLine()方法来判断是否还有下一行输入。通常，它会被用在一个循环中，这个循环会一直运行直到没有更多的输入行为止。这在需要持续从输入流（例如标准输入或文件）中读取数据的情况下非常有用。
设置分隔符：
- useDelimiter(String pattern)：设置分隔符模式，用于切分输入。
关闭Scanner：
- close()：关闭Scanner，释放资源。
除此之外，需要注意一些小细节：（非常常用）
数字读取到字符串读取之间需要用 in.nextLine() 换行；

使用Scanner类可以方便地从用户输入中读取数据，例如：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入您的姓名：");
        String name = scanner.nextLine();
        
        System.out.print("请输入您的年龄：");
        int age = scanner.nextInt();
        
        System.out.println("您好，" + name + "，您今年" + age + "岁。");
        
        scanner.close();
    }
}

核心: 在接收输入的时候要善于利用String的各种api然后截取到有用的数据作为输入数据!

常用: obj.replace("[",""); ===> 用于去除传入的一行数据的" [ " 这个符号
            obj.split(",");        ==> 将当前字符串以逗号分割形成一个数组
            String.join(",",String数组)
            Arrays.deepToString(数组..);  ==> 直接就是格式打印
注意: deepToString(Object[] ) 这里如果是int[] []就可以直接传入并打印.
注意这里是int[] 是不可以传进去的!!!必须是Integer[]
也需要注意空格问题!!!
List<Integer> res = new LinkedList<>();
System.out.println(res); //有时候层序遍历时，每个元素都带空格了，需要替换掉
应该这样写：

实际考试中，如果输出格式不对，也是没分的！！！

2. Scanner对象创建

Scanner sc = new Scanner(System.in);

构造方法的参数System.in表示允许用户从系统中读取内容

3. 常用方法

3.1 next()方法的返回值是字符串类型

next()类似方法

~ nextLine()：返回输入回车之前的所有字符

~ nextInt()：返回输入内容得到int型数据

next()方法与nextLine()方法的区别：

①next(）方法只有扫描到有效字符后才会结束输入，而nextLine()方法可以直接使用回车结束输入；

②next()方法会自动去掉空白（例如回车、空格等），而nextLine()方法可以得到空白和带有空格的字符串。

3.2 hasNext()方法

hasNext()方法的返回值是一个布尔类型，如果输入中包含数据的输入，则返回true。否则返回false。通常用来做输入内容的验证。

4. 实例应用

4.1. 数字处理

如果是读取 Long，则使用：in.hasNextLong() 和 Long a = in.nextLong()；
读取小数：f = scan.nextFloat() 或 double weight = scan.nextDouble()；

4.1.1 多组空格分隔的两个正整数

输入包括两个正整数a,b(1 <= a, b <= 10^9),输入数据包括多组；

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int a = in.nextInt();
            int b = in.nextInt();
            //处理
        }
    }
}

4.1.2 第一行数组接空格分隔的两个正整数

第一行输入数据个数，后面输入数据；

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int num = in.nextInt();
        for(int i = 0; i < num; i++) { // 注意 while 处理多个 case
            int a = in.nextInt();
            int b = in.nextInt();
            //处理
        }
    }
}

4.1.3 空格分隔的两个正整数为0 0 结束

输入包括两个正整数a,b(1 <= a, b <= 10^9), 如果输入为0 0则结束输入；

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int a = in.nextInt();
            int b = in.nextInt();
            if(a ==0 && b == 0) break;
            //处理
        }
    }
}

4.1.4 每行第一个为个数后带空格分割整数为0结束

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int n = in.nextInt();
            if(n == 0) break;
            int sum = 0;
            for (int i = 0; i < n; i++) {
                sum += in.nextInt();
            }
            System.out.println(sum);
        }
    }
}

4.2 字符串处理

4.2.1 第一行个数第二行字符串

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        in.nextLine();
        while (in.hasNext()) { // 注意 while 处理多个 case
            String[] s = in.nextLine().split(" ");
            //处理
        }
    }
}

4.2.2 多行空格分开的字符串

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String[] s = in.nextLine().split(" ");
            //处理
        }
    }
}

5. 输出格式化相关

输出有两种方式：String str=String.format(示例) 或 System.out.printf(示例)；
向上取整用：Math.ceil(1.01)，向下取整用：Math.floor(1.01)；

5.1 转换符

5.2 搭配转换符的标志

6. ACM 模式模板

import java.util.*;
import java.lang.*;

public class Main {

    public static void main(String[] args) {
        //1.数据输入
        Scanner in = new Scanner(System.in);
        //读数字
        int numLen = in.nextInt();
        int[] numArr = new int[numLen];
        int i = 0;
        while(in.hasNextInt() && i < numLen){
            numArr[i] = in.nextInt();
            i++;
        }
        //读字符串
        int strLen = in.nextInt();
        in.nextLine(); //数字到字符串要换行
        String[] strArr = new String[strLen];
        //或者 strArr[] = in.nextLine().split(" ");
        int j = 0;
        while(in.hasNextLine() && j < strLen){
            strArr[j] = in.nextLine();
            j++;
        }
        
        //2. 处理
        Solution solution = new Solution();
        String result = solution.process(numArr, strArr);
        
        //3. 输出
        System.out.println(result);
        //四舍五入输出小数
        String str = String.format("%.2f",3.555);
        System.out.println(str);
    }
}

//下面类似 LeetCode 的核心代码模式
class Solution {
    public String process(int[] nums, String[] strs) {
        StringBuilder sb = new StringBuilder();
        sb.append(Arrays.toString(nums));
        sb.append(" && ");
        sb.append(Arrays.toString(strs));
        return sb.toString();
    }
}

7.实际题目中用到的一些输入输出格式或者api方法

①解析字符串数组

//String[] inputs = line.split(" "); //用空格将line字符串分隔开，存入inputs数组中 
String[] inputs = {"A", "10"};

char ch = inputs[0].charAt(0); // ch = 'A'
int n = Integer.parseInt(inputs[1]); // n = 10

这段代码首先从一个名为inputs的字符串数组中获取第一个元素，然后获取该元素的第一个字符，并将其赋值给变量ch。

接着，从数组的第二个元素中获取一个字符串，然后将其解析为整数，并将结果赋值给变量n。

通过解析这些输入，我们可以得到字符'A'和整数型参数数值10。

补充：

charAt(int index)，返回 char指定索引处的值。

②句子首字母缩写

通过Scanner从标准输入中读取n行字符串，并对每行字符串进行处理，提取每个单词的首字母并将其转换为大写字母后输出。

import java.util.*;
public class Main {  
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in); // 创建Scanner对象，用于读取输入
        int n = in.nextInt(); // 读取整数n，表示接下来有n行输入
        in.nextLine(); // 读取换行符，准备读取下一行
        
        for(int x = 0;x < n;x++) { // 循环处理n行输入
            String s = in.nextLine(); // 读取一行字符串(这种读法包含了空格,等所有字符)
            int i = 0; // 初始化字符索引为0
            StringBuilder sb = new StringBuilder(); // 创建StringBuilder对象，用于存储提取出的首字母
            
            while(i < s.length()){ // 循环遍历字符串s中的每个字符
                while(s.charAt(i) == ' ') { // 跳过空格
                    i++;
                }
                char c = s.charAt(i); // 获取当前字符
                if(c <= 'Z' && c >= 'A') { // 如果是大写字母，则直接添加到StringBuilder中
                    sb.append(s.charAt(i));
                } else { // 如果是小写字母，则转换为大写字母后添加到StringBuilder中
                    sb.append((char) (c + 'A' - 'a'));
                }
                while(i < s.length() && s.charAt(i) != ' ') { // 跳过当前单词的剩余字符
                    i++;
                }
            }
            System.out.println(sb.toString()); // 输出StringBuilder中的内容，即为提取出的首字母组成的单词
        }
    }    
}

while (in.hasNext()) {
    int n = in.nextInt(); // 输入一个整数n
    in.nextLine(); // 读取换行符，准备读取下一行
    
    for (int i = 0; i < n; i++) {
        String line = in.nextLine().trim();
        System.out.println(line);
    }
}

这段代码是一个循环，它会执行n次。

在每次循环中，它从输入流中读取一行字符串，并去除字符串两端的空格（trim()方法的作用），然后将该字符串赋值给变量line。
接着，它创建了一个StringBuilder对象sb，并在循环中将sb的内容输出到控制台。

好处：sb.append(s.charAt(i)); 可以将符合条件的字符直接添加到StringBuilder中，

可变字符串。

StringBuilder的toString()方法用于将StringBuilder对象中的字符序列转换为字符串。当你需要将StringBuilder中的内容作为字符串进行处理或者输出时，可以使用toString()方法。

sb.append((char) (c + 'A' - 'a'));

这种方法是一种常见的将小写字母转换为大写字母的技巧，通过调整ASCII值来实现大小写转换。

c是当前字符，假设是一个小写字母。
'A'和'a'是ASCII编码中大写字母'A'和小写字母'a'对应的值。
(char) (c + 'A' - 'a')的计算过程是：
首先，将小写字母转换为对应的大写字母。这是通过将小写字母的ASCII值加上'A' - 'a'来实现的。因为小写字母和大写字母之间的ASCII值差是固定的，所以只需加上这个差值即可将小写字母转换为大写字母。
然后，将得到的结果强行转换为对应的字符（char）。

方法二：

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        while(scan.hasNextInt()){
            int n = scan.nextInt();
            //Scanner类的nextInt()方法会读取输入中的一个整数，
            //但它只会读取整数值，而不会读取换行符。
            //当你调用nextInt()后，输入缓冲区中的整数被读取，但换行符仍然留在缓冲区中。
            scan.nextLine();//数字读取到字符串读取之间需要用 in.nextLine() 换行；
            while(n-- > 0){//外层循环，表示遍历n行字符串
                String s = scan.nextLine();
                //忽略连续空格之间的空字符串，可以使用正则表达式\s+作为分隔符，
                //它表示一个或多个连续的空白字符
                String[] str = s.split("\\s+"); //分割出一个字符串数组str
                String result = "";
                for(int i = 0; i < str.length; i++){//
                    if(str[i].isEmpty()) continue;
                    result += String.valueOf(str[i].charAt(0)).toUpperCase();
                }
                System.out.println(result);
            }
        }
        scan.close();
    }
}

String[] str = s.split("\\s+");

这行代码使用了Java中String类的split方法来将字符串s按照正则表达式"\s+"进行分割，并将分割后的结果存储到字符串数组str中。

让我解释一下：

s.split("\\s+")：这个方法调用会根据正则表达式"\s+"对字符串s进行分割。正则表达式"\s+"表示一个或多个空白字符（空格、制表符、换行符等），因此该方法会将字符串s按照空白字符进行分割。
返回的是一个字符串数组，数组中的每个元素都是分割后得到的子串。

举个例子，假设字符串s是"Hello World"，其中有多个连续的空格字符。使用split方法分割后，字符串数组str将包含两个元素："Hello" 和 "World"，其中多个连续的空格字符被视为一个空白字符进行分割。

String result = "";

for(int i = 0; i < str.length; i++){

if(str[i].isEmpty()) continue;

result += String.valueOf(str[i].charAt(0)).toUpperCase(); }

这段代码的作用是将字符串数组str中每个非空字符串的首字母提取出来，并将其转换为大写字母后拼接到result字符串中。

让我逐行解释一下：

String result = "";：创建一个空字符串result，用于存储提取出的首字母的大写形式。
for(int i = 0; i < str.length; i++){：使用for循环遍历字符串数组str中的每个元素。
if(str[i].isEmpty()) continue;：如果当前元素是空字符串，则跳过本次循环，继续处理下一个元素。
result += String.valueOf(str[i].charAt(0)).toUpperCase();：
str[i].charAt(0)：获取当前字符串的第一个字符（即首字母）。
String.valueOf(...)：将首字母转换为字符串。
.toUpperCase()：将首字母转换为大写形式。
result += ...：将转换后的大写首字母拼接到result字符串后面。

Java语言中ACM模式输入输出- 1（大厂 笔试题必备知识）