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;
排序：
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]); // 按照二维数组的第二个元素从小到大排序
打印：
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"
Stack
创建 stack：
Deque<Integer> stack = new ArrayDeque<Integer>();
栈顶：
stack.peek()
入栈：
stack.push();
出栈：
stack.pop();
栈是否为空：
stack.isEmpty();
栈的长度：
stack.size();
ArrayList
创建列表：
List<Integer> array = new ArrayList<Integer>();
List<Integer> array = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4)); // 初始化值
添加元素：
array.add(1);
指定位置的元素：
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<Integer, Integer>();
存储键值对（修改键值对）：
map.put(key, value);
获取 key 的内容：
map.get(key);
如果不知道有没有内容：
map.getOrDefault(key, default);
// 如果存在key，返回key的值
// 如果不存在key，返回default
map.put(key, map.getOrDefault(key, 0) + 1);
查询是否存在 key：
map.containsKey(key);
遍历键值对：
// 遍历key
for (Integer key : map.keySet()) {
}
// 遍历value
for (Integer value : map.values()) {
}
是否为空：
map.isEmpty();
删除Key：
map.remove(key);
大小：
map.size();
排序：
Map<Integer, Integer> map = new HashMap<Integer, Integer>(); // 创建一个哈希映射
List<Map.Entry<Integer, Integer>> mapList = new ArrayList<Map.Entry<Integer, Integer>>(map.entrySet()); // 我们无法对HashMap排序，需要把HashMap转换为ArrayList再排序
Collections.sort(mapList, new Comparator<Map.Entry<Integer, Integer>>() {
public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
return (o2.getValue() - o1.getValue()); // 按照值的大小，从大到小排序
}
});
mapList.get(i).getKey(); // 排序后第i个的键
mapList.get(i).getValue(); // 排序后第i个的值
HashSet
创建哈希表：
Set<Integer> set = new HashSet<Integer>();
添加元素：
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> queue = new LinkedList<Integer>();
加入元素：
queue.offer(1);
删除元素（先进先出）：
queue.poll();
队首元素：
queue.peek();
队列大小：
queue.size();
是否为空：
queue.isEmpty();
队列清空：
queue.clear();
Deque
创建Deque：
Deque<Integer> deque = new ArrayDeque<Integer>();
队尾添加元素：
deque.offerLast(); // queue的用法
队首弹出元素：
deque.pollFirst(); // queue的用法
取队首元素：
deque.peekFirst(); // queue的用法
队首添加元素：
deque.offerFirst();
队尾弹出元素：
deque.pollLast();
取队尾元素：
deque.peekLast();
LinkedList
新建链表：
LinkedList<Integer> link = new LinkedList<Integer>();
头部插入：
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
创建优先队列：
PriorityQueue<Integer> heap = new PriorityQueue<Integer>();
// 如果不加Comparator默认为小根堆
// 即只有第一个元素是最小元素
插入元素：
heap.offer();
取堆顶：
heap.peek();
弹出堆顶：
heap.poll();
删除特定元素：
heap.remove();
堆大小：
heap.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 = String.valueOf(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]]