Java_tips4: Java机试---常见的矩阵输入操作

题目零：输入一个整型，浮点型，字符型和字符串型的数

题目0：
例子：
1 2.0 avc acv

public class Main5 {
    public static void main(String[] args) {
        //输入：
        Scanner cin=new Scanner(System.in);
        //1）获取整型
        int A=cin.nextInt();
        //2）获取浮点型
        double B=cin.nextDouble();
        //3）获取字符串型
        String  C=cin.next();
        String  D=cin.next();

        System.out.println("A="+A);   //A=1
        System.out.println("B="+B);   //B=2.0
        System.out.println("C="+C);   //C=avc
        System.out.println("D="+D);   //D=acv

        //4）获取一行
        String E=cin.nextLine();
        System.out.println("E="+E);
    }
}

题目一：输入一个矩阵，已知数据的行数和列数（用数组装数据最好）

题目三：第一行两个正整数M和N，接下来M行，每行N个非负整数（用空格隔开）
在已知行和列的情况下，可以用数组装数据最快
数据的输入格式：把后面T行数据用一个集合装起来。
例子：
2 3
1 2 3
1 5 6
结果：string={[2,3],[1,2,3],[1,5,6]}

public class Main3 {
    public static void main(String[] args) {
        //输入：指定行和列数进行输入
        //第一行：输入两个数m,n
        //后面m行，每行n个数字
        Scanner cin=new Scanner(System.in);
        int row= cin.nextInt();
        int col= cin.nextInt();
        int[][] string=new int[row][col];
        for(int i=0; i<row;i++){
            for(int j=0;j<col;j++){
                string[i][j]=cin.nextInt();
            }
        }
    }
}

题目二：输入一个行，列数不清楚（用集合装数据最好）

        Scanner cin=new Scanner(System.in);
        //1)输入(输入一行，没有指定有多少个数字）
        //1 2 3 4 5
        List<Integer> list=new ArrayList<>();
        String string=cin.nextLine();
        String[] arrstring=string.split(" ");
        for(int i=0;i<arrstring.length;i++){
            list.add(Integer.valueOf(arrstring[i]));
        }
        System.out.println("list="+list);

题目三：输入一个矩阵，已知数据的行数，不知列数（用集合装数据最好）

题目三：第一行输入一个整数size；第二行之后共有size行数据
数据的输入格式：把输入数据用一个集合装起来。
例子：
3
1 2 3 4
2 3 5 4
7 8 9 8
输出结果：list=[[1, 2, 3, 4], [2, 3, 5, 4], [7, 8, 9, 8]]

public class Main{
        public static void main(String[] args) {
        Scanner cin=new Scanner(System.in);
        int size= cin.nextInt();
        cin.nextLine();  //注释：一定要这一句，因为nextInt()没有换行，否则会读到一个空行
        List<List<Integer>> list=new ArrayList<>();
        for(int i=0;i<size;i++){
            List<Integer> arrlist=new ArrayList<>();
            String string=cin.nextLine();
            String[] temp=string.split(" ");
            for(int j=0;j< temp.length;j++){
                arrlist.add(Integer.valueOf(temp[j]));
            }
            list.add(arrlist);
            }
        System.out.println("list="+list);
    }
}

题目四：输入一个矩阵，行数和列数都不清楚（用集合装数据最好）

每行若干个整数（用空格隔开）
数据的输入格式：把输入数据用一个集合装起来。
例子：
1 2 3
2 5 3 5 8 1
4 5 6 8
输出结果：data=[[1, 2, 3], [2, 5, 3, 5, 8, 1], [4, 5, 6, 8]]

//核心是遇到了空行则break
public class Main {
    public static void main(String[] args) {
        //0）核心目的：在不知道行和列的情况下输入
        //1）准备工作：数据集合和输入器
        List<List<Integer>>  data= new ArrayList<>();
        Scanner cin=new Scanner(System.in);
        //2）判断是否还有下一行
        while(true) {
            List<Integer> list= new ArrayList<>();
            String string=cin.nextLine();
            //3）设置截止条件（空行结束）
            if(string=="") break;
            //4）把字符串转变为集合
            String[] arrstring=string.split(" ");
            for(int i=0;i<arrstring.length;i++){
                list.add(Integer.parseInt(arrstring[i]));//把字符型转变为整型
            }
            data.add(list);
        }
        //输出显示
        System.out.println("data="+data);
    }
}

题目五：实战题目

// 2:第一行：整数M，表示搜索的次数(表示接下来有2M行数据），第一行为搜索词，第二行为停用词。
// 3 a ab abc:第三行：搜索词：第一个数为之后字符串的个数n，后面就为n字符串
// 2 q qe :第四行：停用词：第一个数为之后字符串的个数n，后面就为n字符串
// 4 a ab abc abcd：搜索词：第一个数为之后字符串的个数n，后面就为n字符串
// 3 a ab abc：停用词：第一个数为之后字符串的个数n，后面就为n字符串

        Scanner cin=new Scanner(System.in);
        int size=cin.nextInt();
        cin.nextLine();
        List<List<String>> data=new ArrayList<>(); //搜索词
        List<List<String>> stopdata=new ArrayList<>(); //停用词
        for(int i=0;i<size;i++){
            List<String> arrdata=new ArrayList<>();
            int num=cin.nextInt();
            for(int j=0;j<num;j++){
                arrdata.add(cin.next());
            }
            data.add(arrdata);

            List<String> arrstopdata=new ArrayList<>();
            int num1=cin.nextInt();
            for(int j=0;j<num1;j++){
                arrstopdata.add(cin.next());
            }
            stopdata.add(arrstopdata);
        }
        System.out.println("data="+data);
        System.out.println("stopdata="+stopdata);
        //data=[[a, ab, abc], [a, ab, abc, abcd]]
        //stopdata=[[q, qe], [a, ab, abc]]

题目六：判断一个字符串中的字符是否都在0-9，a-z和A-Z里

        Scanner cin=new Scanner(System.in);
        String data=cin.next();
        for(int i=0;i<data.length();i++){
            char target=data.charAt(i);
            if((target-'0'>=0 && target-'9'<=0) ||(target-'a'>=0 && target-'z'<=0) ||(target-'A'>=0 && target-'Z'<=0)){
                System.out.println(true);
            }else{
                System.out.println(false);
            }
        }

题目七：一个map集合（String，Integer）,根据值的大小从大到小排，如果值相同，则根据键的大小从小到大排。

1. map集合的默认排序规则是根据key值进行排序。

public static void main(String[] args) {
        Scanner cin=new Scanner(System.in);
        //6）对于一个map,先按值从大到小排序，如果值相同，则按照名字从小到大排序
        //几个对象:N
        //每个对象的名字：apple ben san kevin
        //每个对象的家产：10 20 35 10
        int size=cin.nextInt();
        cin.nextLine();
        List<String> name=new ArrayList<>();
        for(int i=0;i<size;i++){
            name.add(cin.next());
        }
        List<Integer> money=new ArrayList<>();
        for(int i=0;i<size;i++){
            money.add(cin.nextInt());
        }
        System.out.println(name+":"+money);
        //（2）获取对应的map集合
        Map<String,Integer> map=new HashMap<>();
        for(int i=0;i<size;i++){
            map.put(name.get(i),money.get(i));
        }
        //（3）把map集合装入list中
        List<Map.Entry<String,Integer>> list=new ArrayList<>(map.entrySet());

        //(4) 重新自定义Collections的排序规则
        Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                if(o1.getValue() ==o2.getValue()){
                    return o1.getKey().compareTo(o2.getKey());
                }else{
                    return o2.getValue()-o1.getValue();
                }
            }
        });
        System.out.println(list);
    }