Java 刷题常用集合类、函数及类型转换指南

list.add(1); list.add(2); list.add(3); list.add(4); list.add(5); list.remove(0); // 2 3 4 5 list.remove(list.size()-1); // 2 3 4 

5. 检查元素

1) 检查集合是否包含某个元素：

boolean contains = list.contains(10); // 检查是否包含值为 10 的元素 false 

2) 检查集合是否为空：

boolean isEmpty = list.isEmpty(); // 检查 ArrayList 是否为空 

6. 遍历 ArrayList

1) 使用普通 for 循环遍历

for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); // 访问每一个元素 }

2) 使用增强 for 循环遍历：

for (Integer num : list) { System.out.println(num); }

3) 使用迭代器遍历：

Iterator<Integer> iterator = list.iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); }

LinkedList

LinkedList 和 ArrayList 命令上大体相同，他们都实现了 List 接口。

但 LinkedList 实现了 Queue 和 Deque 接口，可以用作队列（FIFO）和栈（LIFO）。

Stack

1. 创建 Stack 对象

用于创建一个新的栈，常用于存储数字、字符或其他对象。

Stack<Integer> stack = new Stack<>(); 

2. 压入元素 (push)

push(E item) 方法用于将元素推入栈顶。

stack.push(10); stack.push(20); stack.push(30); // 10 20 30

3. 弹出元素 (pop)

pop() 方法用于移除并返回栈顶元素。如果栈为空，调用该方法会抛出 EmptyStackException 异常。需要注意栈为空时使用时需检查栈是否为空，避免异常。

int topElement = stack.pop(); // 30

4. 查看栈顶元素 (peek)

peek() 方法用于查看栈顶元素，但不会移除它。如果栈为空，同样会抛出 EmptyStackException 异常。

int topElement = stack.peek(); // stack{10,20} 20 

5. 检查栈是否为空 (empty)

empty() 方法返回 true 如果栈为空，false 如果栈不为空。这个方法在判断栈是否可以继续操作时非常有用。

boolean isEmpty = stack.empty(); // false 

Queue

1. 创建队列对象

Queue<Integer> queue = new LinkedList<>(); // 或使用 ArrayDeque，性能更好 Queue<Integer> queue = new ArrayDeque<>(); 

2. 添加元素 (add 和 offer)

在刷题中，offer 比较常用。

queue.add(10); // 抛出异常：如果队列已满，则抛出 IllegalStateException queue.offer(20); // 返回 true/false：如果队列已满，返回 false 

3. 移除元素 (poll 和 remove)

poll() 更常用。

int element = queue.poll(); // 移除并返回队列头部的元素，队列为空时返回 null int element = queue.remove(); // 移除并返回队列头部的元素，队列为空时抛出 NoSuchElementException 

4. 查看队列头部元素 (peek 和 element)

peek() 方法更常用，因为它更安全，不会抛出异常。

int element = queue.peek(); // 返回队列头部的元素，队列为空时返回 null int element = queue.element(); // 返回队列头部的元素，队列为空时抛出 NoSuchElementException 

5. 队列大小 (size)

返回队列中元素的数量，通常用于判断队列是否为空。

int size = queue.size(); // 获取队列中元素的数量 

6. 检查队列是否为空 (isEmpty)

返回 true 如果队列为空，false 如果队列不为空。常用于循环前检查队列是否有元素。

boolean isEmpty = queue.isEmpty(); // 判断队列是否为空 

PriorityQueue

PriorityQueue 跟 Queue 命令大体相似，但它也是刷题中经常遇到的，因为它可以创建大小根堆。

大根堆（Max-Heap）：每个父节点的值大于或等于其子节点的值，根节点为最大元素。小根堆（Min-Heap）：每个父节点的值小于或等于其子节点的值，根节点为最小元素。

小根堆：

// 创建小根堆 //默认就是小根堆 PriorityQueue<Integer> minHeap = new PriorityQueue<>(); // 向小根堆插入元素 minHeap.offer(10); minHeap.offer(20); minHeap.offer(5); minHeap.offer(30); // 输出堆顶元素（最小元素） System.out.println("小根堆堆顶元素：" + minHeap.peek()); // 输出 5 // 删除堆顶元素（最小元素） System.out.println("删除堆顶元素：" + minHeap.poll()); // 输出 5 // 输出删除堆顶后的堆顶元素 System.out.println("删除后堆顶元素：" + minHeap.peek()); // 输出 10

大根堆

// 创建大根堆（使用自定义的比较器实现降序排列） PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a,b)-> b - a); // PriorityQueue<Integer> max = new PriorityQueue<>(Comparator.reverseOrder()); // 向大根堆插入元素 maxHeap.offer(10); maxHeap.offer(20); maxHeap.offer(5); maxHeap.offer(30); // 输出堆顶元素（最大元素） System.out.println("大根堆堆顶元素：" + maxHeap.peek()); // 输出 30 // 删除堆顶元素（最大元素） System.out.println("删除堆顶元素：" + maxHeap.poll()); // 输出 30 // 输出删除堆顶后的堆顶元素 System.out.println("删除后堆顶元素：" + maxHeap.peek()); // 输出 20

Set

1. 创建 Set 实例

3 种方法任选一种。

Set<Integer> set = new HashSet<>(); Set<Integer> linkedSet = new LinkedHashSet<>(); Set<Integer> treeSet = new TreeSet<>(); 

2. 添加元素

set.add(1); // 添加元素，如果元素已存在，返回 false set.add(2); set.add(3); 

3. 删除元素

set.remove(2); // 删除元素 2 

4. 检查是否包含某个元素

boolean contains = set.contains(3); // 返回 true 如果包含元素 3 

5. 获取集合的大小

int size = set.size(); // 返回集合的元素个数 

6. 判断集合是否为空

boolean isEmpty = set.isEmpty(); // 如果集合为空，返回 true 

7. 遍历

1）使用迭代器遍历

Iterator<Integer> iterator = set.iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); }

2）使用增强型 for 循环遍历

for (Integer num : set) { System.out.println(num); }

8. Set 转换为 List

List<Integer> list = new ArrayList<>(set); // 转换为 List 

Map

1. 基本创建 Map

Map<K, V> map = new HashMap<>(); 

K 是键的类型，V 是值的类型。可以使用 HashMap、TreeMap、LinkedHashMap 等不同实现类。经常使用 HashMap 类，O(1)。

Map<Integer,Integer> map = new HashMap<>(); Map<Integer,Integer> map1 = new TreeMap<>(); Map<Integer,Integer> map2= new LinkedHashMap<>();

2. 插入/更新元素

map.put(K key, V value); // 插入或更新元素，如果 key 已经存在，值会被更新 

3. 获取元素

V value = map.get(K key); // 根据键获取对应的值，若键不存在返回 null 

4. 检查键或值是否存在

boolean containsKey(Object key); // 判断 map 中是否存在指定的 key boolean containsValue(Object value); // 判断 map 中是否存在指定的 value 

5. 删除元素

map.remove(K key); // 根据 key 删除键值对 

6. 获取键集合、值集合和键值对集合

Set<K> keySet = map.keySet(); // 获取所有键 Collection<V> values = map.values(); // 获取所有值 Set<Map.Entry<K, V>> entrySet = map.entrySet(); // 获取所有的键值对 

Map<String,Integer> hash = new HashMap<>(); hash.put("hhh",1); hash.put("ggg",2); hash.put("www",3); Set<String> keySet = hash.keySet(); System.out.println(keySet); Collection<Integer> values = hash.values(); System.out.println(values); Set<Map.Entry<String, Integer>> entrySet = map.entrySet(); System.out.println(entrySet);

7. 遍历 Map

// 使用增强 for 循环遍历 entrySet for (Map.Entry<K, V> entry : map.entrySet()) { K key = entry.getKey(); V value = entry.getValue(); } // 使用 lambda 表达式遍历 map.forEach((key, value) -> { System.out.println(key + ": " + value); }); 

Map<String,Integer> hash = new HashMap<>(); hash.put("hhh",1); hash.put("ggg",2); hash.put("www",3); //遍历 key for(String key :hash.keySet()) { System.out.print(key+" "); } System.out.println(); //遍历 values for(Integer value :hash.values()) { System.out.print(value+" "); } System.out.println(); //遍历整个 map for (Map.Entry<String,Integer> entry :hash.entrySet()) { System.out.println(entry.getKey() + ":" + entry.getValue()); } //lambda 遍历 map System.out.println(); hash.forEach((key,value)->{ System.out.println(key + ":" + value); });

8. 默认值处理

V value = map.getOrDefault(K key, V defaultValue); // 如果 key 存在，返回对应的值，否则返回默认值 

String 类

1. 字符串连接

String.concat(String str)

将给定的字符串拼接到当前字符串的末尾。相当于 + 操作符，但效率较高。

String str = "Hello"; str = str.concat(" World"); // str = "Hello World"

2. 字符串比较

1) 判断当前字符串和指定字符串是否相等。比较的是字符序列是否相同。

String.equals(Object obj)

String str1 = "Hello"; String str2 = "hello"; boolean isEqual = str1.equals(str2); // false 

2) 忽略大小写比较两个字符串是否相等。

String.equalsIgnoreCase(String anotherString)

String str1 = "Hello"; String str2 = "hello"; boolean isEqual = str1.equalsIgnoreCase(str2); // true 

3) 字符串按字典顺序比较，返回一个整数：

• 0 表示两个字符串相等；
• < 0 表示当前字符串在字典序中小于给定字符串；
• > 0 表示当前字符串在字典序中大于给定字符串。

String.compareTo(String anotherString)

String str1 = "apple"; String str2 = "banana"; int result = str1.compareTo(str2); // result < 0 

4) 忽略大小写进行字典序比较。

String str1 = "apple"; String str2 = "APPLE"; int result = str1.compareToIgnoreCase(str2); // result == 0 

3. 字符串查找

1) 返回指定子字符串首次出现的索引位置。如果没有找到，返回 -1。

String.indexOf(String str)

String str = "Hello, World!"; int index = str.indexOf("W"); // index = 7 int index = str.indexOf("M"); // index = -1

2) 返回指定子字符串最后一次出现的索引位置。

String.lastIndexOf(String str)

String str = "aaaaabbbbba"; int index = str.lastIndexOf("a"); //index=10

3) 判断当前字符串是否包含指定的子字符串，返回布尔值。

String.contains(CharSequence sequence)

String str = "Hello, World!"; boolean contains = str.contains("World"); // true 

4) 判断当前字符串是否以指定的前缀开头。

String.startsWith(String prefix)

String str = "Hello"; boolean startsWith = str.startsWith("He"); // true 

5) 判断当前字符串是否以指定的后缀结尾。

String.endsWith(String suffix)

String str = "Hello"; boolean endsWith = str.endsWith("lo"); // true 

4. 字符串替换和修改

1) 替换字符串中的字符。返回一个新的字符串，原字符串不变。

String.replace(char oldChar, char newChar)

String str = "hello"; String newStr = str.replace('l', 'p'); // newStr = "heppo"

2) 字符串截取

1）返回从指定索引开始到字符串末尾的子字符串

String.substring(int beginIndex)

String str = "Hello World!"; String subStr = str.substring(6); // subStr = "World!"

2）返回从 beginIndex 到 endIndex 之间的子字符串。

String.substring(int beginIndex, int endIndex)

String str = "Hello World!"; String subStr = str.substring(0, 5); // subStr = "Hello"

5. 字符串转换

1）将字符串转换为小写字母。

String.toLowerCase()

String str = "HELLO"; String lowerStr = str.toLowerCase(); // lowerStr = "hello"

2）将字符串转换为大写字母。

String.toUpperCase()

String str = "hello"; String upperStr = str.toUpperCase(); // upperStr = "HELLO"

3）去掉字符串前后的空白字符。

String.trim()

String str = " Hello World! "; String trimmedStr = str.trim(); // trimmedStr = "Hello World!"

4）将其他类型的数据（如 int、boolean、char 等）转换为字符串。

String.valueOf()

int num = 100; String str = String.valueOf(num); // str = "100"

6. 其他常用方法

1）根据正则表达式将字符串拆分成数组。

String.split(String regex)

String str = "apple,banana,orange"; String[] arr = str.split(","); // arr = ["apple", "banana", "orange"]

2）将多个字符串连接成一个字符串，中间用指定的分隔符。

String.join(CharSequence delimiter, CharSequence... elements)

String result = String.join(",", "apple", "banana", "orange"); // "apple,banana,orange"

StringBuffer

1. 追加字符串：append

将指定的内容追加到 StringBuffer 末尾。

StringBuffer stringBuffer = new StringBuffer(); // 默认容量为 16 stringBuffer.append("hello"); stringBuffer.append(" "); stringBuffer.append("world!"); // hello world!

2. 插入字符串：insert

将指定的内容插入到指定位置。

StringBuffer stringBuffer = new StringBuffer(); // 默认容量为 16 stringBuffer.append("hello"); stringBuffer.append(" "); stringBuffer.append("world!"); stringBuffer.insert(6,"hi "); // hello hi world!

3. 删除字符串：delete 和 deleteCharAt

• delete(start, end)：删除从 start 到 end（不包括 end）的字符。
• deleteCharAt(index)：删除指定索引处的字符。

StringBuffer stringBuffer = new StringBuffer(); // 默认容量为 16 stringBuffer.append("hello"); stringBuffer.append(" "); stringBuffer.append("world!"); stringBuffer.delete(0,5); // world!

stringBuffer.append("hello"); stringBuffer.deleteCharAt(stringBuffer.length()-1); // hell

4. 反转字符串：reverse

将 StringBuffer 中的字符序列反转。

stringBuffer.append("hello"); stringBuffer.reverse(); // olleh

5. 转换为 String：toString

stringBuffer.append("hello"); String str = stringBuffer.toString(); //hello

StringBuilder（线程不安全）跟 StringBuffer（线程安全）类似，功能基本一致。

Math 类

列举一些主要的数学函数。

1. 绝对值：abs

返回参数的绝对值。

Math.abs(-5); // 5 Math.abs(3.14); // 3.14 

平方根：sqrt

返回参数的平方根。如果参数为负数，则返回 NaN。

Math.sqrt(16); // 4.0 Math.sqrt(2); // 1.4142135623730951 

幂运算：pow

返回第一个参数的第二个参数次方。

Math.pow(2, 3); // 8.0 Math.pow(3, 0); // 1.0 

最大值和最小值：max 和 min

返回两个数中的最大值或最小值。

Math.max(5, 10); // 10 Math.min(5, 10); // 5 

四舍五入：round

返回最接近的整数（四舍五入），并将结果作为 long 类型返回。

Math.round(3.6); // 4 Math.round(3.4); // 3 

向上取整：ceil

返回大于或等于参数的最小整数值，结果是 double 类型。

Math.ceil(3.1); // 4.0 Math.ceil(3.9); // 4.0 

指数运算：exp

计算 e 的 x 次方，等效于 Math.pow(Math.E, x)。

Math.exp(1); // 2.718281828459045 

数组（Arrays）类

1. 数组的排序

1) 默认是以升序状态

Arrays.sort(array)

int[] arr = {10,5,12,45,32,20,18}; Arrays.sort(arr); System.out.println(Arrays.toString(arr));

2) 用于自定义排序规则。适用于对象类型的数组 降序排序

Integer[] arr = {10,5,12,45,32,20,18}; Arrays.sort(arr,(a,b)-> b - a); System.out.println(Arrays.toString(arr)); //[45, 32, 20, 18, 12, 10, 5]

2. 数组转化字符串

1) 一维数组（常用）

Arrays.toString(array)

int[] arr = {1, 2, 3}; String str = Arrays.toString(arr); // "[1, 2, 3]"

2) 二维数组

Arrays.deepToString(array)

int[][] arr = {{1, 2}, {3, 4}}; String str = Arrays.deepToString(arr); // "[[1, 2], [3, 4]]"

3. 数组复制

1) 创建一个新数组，包含原数组的前 newLength 个元素。如果新长度大于原数组长度，则新增元素会被填充为默认值（如 0）。

Arrays.copyOf(array, newLength)

int[] arr = {1, 2, 3}; int[] newArr = Arrays.copyOf(arr, 5); // [1, 2, 3, 0, 0]

2) 创建一个新数组，复制原数组指定范围的元素（from 包含，to 不包含）。

Arrays.copyOfRange(array, from, to)

int[] arr = {1, 2, 3, 4, 5}; int[] subArr = Arrays.copyOfRange(arr, 1, 4); // [2, 3, 4]

4. 数组填充

1) 将数组中的所有元素设置为指定的值。

Arrays.fill(array, value)

int[] arr = new int[5]; Arrays.fill(arr, 7); // [7, 7, 7, 7, 7]

2) 将数组中从 fromIndex 到 toIndex 范围内的元素设置为指定值。

Arrays.fill(array, fromIndex, toIndex, value)

int[] arr = new int[5]; Arrays.fill(arr, 1, 4, 9); // [0, 9, 9, 9, 0]

5. 数组比较

判断两个数组是否相等。数组相等的标准是数组的长度相同且对应位置的元素相等。

Arrays.equals(array1, array2)

int[] arr1 = {1, 2, 3}; int[] arr2 = {1, 2, 3}; boolean isEqual = Arrays.equals(arr1, arr2); // true 

其他操作

常见数据类型的最大值和最小值

Integer.MAX_VALUE / Integer.MIN_VALUE Long.MAX_VALUE / Long.MIN_VALUE Float.MAX_VALUE / Float.MIN_VALUE Double.MAX_VALUE / Double.MIN_VALUE

集合转化成数组

// 将 List 转换为数组 String[] array = list.toArray(new String[0]); // 将 Set 转换为数组 String[] array = set.toArray(new String[0]); // 将 Queue 转换为数组 String[] array = queue.toArray(new String[0]); // 将 Map 的键转换为数组 String[] keys = map.keySet().toArray(new String[0]); // 将 Map 的值转换为数组 String[] values = map.values().toArray(new String[0]);

对于 List、Set 和 Queue，可以使用 toArray() 方法直接将其转换为数组。对于 Map，你可以选择将其键、值或条目转换为数组，使用 keySet()、values() 或 entrySet() 方法。

字符与字符串的转换

1）字符数组转字符串：String.valueOf() 或 String 构造函数。

char[] charArray = {'a', 'b', 'c'}; String str = new String(charArray); // str = "abc"

2）字符串转字符：使用 charAt() 获取指定位置的字符。

String str = "hello"; char ch = str.charAt(0); // ch = 'h'

字符串和整型之间的转化

1）字符串转整型（String -> int）

要将字符串转换为整型，可以使用 Integer.parseInt() 或 Integer.valueOf() 方法。

String str = "123"; int num = Integer.parseInt(str); System.out.println(num); // 输出：123 

String str = "123"; int num = Integer.valueOf(str); // 返回的是 Integer 对象 System.out.println(num); // 输出：123 

2）整型转字符串（int -> String）

要将整型转换为字符串，可以使用 String.valueOf() 或 Integer.toString() 方法。

int num = 123; String str = String.valueOf(num); System.out.println(str); // 输出："123"

int num = 123; String str = Integer.toString(num); System.out.println(str); // 输出："123"

还有遗留的等遇到会慢慢补充，这个会长期更新...