常规代码模板

核心代码模式

函数名，输入参数，输出参数类型都已经写好，只需要写函数体即可。

ACM模式

啥都没有，需要自己写

这里提供一个模板，主要是读入示例，自己构建出输入参数，那么就可以转化为核心代码模式了，方便过渡。

读入大致是分为两类，数字和字符串。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);// 获取控制台对象
        int T = sc.nextInt();//如果一个示例有多组数据 T就是组数
        while(T-- >0){// 循环读入T组数据，处理后输出每组数据的结果
            int n = sc.nextInt();// 该示例中 需要先读取一个 n 表示接下来n个数是x数组
            int[] nums = new int[n];
            String[] strs = new String[n];
            for(int i = 0; i < n; ++i){
                nums[i] = sc.nextInt();
            }
            for(int i = 0; i < n; ++i){
                strs[i] = sc.nextLine();// nextLine()读取字符串
            }
            System.out.println(getResult(nums,strs));
        }
    }

    private static int getResult(int[] nums, String[] strs) {
        //核心代码模式
        // write your code here
        return -1;
    }

}

Map Set 遍历

/*
* 测试List遍历的方式
* */
public class TestArrayList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");

        //方式一，for循环遍历,通过get()方法
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }


        //方式四,增强for循环  foreach
        for (String str : list) {
            System.out.println(str);
        }

        //方式五，转化数组
      　　　  String[] a = new String[3];
        String[] aa = list.toArray(a);
        for (int i = 0; i < aa.length; i++) {
            System.out.println(aa[i]);
        }
    }
}
————————————————
版权声明：本文为CSDN博主「yuyinghe0612」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/yuyinghe0612/article/details/80549443

public class TestHashMap {
    public static void main(String[] args) {

        Map<String, String> map = new HashMap<>();
        map.put("a", "2000");
        map.put("b", "3000");

        //方式一、在for-each循环中使用entrySet来遍历
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        for (Map.Entry<String, String> entry : entrySet) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println("key=" +key+"  value="+value);
        }

        //方式二、在for-each循环中通过键找值遍历
        for (String key : map.keySet()) {
            System.out.println("key=" + key+"  value="+map.get(key));
        }

        //只打印键值keys
        for (String key : map.keySet()) {
            System.out.println("key=" + key);
        }
        //只打印values
        for (String value : map.values()) {
            System.out.println("value=" + value);
        }


    }
}
————————————————
版权声明：本文为CSDN博主「yuyinghe0612」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/yuyinghe0612/article/details/80549443

map不能用增强for循环。

自定义比较器

算法题中会出现可以使用库函数sort 的情景，不过往往不是简单的sort，在java中

sort默认是升序，如何实现降序呢？如果现在是对nums(int[2]) 中的第0列数据升序，在此基础上第1列数据降序，又怎么做呢？

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;

/**
 * @Description
 * @create 2022/2/14 - 21:27
 */
public class compareDemo {
    public static void main(String[] args) {
        int[][] nums = new int[3][2];
        nums[0][0] = 12;
        nums[0][1] = 0;
        nums[1][0] = 15;
        nums[1][1] = 50;
        nums[2][0] = 15;
        nums[2][1] = 90;
        for (int[] num : nums) {
            System.out.println(num[0] + " " + num[1]);
        }
        System.out.println("=========排序后==========");
        Arrays.sort(nums,new Comparator<int[]>(){
            @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[0]!=o2[0]){
                    return o1[0] - o2[0];// 升序
                }else{
                    return o2[1] - o1[1];// 降序
                }
            }
        });
        for (int[] num : nums) {
            System.out.println(num[0] + " " + num[1]);
        }

        Integer[] nums1 = new Integer[]{5,7,8,2,3};
        Arrays.sort(nums1);// 升序
        for (int i : nums1) {
            System.out.println(i);
        }
        Arrays.sort(nums1, Collections.reverseOrder());// 降序
        for (int i : nums1) {
            System.out.println(i);
        }
        Arrays.sort(nums1,new Comparator<Integer>(){
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1; // 降序
            }
        });
        for (int i : nums1) {
            System.out.println(i);
        }
    }
}

sort 自定义比较器不能对 int[] 等基本数据类型的数组进行排序，只适用于object[]。

所以对于int[] 要不然转化为引用数据类型的数组，再用库函数，要不然自己写快排之类的算法。

建立大跟堆、小根堆

import java.util.Comparator;
import java.util.PriorityQueue;

/**
 * @Description
 * @create 2022/2/14 - 21:58
 */
public class heapDemo {
    public static void main(String[] args) {

        PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;//小根堆
            }
        });
        pq.add(1); pq.add(5); pq.add(10);
        PriorityQueue<Integer> pq2 = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;//大根堆
            }
        });
        pq2.add(1); pq2.add(5); pq2.add(10);

        System.out.println(pq.peek());
        System.out.println(pq2.peek());

        int[][] nums = new int[3][2];
        nums[0][0] = 12;
        nums[0][1] = 0;
        nums[1][0] = 15;
        nums[1][1] = 50;
        nums[2][0] = 15;
        nums[2][1] = 90;
        for (int[] num : nums) {
            System.out.println(num[0] + " " + num[1]);
        }
        PriorityQueue<int[]> pqArr = new PriorityQueue<>(new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[0]!=o2[0]){
                    return o1[0] - o2[0];// 升序
                }else{
                    return o2[1] - o1[1];// 降序
                }
            }
        });
        pqArr.add(nums[0]);
        pqArr.add(nums[1]);
        pqArr.add(nums[2]);
        while(!pqArr.isEmpty()) {
            System.out.println(pqArr.peek()[0] + " " + pqArr.poll()[1]);
        }
    }
}