在刷牛客网时，遇到一类机试（华为机试）是采用ACM模式下的算法，这样针对不同的输入输出就需要有一个大致的了解。

牛客网题目链接：https://ac.nowcoder.com/acm/contest/5657#question

首先对与Java的输入，要用Scanner：

Scanner in = new Scanner(System.in);

读取字符或行：

in.hasNext()
in.hasNextLine()

使用的方法总结：

采用has xxxx的话，后面也要用next xxxx。比如前面用hasNextLine，那么后面要用 nextLine 来处理输入。

具体区别参考：笔试在线判题系统输入输出（剑指Offer类和传统ACM的OJ模式）

以下是针对各种输入输出条件下举例实现的Java代码：

1. 多组空格分割的两个整数 （无行数，结束字符限制）

题目描述：

输入包括两个正整数a,b(1 <= a, b <= 10^9),输入数据包括多组。
输出a+b的结果

输入示例：

1 5
10 20

输出示例

6
30

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) { 
            int a = in.nextInt();
            int b = in.nextInt();
            System.out.println(a + b);
        }
    }
}

2. 第一行组数接空格分割的两个正整数 （行数限制）

题目描述：

输入第一行包括一个数据组数t(1 <= t <= 100)
接下来每行包括两个正整数a,b(1 <= a, b <= 10^9)
输出a+b的结果

输入示例：

2
1 5
10 20

输出示例：

6
30

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();
            System.out.println(a + b);
        }
    }
}

3. 空行分割的两个正整数，0 0 结束 （结束符限制）

题目描述：

输入包括两个正整数a,b(1 <= a, b <= 10^9),输入数据有多组, 如果输入为0 0则结束输入
输出a+b的结果

输入示例：

1 5
10 20
0 0

输出示例：

6
30

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        
        while (in.hasNext()) { 
            int a = in.nextInt();
            int b = in.nextInt();
            if(a ==0 && b == 0) break;
            System.out.println(a + b);
        }
    }
}

4. 每行第一个为个数后带空格分割整数，0结束 （结束符限制,每行有个数限制）

题目描述：

输入数据包括多组。
每组数据一行,每行的第一个整数为整数的个数n(1 <= n <= 100), n为0的时候结束输入。
接下来n个正整数,即需要求和的每个正整数。

每组数据输出求和的结果

输入示例：

4 1 2 3 4
5 1 2 3 4 5
0

输出示例：

10
15

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        
        while (in.hasNext()) { 
            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);
        }
    }
}

5. 第一行组数接第一个个数接空格分开的整数 （行数限制,每行有个数限制）

题目描述：

输入的第一行包括一个正整数t(1 <= t <= 100), 表示数据组数。
接下来t行, 每行一组数据。
每行的第一个整数为整数的个数n(1 <= n <= 100)。
接下来n个正整数, 即需要求和的每个正整数。

每组数据输出求和的结果

输入示例：

2
4 1 2 3 4
5 1 2 3 4 5

输出示例：

10
15

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++){
            int n = in.nextInt();
            int sum = 0;
            for(int j = 0; j < n; j++){
                sum += in.nextInt();
            }
            System.out.println(sum);
        }
    }
}

6. 每行第一个为个数后带空格分割整数 (无结束限制,每行有个数限制)

题目描述：

输入数据有多组, 每行表示一组输入数据。
每行的第一个整数为整数的个数n(1 <= n <= 100)。
接下来n个正整数, 即需要求和的每个正整数。

每组数据输出求和的结果

输入示例：

4 1 2 3 4
5 1 2 3 4 5

输出示例：

10
15

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) { 
            int n = in.nextInt();
            int sum = 0;
            while (n > 0) {
                sum += in.nextInt();
                n--;
            }
            System.out.println(sum);
        }
    }
}

7. 多组空格分隔的正整数 (无结束限制,每行无个数限制,需要当作字符串处理)

题目描述：

输入数据有多组, 每行表示一组输入数据。
每行不定有n个整数，空格隔开。(1 <= n <= 100)。

每组数据输出求和的结果

输入示例：

1 2 3
4 5
0 0 0 0 0

输出示例：

6
9
0

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) { 
            String[] s = in.nextLine().split(" ");
            int sum = 0;
            for (int i = 0; i < s.length; i++) {
                sum += Integer.parseInt(s[i]);
            }
            System.out.println(sum);
        }
    }
}

// 扩展：第一行组数接空格分开的多个整数 (有行数限制,每行无个数限制,需要当作字符串处理)
// eg: 每组数据输出求和的结果
// 3
// 1 2 3
// 4 5
// 0 0 0 0 0

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int num = in.nextInt();
        in.nextLine();  // 跳过行数所在行
        for (int i = 0; i < num; i++ ){
            String[] s = in.nextLine().split(" ");
            int sum = 0;
            for(int j = 0; j < s.length; j++){
                sum += Integer.parseInt(s[j]);  // 将字符转成整数类型
            }
            System.out.println(sum);
        }
    }
}

8. 第一行个数第二行字符串

题目描述：

输入有两行，第一行n
第二行是n个空格隔开的字符串

输出一行排序后的字符串，空格隔开，无结尾空格

输入示例：

5
c d a bb e

输出示例：

a bb c d e

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(" ");
            Arrays.sort(s);
            for (int i = 0; i < s.length; i++) {
                System.out.print(s[i] + " ");
            }
            
        }
    }
}

9. 多行空格分开的字符串

题目描述：

多个测试用例，每个测试用例一行。
每行通过空格隔开，有n个字符，n＜100

对于每组测试用例，输出一行排序过的字符串，每个字符串通过空格隔开

输入示例：

a c bb
f dddd
nowcoder

输出示例：

a bb c
dddd f
nowcoder

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(" ");
            Arrays.sort(s);
            for (String c:s) {
                System.out.print(c + " ");
            }
            System.out.println();
        }
    }
}

10. 多行逗号分开的字符串 （逗号和空格的区别就是最后一个字符输完的时候",“还是” " ）

题目描述：

多个测试用例，每个测试用例一行。
每行通过,隔开，有n个字符，n＜100

对于每组用例输出一行排序后的字符串，用','隔开，无结尾空格

输入示例：

a,c,bb
f,dddd
nowcoder

输出示例：

a,bb,c
dddd,f
nowcoder

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(",");
            Arrays.sort(s);
            int l = s.length;
            for (int i = 0; i < l - 1; i++) {
                System.out.print(s[i] + ",");
            }
            System.out.println(s[l-1]);
        }
    }
}

以上就是遇到的各种输入输出的一个总结，后面再遇到新的情况会及时更新。

一个整体的代码如下：

import java.util.Arrays;
import java.util.Scanner;

public class InOutTest {
    public static void main(String[] args){
        // 1. 多组空格分割的两个整数
        // eg：每行输入两个数求和
        // 1 5
        // 10 20
//        Scanner in = new Scanner(System.in);
//        while (in.hasNext()){ // while处理多个case
//            int a = in.nextInt();
//            int b = in.nextInt();
//            System.out.println(a + b);
//        }

        // 2. 第一行组数接空格分割的两个正整数 （行数限制）
        // eg: 输出a+b的结果
        // 2
        // 1 5
        // 10 20
//        Scanner in = new Scanner(System.in);
//        int num = in.nextInt();
//        for (int i =0; i < num; i++){
//            int a = in.nextInt();
//            int b = in.nextInt();
//            System.out.println(a + b);
//        }

        // 3. 空行分割的两个正整数，0 0 结束 （结束符限制）
        // eg: 输出a+b的结果
        // 1 5
        // 10 20
        // 0 0
//        Scanner in = new Scanner(System.in);
//        while (in.hasNext()){
//            int a = in.nextInt();
//            int b = in.nextInt();
//            if(a == 0 && b == 0) break;
//            System.out.println(a + b);
//        }

        // 4. 每行第一个为个数后带空格分割整数，0结束 （结束符限制,每行有个数限制）
        // 输入数据包括多组。
        // 每组数据一行,每行的第一个整数为整数的个数n(1 <= n <= 100), n为0的时候结束输入。
        // 接下来n个正整数,即需要求和的每个正整数。
        // eg: 每组数据输出求和的结果
        // 4 1 2 3 4
        // 5 1 2 3 4 5
        // 0
//        Scanner in = new Scanner(System.in);
//        while (in.hasNext()){
//            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);
//        }

        // 5. 第一行组数接第一个个数接空格分开的整数 （行数限制,每行有个数限制）
        // 输入的第一行包括一个正整数t(1 <= t <= 100), 表示数据组数。
        // 接下来t行, 每行一组数据。
        // 每行的第一个整数为整数的个数n(1 <= n <= 100)。
        // 接下来n个正整数, 即需要求和的每个正整数。
        // eg: 每组数据输出求和的结果
        // 2
        // 4 1 2 3 4
        // 5 1 2 3 4 5
//        Scanner in = new Scanner(System.in);
//        int num = in.nextInt();
//        for (int i = 0; i < num; i++){
//            int n = in.nextInt();
//            int sum = 0;
//            for(int j = 0; j < n; j++){
//                sum += in.nextInt();
//            }
//            System.out.println(sum);
//        }
        // 6. 每行第一个为个数后带空格分割整数 (无结束限制,每行有个数限制)
        // 输入数据有多组, 每行表示一组输入数据。
        // 每行的第一个整数为整数的个数n(1 <= n <= 100)。
        // 接下来n个正整数, 即需要求和的每个正整数。
        // eg: 每组数据输出求和的结果
        // 4 1 2 3 4
        // 5 1 2 3 4 5
//        Scanner in = new Scanner(System.in);
//        while (in.hasNextInt()){
//            int num = in.nextInt();
//            int sum = 0;
//            for(int i = 0; i < num; i++){
//                sum += in.nextInt();
//            }
//            System.out.println(sum);
//        }

        // 7. 多组空格分隔的正整数 (无结束限制,每行无个数限制,需要当作字符串处理)
        // 输入数据有多组, 每行表示一组输入数据。
        // 每行不定有n个整数，空格隔开。(1 <= n <= 100)。
        // eg: 每组数据输出求和的结果
        // 1 2 3
        // 4 5
        // 0 0 0 0 0 0
//        Scanner in = new Scanner(System.in);
//        while (in.hasNextLine()){   // 直接读一行字符串
//            String[] s = in.nextLine().split(" ");
//            int sum = 0;
//            for(int i = 0; i < s.length; i++){
//                sum += Integer.parseInt(s[i]);
//            }
//            System.out.println(sum);
//        }

        // 扩展：第一行组数接空格分开的多个整数 (有行数限制,每行无个数限制,需要当作字符串处理)
        // eg: 每组数据输出求和的结果
        // 3
        // 1 2 3
        // 4 5
        // 0 0 0 0 0
        Scanner in = new Scanner(System.in);
        int num = in.nextInt();
        in.nextLine();  // 跳过行数所在行
        for (int i = 0; i < num; i++ ){
            String[] s = in.nextLine().split(" ");
            int sum = 0;
            for(int j = 0; j < s.length; j++){
                sum += Integer.parseInt(s[j]);
            }
            System.out.println(sum);
        }


        // 8. 第一行个数第二行字符串
        // 输入有两行，第一行n
        // 第二行是n个空格隔开的字符串
        // eg: 输出一行排序后的字符串，空格隔开，无结尾空格
        // 5
        // c d a bb e
//        Scanner in = new Scanner(System.in);
//        int num = in.nextInt();
//        in.nextLine();
//        while (in.hasNext()){
//            String[] s = in.nextLine().split(" ");
//            Arrays.sort(s);
//            for (int i = 0; i < s.length; i++){
//                System.out.print(s[i] + " ");
//            }
//        }

        // 9. 多行空格分开的字符串
        // 多个测试用例，每个测试用例一行。
        // 每行通过空格隔开，有n个字符，n＜100
        // eg: 对于每组测试用例，输出一行排序过的字符串，每个字符串通过空格隔开
        // a c bb
        // f dddd
        // nowcoder
//        Scanner in = new Scanner(System.in);
//        while (in.hasNextLine()){
//            String[] s = in.nextLine().split(" ");
//            Arrays.sort(s);
//            for (String c:s){
//                System.out.print(c + " ");
//            }
//            System.out.println();
//        }

        // 10. 多行逗号分开的字符串 （逗号和空格的区别就是最后一个字符输完的时候","还是" " ）
        // 多个测试用例，每个测试用例一行。
        // 每行通过,隔开，有n个字符，n＜100
        // eg: 对于每组用例输出一行排序后的字符串，用','隔开，无结尾空格
        // a,c,bb
        // f,dddd
        // nowcoder
//        Scanner in = new Scanner(System.in);
//        while (in.hasNextLine()) {
//            String[] s = in.nextLine().split(",");
//            Arrays.sort(s);
//            int l = s.length;
//            for (int i = 0; i < l - 1; i++) {
//                System.out.print(s[i] + ",");
//            }
//            System.out.println(s[l-1]);
//        }

    }

}