Java基础语法系列（2）

1. 基本语法展示

1.3 栈和队列

如果需要使用栈和队列的话，就使用deque类型

    public static void main(String[] args) {

        Deque<String> queue=new LinkedList<>();
        queue.addFirst("b");
        queue.addFirst("a");
        queue.addLast("c");
        queue.addLast("d");
        queue.removeLast();
        queue.removeFirst();
        System.out.println("queue="+queue); //queue=[b, c]
    }

1.4 Set集合

    public static void main(String[] args) {
        //定义，排序，输出
        Set<String> sets=new TreeSet<>();   //注意：hashSet是无序的，TreeSet是默认字典序
        sets.add("apple");
        sets.add("apples");
        sets.add("bb");
        sets.add("ca");
        sets.add("ca");
        sets.add("ba");
        sets.add("cc");
        System.out.println("sets的值为="+sets); //sets的值为=[apple, apples, ba, bb, ca, cc]

        // 查看一个数是不是在set里面
        System.out.println(sets.contains("aa")); //false
    }

1.5 Map集合

    public static void main(String[] args) {
        //1)定义map(treeMap默认是按照key值进行排序)
        Map<String,Integer> map =new TreeMap<>();
        map.put("acc",2);
        map.put("abc",1);
        map.put("acd",5);
        map.put("abd",3);
        map.put("bcs",1);
        System.out.println("treeMap默认排序输出="+map); //treeMap默认排序输出={abc=1, abd=3, acc=2, acd=5, bcs=1}

        //2)输出map
        //2_1)先获取到key，在获取到value
        int id=-1;
        for(String key :map.keySet()){
            id++;
            int value =map.get(key);
            System.out.println("map["+id+"]=["+key+","+value+"]");
            //map[0]=[abc,1]
            //map[1]=[abd,3]
            //map[2]=[acc,2]
            //map[3]=[acd,5]
            //map[4]=[bcs,1]
        }

        //2_2)同时获取到key和value:map.entrySet()
        id=-1;
        for(Map.Entry<String,Integer> entry: map.entrySet()){
            id++;
            String key =entry.getKey();
            Integer value =entry.getValue();
            System.out.println("下面内容为同时读取可以和value的值");
            System.out.println("map["+id+"]=["+key+","+value+"]");
            //下面内容为同时读取可以和value的值
            //map[0]=[abc,1]
            //下面内容为同时读取可以和value的值
            //map[1]=[abd,3]
            //下面内容为同时读取可以和value的值
            //map[2]=[acc,2]
            //下面内容为同时读取可以和value的值
            //map[3]=[acd,5]
            //下面内容为同时读取可以和value的值
            //map[4]=[bcs,1]
        }



        //3)排序（按照map的key进行排序）:直接使用默认的选项即可以完成
          // 正序
        Map<String,Integer> map1 =new TreeMap<>();
        map1.put("acc",2);
        map1.put("abc",1);
        map1.put("acd",8);
        map1.put("abd",3);
        map1.put("bcs",1);
        System.out.println("treeMap默认排序输出="+map1);
        //treeMap默认排序输出={abc=1, abd=3, acc=2, acd=8, bcs=1}

        // 倒序
        Map<String,Integer> map2 =new TreeMap<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });
        map2.put("acc",2);
        map2.put("abc",1);
        map2.put("acd",8);
        map2.put("abd",3);
        map2.put("bcs",1);
        System.out.println("treeMap自定义倒序输出="+map2);
        //reeMap自定义倒序输出={bcs=1, acd=8, acc=2, abd=3, abc=1}


        //4）同时按照key和value进行排序：先用list起来，
        // 下面一行是核心最关键的操作：把map,entrySet用list集合给装起来！
        List<Map.Entry<String,Integer>> list =new ArrayList<>(map.entrySet());
        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());
                }
                return o2.getValue()-o1.getValue();
            }
        });
        System.out.println("排序后的list"+list);
        //排序后的list[acd=5, abd=3, acc=2, abc=1, bcs=1]
        //排序规则：先根据value的值从大到小排序，如果相同value，根据key的值从小到大排序
    }

List集合

主要使用函数Collections进行排序

    public static void main(String[] args) {


        //1)list集合是使用最广泛的集合，针对数组，map集合的自定义排序，都可以交给list集合来做

        //1)定义，赋值，拷贝
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(2);
        list.add(0);
        System.out.println(list.contains(2)); //true
        System.out.println("原始的list=" + list); //原始的list=[1, 3, 2, 0]
        List<Integer> listShallowCopy = list;    //浅拷贝：寻找找了一个分身
        List<Integer> listDeepCopy = new ArrayList<>(list);  // 深拷贝：与原来的独立
        list.add(100);
        System.out.println("listShallowCopy ==" + listShallowCopy); //listShallowCopy ==[1, 3, 2, 0, 100]
        System.out.println("listDeepCopy ==" + listDeepCopy);// listDeepCopy ==[1, 3, 2, 0]

        //2) 遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.println("list[" + i + "]=" + list.get(i));
            //list[0]=1
            //list[1]=3
            //list[2]=2
            //list[3]=0
            //list[4]=100
        }

        //3) 排序
        // 针对一般数据类型String排序
        List<String> sortList = new ArrayList<>();
        sortList.add("aa");
        sortList.add("ba");
        sortList.add("ab");
        sortList.add("bb");
        sortList.add("bc");
        sortList.add("ac");
        System.out.println("sortList原始排序=" + sortList);
        //sortList原始排序=[aa, ba, ab, bb, bc, ac]
        Collections.sort(sortList);
        System.out.println("sortList使用sort排序=" + sortList); // 默认正序排列
        //sortList使用sort排序=[aa, ab, ac, ba, bb, bc]
        Collections.sort(sortList, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });
        System.out.println("sortList使用sort自定义排序=" + sortList); // 自定义逆序排列
        //sortList使用sort自定义排序=[bc, bb, ba, ac, ab, aa]

        // 针对数组排序
        List<int[]> sortIntList = new ArrayList<>();
        sortIntList.add(new int[]{2, 2, 3});
        sortIntList.add(new int[]{2, 3, 3});
        sortIntList.add(new int[]{1, 2, 3});
        sortIntList.add(new int[]{3, 2, 3});
        System.out.println("sortIntList原始排序=" + Arrays.deepToString(listToArray(sortIntList)));
        //sortIntList原始排序=[[2, 2, 3], [2, 3, 3], [1, 2, 3], [3, 2, 3]]
        
        
        // 自定义规则：第一个数从小到大排列，第一个数相等，第二个数从大到小排列
        Collections.sort(sortIntList, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[0]==o2[0]){
                    return o2[1]-o1[1];
                }
                return o1[0]-o2[0];
            }
        });
        System.out.println("sortIntList自定义排序=" + Arrays.deepToString(listToArray(sortIntList)));
        //sortIntList自定义排序=[[1, 2, 3], [2, 3, 3], [2, 2, 3], [3, 2, 3]]

        // 针对map集合排序（先根据value值，从大到小排序，如果相等，再看key的值）

    }

    public static int[][] listToArray(List<int[]> list) {
        int[][] resultInt = new int[list.size()][3];
        for (int i = 0; i < list.size(); i++) {
            resultInt[i] = list.get(i);
        }
        return resultInt;
    }```