环境配置

vscode配置java

  • 下载jdk，笔者下载的是jdk15.0.1
    20240311145620
    下载完之后安装即可
  • 环境变量配置
    打开系统环境变量-点击环境变量-点击系统变量的path-编辑-新建，添加刚刚的安装目录的bin和jre\bin
    20240311145829
    20240311150012
    20240311150158
  • 查看配置正确
    win+r输入cmd,输入java -version 和 javac -version，如果出现下图所示配置正确
    20240311150420
  • 下载vscode的java插件
  • 编写程序
    1
    2
    3
    4
    5
    6
    // import java.util.*;
    public class a {
    	public static void main(String[] args) {
    		System.out.println("Hello World");
    	}
    }
    20240311150528
  • 可以在.gitignore中添加运行生成的.class文件
    20240311150747

sublime 配置java环境

  • 下载jdk和前文配置vscode
  • 新建编译系统
    工具-编译系统-新建编译系统-复制进去-保存为java.sublime-build
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    {
        "cmd": ["javac", "$file_name", "&&", "start","cmd", "/k", "java", "$file_base_name"],
        "shell": true,
        "file_regex": "^(...*?):([0-9]*):?([0-9]*)",
        "working_dir": "$file_path",
        "selector": "source.java",
        "encoding": "GBK",
        "variants": [
            {
                "name": "Terminal",
                "cmd": ["javac", "$file_name", "&&", "start","cmd", "/k", "java", "$file_base_name"],
                "shell_cmd": "",
            },
            {
                "name": "Build",
                "quiet": true,
                "shell_cmd": "javac $file_name && java $file_base_name && del $file_base_name.class",
            }
        ]
    }

sublime添加代码模板记得空出class位置

工具-插件开发-新建代码片段-复制代码-保存为-“jm.sublime-snippet”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
<snippet>
    <content><![CDATA[
//$TM_FILEPATH
import java.io.*;
import java.util.StringTokenizer;
import java.util.Scanner;
public class ${1:} {
    public static Reader in;
    public static PrintWriter out;
    public static void main(String[] args) {
        out = new PrintWriter(new BufferedOutputStream(System.out));
        in = new Reader();
        int t = in.nextInt();
        while (t-- > 0)
            solve();
        out.close();
    }
    static void solve(){
        int n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
        char[][] c = new char[n][m];
        for (int i = 0; i < n; i++) {
            c[i] = in.nextLine().toCharArray();
        }
    }
 
    static class Reader {
        private BufferedReader br;
        private StringTokenizer st;
 
        Reader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }
 
        boolean hasNext(){
            try {
                while (st == null || !st.hasMoreElements()) {
                    st = new StringTokenizer(br.readLine());
                }
            }catch (Exception e){
                return false;
            }
            return true;
        }
 
        String next() {
            try {
                while (st == null || !st.hasMoreTokens()) {
                    st = new StringTokenizer(br.readLine());
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return st.nextToken();
        }
 
        int nextInt() {
            return Integer.parseInt(next());
        }
 
        int[] nextIntArray(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++)
                arr[i] = nextInt();
            return arr;
        }
 
        long[] nextLongArray(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++)
                arr[i] = nextLong();
            return arr;
        }
 
        long nextLong() {
            return Long.parseLong(next());
        }
 
        String nextLine() {
            String s = "";
            try {
                s = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return s;
        }
    }
}
]]></content>
    <tabTrigger>jp</tabTrigger>
</snippet>

输入jp(自己设置的)就可以出现代码模板
20240311153902

数据结构常用

邻接表

1
2
List<int[]>[] g = new ArrayList[N]; // 邻接表
Arrays.setAll(g, i -> new ArrayList<>());

List<int[]>[]:

  • 这是一个数组，每个元素都是可以存储整数数组(int[])的list。
  • 数组的大小在初始化时固定，并且在其生命周期中不能更改。
  • 这种结构允许通过索引直接访问列表，访问时间为O(1)。

数组初始化

1
2
int[] dist = new int[n + 5];
Arrays.fill(dist, Integer.MAX_VALUE );

双端队列

1
Deque<Integer> q = new LinkedList<>();

快读

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68


public static Reader in;
public static void mian(String[] args){
    in = new Reader();
}
static class Reader {
    private final BufferedReader br;
    private StringTokenizer st;

    Reader() {
        br = new BufferedReader(new InputStreamReader(System.in));
    }

    boolean hasNext() {
        try {
            while (st == null || !st.hasMoreElements()) {
                st = new StringTokenizer(br.readLine());
            }
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    String next() {
        try {
            while (st == null || !st.hasMoreTokens()) {
                st = new StringTokenizer(br.readLine());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return st.nextToken();
    }

    int nextInt() {
        return Integer.parseInt(next());
    }

    int[] nextIntArray(int n) {
        int[] arr = new int[n];
        for (int i = 0; i < n; i++)
            arr[i] = nextInt();
        return arr;
    }

    long[] nextLongArray(int n) {
        long[] arr = new long[n];
        for (int i = 0; i < n; i++)
            arr[i] = nextLong();
        return arr;
    }

    long nextLong() {
        return Long.parseLong(next());
    }

    String nextLine() {
        String s = "";
        try {
            s = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return s;
    }
}

1
2
3
4
private final Set<Integer> s = new HashSet<>();
s.add(val);

s.contains(val);

List

List: List是一个接口，它定义了一个可以按顺序访问的元素集合的基本操作和方法。List是Java集合框架的一部分，它提供了一种方式来存储有序的元素集合。List是一个接口，所以你不能直接实例化一个List。

ArrayList: ArrayList是List接口的一个具体实现。它使用数组的结构来存储元素，这使得元素的随机访问变得非常快。但是，添加或删除元素（尤其是列表的前部）可能比在LinkedList中慢，因为这可能需要移动数组中的其他元素。ArrayList提供了List接口的所有标准操作，并且还添加了一些其他的功能，如确保容量和增加容量。

1
2
3
List<List<Integer>> rooms = new ArrayList<>();
下标从0开始，访问x下标的元素。
rooms.get(x)

ArrayList

ArrayList是Java中最常用的集合之一，提供了一系列功能来处理动态数组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 访问元素
List<Integer> l = new ArrayList<>();
l.get(int index);

for(Integer num : list){

}
//大小
size()
//判空
isEmpty()
//搜索
contains(Object o) //检查列表中是否存在指定的元素。
indexOf(Object o) //返回列表中指定元素的第一个出现的索引，如果列表不包含该元素，则返回-1。
lastIndexOf(Object o) //返回列表中指定元素的最后一个出现的索引，如果列表不包含该元素，则返回-1。
//范围
subList(int l, int r) // 返回一个指定范围的新列表，不会改变原有列表
1
2
//转换
toArray() //将列表转换为一个数组

批量操作

1
clear() // 移除列表中的所有元素。

排序

1
2
people.sort((p1, p2) -> p1.age - p2.age);
按照年龄升序