java输入输出（Scanner）小结（例题）

java输入输出（Scanner）小结（例题）

输入为整数

1. 输入包括两个正整数a,b(1 <= a, b <= 10^9),输入数据包括多组（输入一行输出一个结果），可以无限次的输入。
   输出：a+b的结果

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

结果如下图：


2. 输入第一行包括一个数据组数t（1<=t<=100），接下来每行包括两个正整数a，b。若t=2，表示只能输入两组a，b；输入一行，得到一个结果（行数受t约束）。
输出：a+b的结果

import java.util.Scanner;
public class p2 {
        public static void main(String[] args){
               Scanner sc = new Scanner(System.in);
               int len = sc.nextInt();
               for(int i = 0; i < len; i++){
                        int a = sc.nextInt();
                        int b = sc.nextInt();
                        System.out.println(a + b);

                }
        }
}

结果：

3. 输入包括两个正整数a,b(1 <= a, b <= 10^9),输入数据有多组, 如果输入为0 0则结束输入（无限次输入a，b求和，直至遇到0 0）
   输出：a+b的结果

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

结果：

4. 输入数据包括多组。每组数据一行或多行,每组的第一个整数为整数的个数n(1 <= n <= 100), n为0的时候结束输入。接下来n个正整数,即需要求和的每个正整数。（无限次输入，直至遇到0）
输出：a+b的结果

import java.util.Scanner;
public class p2 {
        public static void main(String[] args) {
                Scanner scan = new Scanner(System.in);
                while (scan.hasNext()) {
                        int n = scan.nextInt();
                        int sum = 0;
                        if (n == 0) break;
                        for (int i = 0; i < n; i++) {
                                sum += scan.nextInt();
                        }
                        System.out.println(sum);
                }
        }
}

结果：
第一次数据：5 1 2 3 4 4，其中5表示有5组数据，结果14表示后面5组数据的和，其他的以此内推。

6.
输入的第一行包括一个正整数t(1 <= t <= 100), 表示数据组数。
接下来t行, 每行一组数据。接下俩，每组数据第一个正整数n表示接下来n组数据求和
输出：a+b的结果

import java.util.Scanner;
public class p2 {
        public static void main(String[] args) {
                Scanner scanner = new Scanner(System.in);
                int num = scanner.nextInt();
                for(int i = 0;i<num;i++) {
                        int a = scanner.nextInt();
                        if(a==0)System.exit(0);
                        int res = 0;
                        for(int j = 0;j<a;j++){
                                res += scanner.nextInt();
                        }
                        System.out.println(res);
                }
        }
}

结果：

7.
输入数据有多组, 每行表示一组输入数据。
每行的第一个整数为整数的个数n(1 <= n <= 100)。
接下来n个正整数, 即需要求和的每个正整数。
（无限次输入，每一组数据的第一个整数表示计算后面几个数之和，即使输入的整数个数超过第一个整数的值，也只会计算第一个整数给出的整数，如结果中的第三组数据）
输出：a+b的结果

import java.util.Scanner;
public class p2 {
        public static void main(String[] args) {
                Scanner scanner = new Scanner(System.in);
                while (scanner.hasNext()) {
                        int a = scanner.nextInt();
                        if (a == 0) System.exit(0);
                        int res = 0;
                        for (int j = 0; j < a; j++) {
                                res += scanner.nextInt();
                        }
                        System.out.println(res);
                }

        }
}

结果：

输入为字符串

1. 输入有两行，第一行n；第二行是n个空格隔开的字符串；（输入次数与n有关）
   输出：输出一行排序后的字符串，空格隔开，无结尾空格

import java.util.*;
public class p2 {
        public static void main(String[] args){
                Scanner sc = new Scanner(System.in);
                while(sc.hasNext()){
                        int n = sc.nextInt();
                        String[] strs = new String[n];
                        for(int i = 0; i < n; i++){
                                strs[i] = sc.next();
                        }
                        Arrays.sort(strs);
                        for(int i = 0; i < n - 1; i++){
                                System.out.print(strs[i] + " ");
                        }
                        System.out.print(strs[n - 1]);
                }
        }
}

结果：超出个数要报错，并且若输入字符串，从字符串的第一个字符开始判断


2. 输入：多个测试用例，每个测试用例一行；每行通过空格隔开，有n个字符，n＜100；（无限次输入）
输入一行得出一次结果。
输出：对于每组测试用例，输出一行排序过的字符串，每个字符串通过空格隔开
（无限次输入）

import java.util.*;
public class p2 {
        public static void main(String[] args){
                Scanner sc = new Scanner(System.in);
                while(sc.hasNextLine()){
                        String[] s = sc.nextLine().split(" ");
                        Arrays.sort(s);
                        for (int i=0;i<s.length-1;i++){
                                System.out.print(s[i]+" ");
                        }
                        System.out.println(s[s.length-1]);
                }
        }
}

结果：

所给出的代码是输入一次数据，给出一个结果；并不是如给出的示例一般，先输入所有，再给出结果，但上述代码是正确的。

3. 输入：多个测试用例，每个测试用例一行。每行通过,隔开，有n个字符，n＜100
输出：对于每组用例输出一行排序后的字符串，用’,'隔开，无结尾空格
（无限次输入）

import java.util.*;
public class p2 {
        public static void main(String[] args){
                Scanner sc=new Scanner(System.in);
                while(sc.hasNextLine()){
                        String[] s=sc.nextLine().split(",");
                        Arrays.sort(s);
                        for(int i=0;i<s.length-1;i++){
                                System.out.print(s[i]+",");
                        }
                        System.out.println(s[s.length-1]);
                }
        }
}

结果：

4、从键盘输入一行字符，一旦回车就逐个打印出来

import java.util.*;
public class p3 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String n = s.nextLine();
        char[] ch = n.toCharArray();
        for (int i = 0; i < n.length(); i++) {
            System.out.print(ch[i]);
        }
    }
}