Java Cheat Sheet

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[] arr = new int[5];
int[] arr = new int[]{1,2,3,4};
int[] arr = {1,2,3,4};
int[][] arr = {{1,2}, {3,4}};

引用

arr[3];

获取长度

arr.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(arr);
// int[] 不能直接做降序排列
// 想做降序排列只能用Integer[]
Integer[] arr = new Integer[2];
Arrays.sort(arr, Comparitor.naturalOrder());	// 升序排列
Arrays.sort(arr, Comparator.reverseOrder());	// 降序排列

二维数组排序

int[][] arr = new int[][]{{1, 2}, {2, 3}};
Arrays.sort(arr, (o1, o2) -> o1[0] - o2[0]);	// 按照二维数组的第一个元素从小到大排序
Arrays.sort(arr, (o1, o2) -> o1[1] - o2[1]);	// 按照二维数组的第二个元素从小到大排序

复制子数组

// arr: 原始数组，不包括to的结束索引
subArray = Arrays.copyOfRange(arr, from, to);

// arr = [4, 2, 5, 1, 6, 3, 7]
subArray = Arrays.copyOfRange(arr, 0, 3);
// subArray = [4, 2, 5]

打印

// 打印一维数组
System.out.println(Arrays.toString(arr));

// 打印多维数组
System.out.println(Arrays.deepToString(arr));

填满

int[] arr = new int[];
int num;
Arrays.fill(arr, num);	// arr全部元素等于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");	// 可以直接使用+

int a = 1;
String s = a + "_" + str;
System.out.println(s);	// 带有int的也可以直接拼接

Stack

创建 stack

Deque<Integer> stack = new ArrayDeque<>();

栈顶

stack.peek()

入栈

stack.push();

出栈

stack.pop();

栈是否为空

stack.isEmpty();

栈的长度

stack.size();

ArrayList

创建列表

List<Integer> list = new ArrayList<>();
List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4));	// 初始化值

添加元素

list.add(1);	// List只能在末尾添加元素，在中间插入元素会导致额外的内存开销，可以选择使用LinkedList

指定位置的元素

list.get(0);

列表中是否存在某元素

list.contains(0);

删除列表元素

list.remove(0);	// 删除list[0]
list.remove(Integer.valueOf(0));	// 删除元素0

列表大小

list.size();

判断列表是否为空

list.isEmpty();

清空列表

list.clear();

升序排列

list.sort(Comparator.naturalOrder());

降序排列

list.sort(Comparator.reverseOrder());

修改值

list.set(int index, int value);

反转

Collections.reverse(list);

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 = 1;
String str = Integer.toString(i);
String str = String.valueOf(i);

// String转int
String str = "1";
int i = Integer.parseInt(str);

// int转char
int i = 1;
char ch = (char) (i + '0');

// char转int
char c = '1';
int i = c - '0';	// 仅适用于'0' - '9'
int i = Character.getNumericValue(c);

// String转char[]
String str = "12";
char[] c = str.toCharArray();

// char[]转String
char[] c = new char[]{'1', '2'};
String str = Arrays.toString(c);	// 转化后有[]包裹，还有个空格，str = "[1, 2]"
String str = new String(c);			// 没有[]，中间没有空格，str = "12"

// char转String
char c = 'a';
String str = c + "";
String str = Character.toString(c);
String str = String.valueOf(c);

// 快速生成ArrayList，相当于int[]转ArrayList吧
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2));
// 或者Java 8+
import java.util.stream.Collectors;
int[] arr = new int[]{1, 2};
ArrayList<Integer> list = Arrays.stream(arr).boxed().collect(Collectors.toCollection(ArrayList::new));

// ArrayList转int[]
// 建议写for循环
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2));
int[] arr = list.stream().mapToInt(Integer::intValue).toArray();

// Integer[]转ArrayList
Integer[] arr = new Integer[]{1, 2};
List<Integer> list = Arrays.asList(arr);

// ArrayList转Integer[]
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2));
Integer[] arr = list.toArray(new Integer[0]);

坑

Math

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;
System.out.println(Arrays.deepToString(a));	// a = [[1, 2], [3, 100]]

当int[]作为HashMap的键

Map<int[], Integer> map = new HashMap<>();
int[] cur = new int[]{1, 0};
map.put(new int[]{1, 0}, 1);
System.out.println(map.containsKey(cur));	// false，因为引用不一样
// 如果为Integer[]同样输出为false

Map<int[], Integer> map = new HashMap<>();
int[] cur = new int[]{1, 0};
map.put(cur, 1);
System.out.println(map.containsKey(cur));	// true，引用相同

Map<List<Integer>, Integer> map = new HashMap<>();
map.put(Arrays.asList(1, 0), 1);
System.out.println(map.containsKey(Arrays.asList(1, 0)));	// true，值相等

Map<List<Integer>, Integer> map = new HashMap<>();
map.put(new ArrayList<>(Arrays.asList(1, 0)), 1);
System.out.println(map.containsKey(Arrays.asList(1, 0)));	// true

作为函数参数

// 假如传入参数为值类型（通常储存在Stack，比如int, boolean）
// 主函数的不会随之修改
private static void modifyInt(int a) {
    a = 10;
}

public static void main(String[] args) {
    int a = 1;
    modifyInt(a);
	System.out.println(a);	// 1
}

// 假如传入参数为引用类型（通常储存在Heap，比如int[], ArrayList）
// 传入的是变量的地址，因此也算值传递，而且主函数的会随之修改
private static void modifyArr(int[] arr) {
    arr[1] = 10;
}

private static void modifyList(List<Integer> list) {
    list.set(1, 10);
}

// String很特别，它属于引用类型，但是值不会变有点像值类型
// 这是因为String具有不可变性，Immutability，一旦创建就不会被修改
private static void modifyStr(String str) {
    str = "STR";
}

public static void main(String[] args) {
    String str = "str";
    int[] arr = new int[]{1, 2};
    List<Integer> list = new ArrayList<>(Arrays.asList(1, 2));

    modifyArr(arr);
    modifyList(list);
    modifyStr(str);

    System.out.println(Arrays.toString(arr));   // [1, 10]
    System.out.println(list);                   // [1, 10]
    System.out.println(str);                    // str，没变
}

// 但是如果在函数中对数组重新赋值，则主函数不受影响，因为地址的值没有变
public static void reassign(int[] arr) {
    arr = new int[]{3, 4}; // 重新分配引用
}

public static void main(String[] args) {
    int[] arr = {1, 2};
    reassign(arr);
    System.out.println(Arrays.toString(arr)); // 输出 [1, 2]
}

Character#

Integer#

Array#

String#

Stack#

ArrayList#

HashMap#

HashSet#

StringBuilder#

Queue#

Deque#

LinkedList#

PriorityQueue#

AtomicInteger#

互相转换#

坑#

Math#

值和引用#