输入要考虑的基本问题

算法竞赛题目一般会有多个测试用例，采用重定向的方式把数据送给程序。
然后观察程序的输出是否和预期的结果一致。
多数情况下，这些测试用例会以文件的形式存在。这就要注意以下的问题：

  1. 每一行的数据有多项，其分隔符不是完全确定，比如是：一个或多个空格。
  2. 每一行上的数据有多少项可能不知道。一直持续到本行结束。
  3. 一共有多少行可能不知道，一直到文件尾。
  4. 最后一行可能没有回车换行符，直接遇到 EOF (文件结束标记)
  5. 在不同的操作系统下，换行的方式可能不同。
  6. 在提供字符串的时候，可能含有空格。

下面我们举一些最常见的例子。

若干行，每行一个整数

测式数据

3
5
-7
9
import java.util.*;
import java.io.*;
public class A
{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        
        try{
            while(true){
                System.out.println("-> " + scan.nextInt());
            } 
        }
        catch(Exception e){}
    }
}
import java.util.*;
import java.io.*;
public class A
{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        
        try{
            while(true){
                System.out.println("-> " + scan.nextInt());
            } 
        }
        catch(Exception e){}
    }
}

使用这种方式，最后一行有没有换行符都无关紧要。
甚至是最后有多个空行也不成问题。

若干行，每行两个整数，用一个或多个空格分开

测试数据

10 20
30   40
50 60
import java.util.*;
import java.io.*;
public class B
{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        
        try{
            while(true){
                System.out.println("-> " + scan.nextInt() + "," + scan.nextInt());
            } 
        }
        catch(Exception e){}
    }
}
import java.util.*;
import java.io.*;
public class B
{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        
        try{
            while(true){
                System.out.println("-> " + scan.nextInt() + "," + scan.nextInt());
            } 
        }
        catch(Exception e){}
    }
}

先是读入一个整数n，后面紧跟着n行字符串（可能含有空格）

测试数据

3
I am a student
test string
ok
import java.util.*;
public class C
{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        
        int n = scan.nextInt();
        scan.nextLine();         //这个空读十分关键
        for(int i=0; i<n; i++){
            System.out.println(scan.nextLine());
        }
    }
}
import java.util.*;
public class C
{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        
        int n = scan.nextInt();
        scan.nextLine();         //这个空读十分关键
        for(int i=0; i<n; i++){
            System.out.println(scan.nextLine());
        }
    }
}

这里要注意的是：在读入整数以后，不能直接按行读入。而是要先空读一行。
因为，nextInt 会越过空白，读取整数，直到遇到了下一个空白（这里就是回车），
但它不会把遇到的这个分隔符吃掉，而是留在缓冲区中。
所以，此时如果直接按行读入，就会先是空行，然后才能读到需要的内容。
而 nextLine 就不同，它不会把回车符留在缓冲区，同时也不会把回车符返回在结果串中。
这样安排有利于解决跨平台时，换行方式不一致的问题。

先是一个整数 n， 接下来有 n 行， 每行多个整数， 空格分开。要求对第每行求和

测试数据

4
1 2 3
10 20 30 40
333
444

此数据的最后一行没有回车
方法一：

import java.util.*;
public class D
{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        
        int n = scan.nextInt();
        scan.nextLine(); // 读掉后面的一个回车符
        
        for(int i=0; i<n; i++){
            String s = scan.nextLine().trim();
            String[] ss = s.split(" +");  // 因为1个或多个空格分开
            
            int sum = 0;
            for(int j=0; j<ss.length; j++){
                sum += Integer.parseInt(ss[j]);
            }
            System.out.println(sum);
        }
    }
}

import java.util.*;
public class D
{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        
        int n = scan.nextInt();
        scan.nextLine(); // 读掉后面的一个回车符
        
        for(int i=0; i<n; i++){
            String s = scan.nextLine().trim();
            String[] ss = s.split(" +");  // 因为1个或多个空格分开
            
            int sum = 0;
            for(int j=0; j<ss.length; j++){
                sum += Integer.parseInt(ss[j]);
            }
            System.out.println(sum);
        }
    }
}

这是比较简明的处理方法，每次把整个一行都读进来，再进行分割。
但这样处理可能有一个问题：当一行的数据太大（上百万比如），可能导致读入有问题。
如果能每次只读入一个数据项，读一个处理一个就很理想了。
所以才有方法二：

import java.util.*;
public class D2
{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        
        int n = scan.nextInt();
        scan.nextLine(); // 读掉后面的一个回车符
        
        scan.useDelimiter(" +");  //默认的数据项分割符是空白和回车换行都可以，这里改为若干空格
        for(int i=0; i<n; i++){
            int sum = 0;
            while(scan.hasNextInt()){
                sum += scan.nextInt();
            }
            if(scan.hasNextLine()){  // 加 if 防止最后一行没有回车符
                sum += Integer.parseInt(scan.nextLine().trim());
            }
            System.out.println(sum);
        }
    }
}

import java.util.*;
public class D2
{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        
        int n = scan.nextInt();
        scan.nextLine(); // 读掉后面的一个回车符
        
        scan.useDelimiter(" +");  //默认的数据项分割符是空白和回车换行都可以，这里改为若干空格
        for(int i=0; i<n; i++){
            int sum = 0;
            while(scan.hasNextInt()){
                sum += scan.nextInt();
            }
            if(scan.hasNextLine()){  // 加 if 防止最后一行没有回车符
                sum += Integer.parseInt(scan.nextLine().trim());
            }
            System.out.println(sum);
        }
    }
}