小知识，大挑战！本文正在参与“程序员必备小知识”创作活动。
前言
本文主要记录一些 Java 函数，这些函数经常会在刷 LeetCode 时使用。因为经常忘记，所以在此记录。
HashMap
初始化
HashMap<String, Integer> hashmap = new HashMap<>();
添加 Key
hashmap.put("aa", 1);
删除 Key
hashmap.remove("key"); // 成功：返回 Key 对应的 Value，失败返回 null
获取元素
hashmap.get("key"); // 获取元素值
hashmap.getOrDefault("key", defaultValue); // 获取元素值，如果 Key 不存在时，返回 defaultValue
元素遍历
Iterator iterator = hashmap.entrySet().iterator();
while (iterator.hashNext()) {
String key = (String) iterator.next();
Integer value = (Integer) hashmap.get("key");
}
判断 Key 或 Value 是否存在
hashmap.containsKey("key");
hashmap.containsValue(value);
替换元素
hashmap.replace("aa",2); // 存在 key，会替换原来的 value，并返回旧 value，同 put 方法。对于不存在的方法，replace 方法什么都不做，这是和 put 的区别。
集合遍历
Map<Character, Integer> map = new HashMap<Character, Integer>();
for (Map.Entry<Character,Integer> entry : map.entrySet()) {
int value = entry.getValue();
}
ArrayList
初始化
List<Integer> list = new ArrayList<>();
排序
Collections.sort(list);
StringBuilder
初始化
StringBuilder stringBuilder = new StringBuilder(100);
拼接字符串
stringBuilder.append("abc"); // 将 abc 拼接在原来字符串后面
转化成 String
String s = stringBuilder.toString();
获取字符串长度
int length = stringBuilder.length();
字符串截取
String s1 = stringBuilder.substring(int start);
String s2 = stringBuilder.substring(int start, int end); // 前闭后开
字符串清空
stringBuilder.delete(0, stringBuilder.length());
字符串反转
stringBuilder = stringBuilder.reverse();
数字变字符
stringBuilder.append((char)('A' + 1)); // (char)('A' + 1) == B
Stack
初始化
Stack<Integer> stack = new Stack<>();
判断栈是否为空
stack.empty();
入栈
stack.push(1);
出栈
stack.pop();
获取栈顶元素，但是不弹出
stack.peak();
int[] 数组
初始化
int[] a = new int[10];
有元素时初始化数组
int[] a = new int[]{1,2};
数组排序（递增）
Arrays.sort(a);
数组排序（自定义排序）
Arrays.sort(a, new Comparator<int[]>() {
public int compare(int[] a1, int[] a2) {
return a1[0] - a2[0];
}
});
String
判断字符串是否相等
if (A.equals(B)) {
}
判断字符串是否相等（区分大小写）
if (A.equalsIgnoreCase(B)) {
}
字符串转整数
String s = "123";
byte a = Byte.parseByte(s);
short b = Short.parseShort(s);
int c = Integer.parseInt(s);
long d = Long.parseLong(s);
Float e = Float.parseFloat(s);
Double f = Double.parseDouble(s);
boolean g = Boolean.parseBoolean(s);
char h = Character.parseCharacter(s);
字符串转 char 数组
char[] ch = s.toCharArray();
Character
判断一个字符是否是字母或者数字
Character.isLetterOrDigit(char ch);
字符转小写
Character.toLowerCase(char ch);
char
获取 char 数组长度
int length = s.length;
AtomicInteger（原子操作）
初始化
AtomicInteger ai = new AtomicInteger(0);
加 1 后返回新值
ai.incrementAndGet();
获取当前值
int a = ai.get();
添加值并返回新值
ai.addAndGet(int value);
HashSet
初始化
HashSet<Integer> hashset = new HashSet<>();
添加元素
hashset.add(1);
判断元素是否存在
hashset.contains(1);
删除元素
hashset.remove(1);
计算大小
hashset.size();
迭代
for (int i : hashset) {
System.out.println(i);
}
Deque（双端队列）
初始化
Deque<Integer> deque = new LinkedList<>();
添加元素到队尾
deque.offerLast(1); // 1
deque.offerLast(2); // 2 -> 1
deque.offerLast(3); // 3 -> 2 -> 1
获取队首元素并删除
System.out.println(deque.pollFirst()); // 1 剩下 3 -> 2
获取队首元素但不删除
System.out.println(deque.peekFirst()) // 2 剩下 3 -> 2
添加元素到队首
deque.offerFirst(4); // 3 -> 2 -> 4
获取队尾元素并删除
System.out.println(deque.pollLast()); // 3 剩余 2 -> 4
获取队尾元素但不删除
System.out.println(deque.peekLast()); // 2 剩余 2 -> 4
Queue
初始化
Queue<Integer> queue = new LinkedList<>();
添加元素到队尾
queue.offer(1); // 1
queue.offer(2); // 2 -> 1
queue.offer(3); // 3 -> 2 -> 1
取队首元素并删除（获取不到返回 false 或 null）
System.out.println(queue.poll()); // 1 剩余 3 -> 2
System.out.println(queue.poll()); // 2 剩余 3
System.out.println(queue.poll()); // 3
System.out.println(queue.poll()); // null 因为队列为空
获取队首元素但不删除（获取不到返回 null 或 false）
queue.offer(4); // 4
System.out.println(queue.peek()); // 4
PriorityQueue
初始化
PriorityQueue<Integer> queue = new PriorityQueue<>();
添加元素
queue.offer(1);
弹出元素
queue.poll(); // 弹出 1
