Character
判断是否为字母或数字：
boolean res = Character.isLetterOrDigit(char);
转小写：
char res = Character.toLowerCase(char);
下一个字符：
'b' == (char) ('a' + 1);
Integer
最大值最小值：
int max = Integer.MAX_VALUE;
int min = Integer.MIN_VALUE;
比较相等：
Integer a = 1;
Integer b = 1;
a == b; // true
Integer c = 200;
Integer d = 200;
c == d; // false
Objects.equals(c, d); // true
Array
创建数组：
int[] array = new int[5];
int[] array = new int[]{1,2,3,4};
int[] array = {1,2,3,4};
int[][] array = {{1,2}, {3,4}};
引用：
array[3];
获取长度：
array.length;
快速初始化：
// 我们要给这个Map的值快速填充
Map<Integer, List<Integer>> map = new HashMap<>();
map.put(1, Arrays.asList(1, 2, 3));
map.put(2, Arrays.asList(2, 3, 4));
排序：
Arrays.sort(array);
// int[] 不能直接做降序排列
// 想做降序排列只能用Integer[]
Integer[] array = new Integer[2];
Arrays.sort(array, Comparitor.naturalOrder()); // 升序排列
Arrays.sort(array, Comparator.reverseOrder()); // 降序排列
二维数组排序：
int[][] array = new int[][]{{1, 2}, {2, 3}};
Arrays.sort(array, (o1, o2) -> o1[0] - o2[0]); // 按照二维数组的第一个元素从小到大排序
Arrays.sort(array, (o1, o2) -> o1[1] - o2[1]); // 按照二维数组的第二个元素从小到大排序
复制子数组：
// array: 原始数组，不包括to的结束索引
subArray = Arrays.copyOfRange(array, from, to);
// array = [4, 2, 5, 1, 6, 3, 7]
subArray = Arrays.copyOfRange(array, 0, 3);
// subArray = [4, 2, 5]
打印：
System.out.println(Arrays.toString(array));
填满：
int[] array = new int[];
int num;
Arrays.fill(array, num); // array全部元素等于num
String
创建字符串：
String string = "java";
指定位置的字符
char charAt3 = string.charAt(3); // charAt3 = 'a'
字符串相等：
String string1 = "abc";
String string2 = "abc";
string1.equals(string2);
字符串转整数：
String string = "123";
int integer = Integer.parseInt(string);
字符串长度：
int length = string.length();
截取字符串：
String sb = "abcdef";
String str = sb.substring(0, 1); // str = "a";
String str = sb.substring(1); // str = "bcdef"; 如果只有一个参数则为beginIndex
字符的位置：
String str = "abc";
int index = str.indexOf(b); // index = 1
字符串转字符数组：
String str;
char[] temp = str.toCharArray();
字符串分割：
String str = "hello world";
String[] word = str.split(" "); // word = ["hello", "world"]
// 这里必须是字符串
// 如果有两个空格连在一起，会在数组中加入一个""（空字符串）
将字符串数组合并为长字符串（中间插入）：
String[] words = new String[]{"hello", "world"};
String str = String.join(" ", words);
// str = "hello world";
字符串替换：
String str = "a! b";
str = str.replace("!", " "); // str = "a b";
// 字符或者字符串都可以替换
删除字符串头尾的空格：
String str = " abc ";
str.trim(); // str = "abc"
字符串拼接：
String str = "abc";
System.out.println(str + "def"); // 可以直接使用+
Stack
创建 stack：
Deque<Integer> stack = new ArrayDeque<>();
栈顶：
stack.peek()
入栈：
stack.push();
出栈：
stack.pop();
栈是否为空：
stack.isEmpty();
栈的长度：
stack.size();
ArrayList
创建列表：
List<Integer> array = new ArrayList<>();
List<Integer> array = new ArrayList<>(Arrays.asList(1, 2, 3, 4)); // 初始化值
添加元素：
array.add(1); // List只能在末尾添加元素，在中间插入元素会导致额外的内存开销，可以选择使用LinkedList
指定位置的元素：
array.get(0);
列表中是否存在某元素：
array.contains(0);
删除列表元素：
array.remove(0); // 删除array[0]
array.remove(Integer.valueOf(0)); // 删除元素0
列表大小：
array.size();
判断列表是否为空：
array.isEmpty();
清空列表：
array.clear();
升序排列：
array.sort(Comparator.naturalOrder());
降序排列：
array.sort(Comparator.reverseOrder());
修改值：
array.set(int index, int value);
反转：
Collections.reverse(array);
HashMap
创建一个哈希映射：
Map<Integer, Integer> map = new HashMap<>();
存储键值对（修改键值对）：
map.put(key, value);
// 如果不知道key存不存在
map.putIfAbsent(key, defVal);
获取 key 的内容：
map.get(key);
// 如果不知道key存不存在
map.getOrDefault(key, defVal);
// 常见用法
map.put(key, map.getOrDefault(key, 0) + 1);
计算：
// 键不存在时执行的操作
map.computeIfAbsent(key, k -> mappingFunc);
// 键存在时执行的操作
map.computeIfPresent(key, (k, v) -> mappingFunc);
查询是否存在 key：
map.containsKey(key);
键集合和值集合：
// 返回一个Collections<V>视图，keys组成的集合
map.keySet();
// 返回一个Collections<V>视图，values组成的集合
map.values();
// 假设map为{1: {1, 2, 3}, 2: {2, 3, 4}}
map.keySet = {1, 2};
map.values = {{1, 2, 3}, {2, 3, 4}};
遍历键值对：
// 遍历key
for (Integer key : map.keySet()) {
}
// 遍历value
for (Integer value : map.values()) {
}
// 如果需要同时访问键和值，使用map.entrySet()会更直观
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
Integer key = entry.getKey();
Integer value = entry.getValue();
}
是否为空：
map.isEmpty();
删除Key：
map.remove(key);
大小：
map.size();
HashSet
创建哈希表：
Set<Integer> set = new HashSet<>();
添加元素：
set.add();
判断元素是否存在：
set.contains(); // HashSet查找元素要优于ArrayList
删除元素：
set.remove();
清空：
set.clear();
遍历：
for (int temp : set) {
...
}
StringBuilder
创建 StringBuilder：
StringBuilder sb = new StringBuilder();
在末尾添加字符或字符串：
sb.append(char);
在末尾删除字符：
sb.deleteCharAt(sb.length() - 1);
长度：
sb.length();
转化为 String：
sb.toString();
取反：
sb.reverse();
插入：
sb.insert(0, "abcd"); // 在第0个元素插入"abcd"
清空：
sb.setLength(0);
取字符：
sb.charAt(i);
修改位置的字符：
sb.setCharAt(i);
Queue
创建queue:
Queue<Integer> q = new LinkedList<>();
加入元素：
q.offer(1);
删除元素（先进先出）：
q.poll();
队首元素：
q.peek();
队列大小：
q.size();
是否为空：
q.isEmpty();
队列清空：
q.clear();
Deque
创建Deque：
Deque<Integer> deque = new ArrayDeque<>();
队尾添加元素：
deque.offerLast(); // queue的用法
队首弹出元素：
deque.pollFirst(); // queue的用法
取队首元素：
deque.peekFirst(); // queue的用法
队首添加元素：
deque.offerFirst();
队尾弹出元素：
deque.pollLast();
取队尾元素：
deque.peekLast();
LinkedList
新建链表：
LinkedList<Integer> link = new LinkedList<>();
头部插入：
link.addFirst();
末尾插入：
link.addLast();
link.add();
指定位置插入：
link.add(int index, int Ele);
清空：
link.clear();
删除并返回第一个：
link.removeFirst();
删除并返回最后一个：
link.removeLast();
删除特定位置：
link.remove(int index);
删除特定元素：
link.remove(Object o);
link.remove(Integer.valueOf(2));
重设：
link.set();
头部取值：
link.getFirst();
尾部取值：
link.getLast();
特定位置取值：
link.get(int index);
是否存在：
link.contains(int key);
遍历：
// 不涉及元素增添或删除可以用for each
for (String element : link) {
}
// 涉及到则需要使用迭代器
Iterator<String> iterator = link.iterator(); // 初始化时指向哑节点
while (iterator.hasNext()) {
String element = iterator.next();
}
PriorityQueue
创建优先队列：
// 小根堆 (Min Heap)
PriorityQueue<Integer> pq = new PriorityQueue<>();
// 大根堆 (Max Heap)
PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
插入元素：
// 每次插入一个元素，时间复杂度是O(log k)，其中k是堆中当前元素的个数
// 将n个元素逐个push到一个空的大根堆的时间复杂度为O(n log n)
pq.offer();
取堆顶：
pq.peek();
弹出堆顶：
// 同样，pop一次的时间复杂度为O(log n)
// n个元素则为O(n log n)
pq.poll();
删除特定元素：
pq.remove();
堆大小：
pq.size();
AtomicInteger
多线程中的integer，线程操作对其是原子性的，不会被其他线程打断。
创建：
AtomicInteger a = new AtomicInteger(0);
获取当前值：
int value = a.get();
设置值：
a.set(2);
先获取再设置：
int oldValue = a.getAndSet(20);
先比较再设置：
boolean updated = a.compareAndSet(20, 43);
// 如果a == 20，则将a = 43，updated = true
// 如果a != 20，则将a不更新，updated = false
加一，返回加一后的值：
int incrementedValue = a.incrementAndGet();
减一，返回减一后的值：
int decrementedValue = a.decrementAndGet();
互相转换
// int转String
int i;
String str = String.valueOf(i);
// String转int
String str;
int i = Integer.parseInt(str);
// char转int
char ch;
int i = ch - '0';
// int转char
int i;
char ch = (char) (i + '0');
// String转char[]
String str;
char[] ch = str.toCharArray();
// char[]转String
char[] ch;
String str = Arrays.toString(ch); // 转化后有[]包裹
// char转String
char ch = 'a';
String str = ch + "";
// ArrayList转Integer[]
List<Integer> list;
Integer[] array = list.toArray(new Integer[list.size()]);
// Integer[]转ArrayList
Integer[] array;
List<Integer> list = Arrays.asList(array);
坑
Math.ceil：
double Math.ceil(double a); // 原函数
Math.ceil(24 / 23); // 1.0
Math.ceil(22 / 23); // 0.0
Math.ceil((double) 24 / 23); // 2.0
(int) Math.ceil((double) 24 / 23); // 2
Math.pow:
Math.pow(10, 9); // 如果想求次方必须要用pow函数，返回double
10 ^ 9; // 这里表示的是亦或而不是次方
二维数组：
int[][] a = new int[][] {{1, 2}, {3, 4}};
int[] b = a[1]; // b = [3, 4]
b[1] = 100;
// a = [[1, 2], [3, 100]]