目录
前言
相信大家在刷算法题的过程中，好不容易想出来大概的思路，也知道去用哪个集合类，但各个集合类的一些命令都长得太像，很容易将他们弄错，并且在各集合之间的转化也是特别烦人，还有很多实用的函数都知道可以去用，但总是会忘记。
本篇将会把刷题中常见的，实用的集合类的功能和各类函数都将详细说明（后续遇到慢慢补充）
集合类
ArrayList
1. 创建和初始化 ArrayList
```java
ArrayList list = new ArrayList<>();
```
默认容量为10
2.添加元素 add
添加单个元素（常用） ：
```java
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
//list{1 2 3 4 5}
```
在指定位置添加元素 ：
```java
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(0,10); // [10, 1, 2, 3, 4, 5]
```
3.获取元素 get
获取指定索引位置的元素 ：
```java
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
int element = list.get(1); // 获取索引为 1 的元素 2
```
4.删除元素 remove
```java
boolean contains = list.contains(10); // 检查是否包含值为 10 的元素 false
```
```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)检查集合是否包含某个元素 ：
```java
boolean contains = list.contains(10); // 检查是否包含值为 10 的元素 false
```
2)检查集合是否为空 ：
```java
boolean isEmpty = list.isEmpty(); // 检查 ArrayList 是否为空
```
6.遍历 ArrayList
1)使用普通 for 循环遍历
```java
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i)); // 访问每一个元素
}
```
2)使用增强 for 循环遍历 ：
```java
for (Integer num : list) {
System.out.println(num);
}
```
3)使用迭代器遍历 ：
```java
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
```
LinkedList
LinkedList和ArrayList命令上大体相同，他们都实现了List
但LinkedList 实现了 Queue 和 Deque 接口，可以用作队列（FIFO）和栈（LIFO）：
Stack
1. 创建Stack对象
用于创建一个新的栈，常用于存储数字、字符或其他对象。
```bash
Stack stack = new Stack<>();
```
**2. 压入元素 (push) **
push(E item)方法用于将元素推入栈顶。
```java
stack.push(10);
stack.push(20);
stack.push(30);
// 10 20 30
```
3. 弹出元素 (pop)
pop()方法用于移除并返回栈顶元素。如果栈为空，调用该方法会抛出EmptyStackException异常。需要注意栈为空时使用时需检查栈是否为空，避免异常。
```java
int topElement = stack.pop(); // 30
```
4. 查看栈顶元素 (peek)
peek()方法用于查看栈顶元素，但不会移除它。如果栈为空，同样会抛出EmptyStackException异常。
```java
int topElement = stack.peek(); // stack{10,20} 20
```
5. 检查栈是否为空 (empty)
empty()方法返回true如果栈为空，false如果栈不为空。这个方法在判断栈是否可以继续操作时非常有用。
```java
boolean isEmpty = stack.empty(); // false
```
Queue
1. 创建队列对象
```java
Queue queue = new LinkedList<>();
// 或使用 ArrayDeque，性能更好
Queue queue = new ArrayDeque<>();
```
**2. 添加元素 (add 和 offer) **
**在刷题中，offer 比较常用 **
```java
queue.add(10); // 抛出异常：如果队列已满，则抛出 IllegalStateException
queue.offer(20); // 返回 true/false：如果队列已满，返回 false
```
3. 移除元素 (poll 和 remove)
poll() 更常用
```java
int element = queue.poll(); // 移除并返回队列头部的元素，队列为空时返回 null
int element = queue.remove(); // 移除并返回队列头部的元素，队列为空时抛出 NoSuchElementException
```
**4. 查看队列头部元素 (peek 和 element) **
peek() 方法更常用，因为它更安全，不会抛出异常。
```java
int element = queue.peek(); // 返回队列头部的元素，队列为空时返回 null
int element = queue.element(); // 返回队列头部的元素，队列为空时抛出 NoSuchElementException
```
**5. 队列大小 (size) **
返回队列中元素的数量，通常用于判断队列是否为空。
```java
int size = queue.size(); // 获取队列中元素的数量
```
**6. 检查队列是否为空 (isEmpty) **
返回true 如果队列为空，false 如果队列不为空。常用于循环前检查队列是否有元素。
```java
boolean isEmpty = queue.isEmpty(); // 判断队列是否为空
```
PriorityQueue
PriotyQueue跟Queue命令大体相似，但它也是刷题中经常遇到的，因为它可以创建大小根堆
- 大根堆（Max-Heap） ：每个父节点的值大于或等于其子节点的值，根节点为最大元素。
- 小根堆（Min-Heap） ：每个父节点的值小于或等于其子节点的值，根节点为最小元素。
小根堆：
```java
// 创建小根堆
//默认就是小根堆
PriorityQueue 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
```
大根堆
```java
// 创建大根堆（使用自定义的比较器实现降序排列）
PriorityQueue maxHeap = new PriorityQueue<>((a,b)-> b - a);
// PriorityQueue 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种方法任选一种
```java
Set set = new HashSet<>();
Set linkedSet = new LinkedHashSet<>();
Set treeSet = new TreeSet<>();
```
2. 添加元素
```java
set.add(1); // 添加元素，如果元素已存在，返回 false
set.add(2);
set.add(3);
```
3. 删除元素
```java
set.remove(2); // 删除元素2
```
4. 检查是否包含某个元素
```java
boolean contains = set.contains(3); // 返回 true 如果包含元素3
```
5. 获取集合的大小
```java
int size = set.size(); // 返回集合的元素个数
```
6. 判断集合是否为空
```java
boolean isEmpty = set.isEmpty(); // 如果集合为空，返回 true
```
7.遍历
1）使用迭代器遍历
```java
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
```
2）使用增强型 for 循环遍历
```java
for (Integer num : set) {
System.out.println(num);
}
```
**7.Set 转换为 List **
```java
List list = new ArrayList<>(set); // 转换为 List
```
Map
1. 基本创建Map
```java
Map map = new HashMap<>();
```
K是键的类型，V是值的类型。- 可以使用
HashMap、TreeMap、LinkedHashMap等不同实现类。- 经常使用HashMap类，O(1)
```java
Map map = new HashMap<>();
Map map1 = new TreeMap<>();
Map map2= new LinkedHashMap<>();
```
2. 插入/更新元素
```java
map.put(K key, V value); // 插入或更新元素，如果key已经存在，值会被更新
```
3. 获取元素
```java
V value = map.get(K key); // 根据键获取对应的值，若键不存在返回 null
```
4. 检查键或值是否存在
```java
boolean containsKey(Object key); // 判断map中是否存在指定的key
boolean containsValue(Object value); // 判断map中是否存在指定的value
```
5. 删除元素
```java
map.remove(K key); // 根据key删除键值对
```
6. 获取键集合、值集合和键值对集合(重)
```cpp
Set keySet = map.keySet(); // 获取所有键
Collection values = map.values(); // 获取所有值
Set> entrySet = map.entrySet(); // 获取所有的键值对
```
```cpp
Map hash = new HashMap<>();
hash.put("hhh",1);
hash.put("ggg",2);
hash.put("www",3);
Set keySet = hash.keySet();
System.out.println(keySet);
Collection values = hash.values();
System.out.println(values);
Set> entrySet = hash.entrySet();
System.out.println(entrySet);
```
7. 遍历 Map
```cpp
// 使用增强for循环遍历entrySet
for (Map.Entry entry : map.entrySet()) {
K key = entry.getKey();
V value = entry.getValue();
}
// 使用lambda表达式遍历
map.forEach((key, value) -> {
System.out.println(key + ": " + value);
});
```
```cpp
Map 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 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. 默认值处理
```java
V value = map.getOrDefault(K key, V defaultValue); // 如果key存在，返回对应的值，否则返回默认值
```
String类
1.字符串连接
```java
String.concat(String str)
```
**将给定的字符串拼接到当前字符串的末尾。相当于+ 操作符，但效率较高。 **
```java
String str = "Hello";
str = str.concat(" World"); // str = "Hello World"
```
2.字符串比较
1) 判断当前字符串和指定字符串是否相等。比较的是字符序列是否相同。
```java
String.equals(Object obj)
```
```java
String str1 = "Hello";
String str2 = "hello";
boolean isEqual = str1.equals(str2); // false
```
2) 忽略大小写比较两个字符串是否相等。
```java
String.equalsIgnoreCase(String anotherString)
```
```java
String str1 = "Hello";
String str2 = "hello";
boolean isEqual = str1.equalsIgnoreCase(str2); // true
```
3)字符串按字典顺序比较，返回一个整数：
0表示两个字符串相等；< 0表示当前字符串在字典序中小于给定字符串；-
> 0表示当前字符串在字典序中大于给定字符串。java
String.compareTo(String anotherString)```java
String str1 = "apple";
String str2 = "banana";
int result = str1.compareTo(str2); // result < 0```
4)忽略大小写进行字典序比较。
```java
String str1 = "apple";
String str2 = "APPLE";
int result = str1.compareToIgnoreCase(str2); // result == 0
```
3.字符串查找
1)返回指定子字符串首次出现的索引位置。如果没有找到，返回-1。
```java
String.indexOf(String str)
```
```java
String str = "Hello, World!";
int index = str.indexOf("W"); // index = 7
int index = str.indexOf("M"); // index = -1
```
2)返回指定子字符串最后一次出现的索引位置。
```java
String.lastIndexOf(String str)
```
```java
String str = "aaaaabbbbba";
int index = str.lastIndexOf("a"); //index=10
```
3)判断当前字符串是否包含指定的子字符串，返回布尔值。
```java
String.contains(CharSequence sequence)
```
```java
String str = "Hello, World!";
boolean contains = str.contains("World"); // true
```
4)判断当前字符串是否以指定的前缀开头。
```java
String.startsWith(String prefix)
```
```java
String str = "Hello";
boolean startsWith = str.startsWith("He"); // true
```
5)判断当前字符串是否以指定的后缀结尾。
```java
String.endsWith(String suffix)
```
```java
String str = "Hello";
boolean endsWith = str.endsWith("lo"); // true
```
4.字符串替换和修改
1)替换字符串中的字符。返回一个新的字符串，原字符串不变。
```java
String.replace(char oldChar, char newChar)
```
```java
String str = "hello";
String newStr = str.replace('l', 'p'); // newStr = "heppo"
```
2)字符串截取
1）返回从指定索引开始到字符串末尾的子字符串
```java
String.substring(int beginIndex)
```
```java
String str = "Hello World!";
String subStr = str.substring(6); // subStr = "World!"
```
2） 返回从beginIndex 到 endIndex 之间的子字符串。
```java
String.substring(int beginIndex, int endIndex)
```
```java
String str = "Hello World!";
String subStr = str.substring(0, 5); // subStr = "Hello"
```
5.字符串转换
1）将字符串转换为小写字母。
```java
String.toLowerCase()
```
```java
String str = "HELLO";
String lowerStr = str.toLowerCase(); // lowerStr = "hello"
```
2）将字符串转换为大写字母。
```java
String.toUpperCase()
```
```java
String str = "hello";
String upperStr = str.toUpperCase(); // upperStr = "HELLO"
```
3）去掉字符串前后的空白字符。
```java
String.trim()
```
```java
String str = " Hello World! ";
String trimmedStr = str.trim(); // trimmedStr = "Hello World!"
```
4）将其他类型的数据（如int、boolean、char 等）转换为字符串。
```java
String.valueOf()
```
```java
int num = 100;
String str = String.valueOf(num); // str = "100"
```
6.其他常用方法
1）根据正则表达式将字符串拆分成数组。
```java
String.split(String regex)
```
```java
String str = "apple,banana,orange";
String[] arr = str.split(","); // arr = ["apple", "banana", "orange"]
```
2） 将多个字符串连接成一个字符串，中间用指定的分隔符。
```java
String.join(CharSequence delimiter, CharSequence... elements)
```
```java
String result = String.join(",", "apple", "banana", "orange"); // "apple,banana,orange"
```
StringBuffer（重）
1.追加字符串：append
将指定的内容追加到StringBuffer 末尾。
```java
StringBuffer stringBuffer = new StringBuffer(); // 默认容量为16
stringBuffer.append("hello");
stringBuffer.append(" ");
stringBuffer.append("world!"); // hello world!
```
**2.插入字符串：insert **
将指定的内容插入到指定位置。
```java
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)：删除指定索引处的字符。java
StringBuffer stringBuffer = new StringBuffer(); // 默认容量为16
stringBuffer.append("hello");
stringBuffer.append(" ");
stringBuffer.append("world!");
stringBuffer.delete(0,5); // world!java
stringBuffer.append("hello");
stringBuffer.deleteCharAt(stringBuffer.length()-1); // hell
4.反转字符串：reverse
将StringBuffer 中的字符序列反转。
```java
stringBuffer.append("hello");
stringBuffer.reverse(); // olleh
```
**5.转换为String：toString **
```java
stringBuffer.append("hello");
String str = stringBuffer.toString(); //hello
```
..................
StringBuilder（线程不安全） 跟StringBuffer（线程安全）类似 功能基本一致
String - > integer -> char数组
Math类
列举一些主要的数学函数
1.绝对值：abs
返回参数的绝对值。
```java
Math.abs(-5); // 5
Math.abs(3.14); // 3.14
```
平方根：sqrt
返回参数的平方根。如果参数为负数，则返回 NaN。
```java
Math.sqrt(16); // 4.0
Math.sqrt(2); // 1.4142135623730951
```
幂运算：pow
返回第一个参数的第二个参数次方。
```java
Math.pow(2, 3); // 8.0
Math.pow(3, 0); // 1.0
```
最大值和最小值：max 和 min
返回两个数中的最大值或最小值。
```java
Math.max(5, 10); // 10
Math.min(5, 10); // 5
```
四舍五入：round
返回最接近的整数（四舍五入），并将结果作为 long 类型返回。
```java
Math.round(3.6); // 4
Math.round(3.4); // 3
```
向上取整：ceil
返回大于或等于参数的最小整数值，结果是 double 类型。
```java
Math.ceil(3.1); // 4.0
Math.ceil(3.9); // 4.0
```
指数运算：exp
计算 e 的 x 次方，等效于 Math.pow(Math.E, x)。
```java
Math.exp(1); // 2.718281828459045
```
数组（Arrays）类
1.数组的排序
1)默认是以升序状态
```
Arrays.sort(array)
```
```java
int[] arr = {10,5,12,45,32,20,18};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
```
2)用于自定义排序规则。适用于对象类型的数组 降序排序
```java
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)一维数组（常用）
```java
Arrays.toString(array)
```
```java
int[] arr = {1, 2, 3};
String str = Arrays.toString(arr); // "[1, 2, 3]"
```
2)二维数组
```bash
Arrays.deepToString(array)
```
```bash
int[][] arr = {{1, 2}, {3, 4}};
String str = Arrays.deepToString(arr); // "[[1, 2], [3, 4]]"
```
3.数组复制
1)创建一个新数组，包含原数组的前newLength 个元素。如果新长度大于原数组长度，则新增元素会被填充为默认值（如 0）。
```bash
Arrays.copyOf(array, newLength)
```
```java
int[] arr = {1, 2, 3};
int[] newArr = Arrays.copyOf(arr, 5); // [1, 2, 3, 0, 0]
```
2) 创建一个新数组，复制原数组指定范围的元素（from 包含，to 不包含）。
```java
Arrays.copyOfRange(array, from, to)
```
```java
int[] arr = {1, 2, 3, 4, 5};
int[] subArr = Arrays.copyOfRange(arr, 1, 4); // [2, 3, 4]
```
4.数组填充
1)将数组中的所有元素设置为指定的值。
```java
Arrays.fill(array, value)
```
```java
int[] arr = new int[5];
Arrays.fill(arr, 7); // [7, 7, 7, 7, 7]
```
2)将数组中从fromIndex 到 toIndex 范围内的元素设置为指定值。
```java
Arrays.fill(array, fromIndex, toIndex, value)
```
```java
int[] arr = new int[5];
Arrays.fill(arr, 1, 4, 9); // [0, 9, 9, 9, 0]
```
5.数组比较
判断两个数组是否相等。数组相等的标准是数组的长度相同且对应位置的元素相等。
```java
Arrays.equals(array1, array2)
```
```java
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
boolean isEqual = Arrays.equals(arr1, arr2); // true
```
其他操作 ：
常见数据类型的最大值和最小值
```bash
Integer.MAX_VALUE / Integer.MIN_VALUE
Long.MAX_VALUE / Long.MIN_VALUE
Float.MAX_VALUE / Float.MIN_VALUE
Double.MAX_VALUE / Double.MIN_VALUE
```
集合转化成数组
```cpp
// 将 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 构造函数。
```cpp
char[] charArray = {'a', 'b', 'c'};
String str = new String(charArray); // str = "abc"
```
2）字符串转字符 ：使用 charAt() 获取指定位置的字符。
```cpp
String str = "hello";
char ch = str.charAt(0); // ch = 'h'
```
字符串和整型之间的转化
1）字符串转整型（String - > int）
要将字符串转换为整型，可以使用Integer.parseInt() 或 Integer.valueOf() 方法。
```cpp
String str = "123";
int num = Integer.parseInt(str);
System.out.println(num); // 输出：123
```
```cpp
String str = "123";
int num = Integer.valueOf(str); // 返回的是 Integer 对象
System.out.println(num); // 输出：123
```
2）整型转字符串（int -> String）
要将整型转换为字符串，可以使用String.valueOf() 或 Integer.toString() 方法。
```cpp
int num = 123;
String str = String.valueOf(num);
System.out.println(str); // 输出："123"
```
```cpp
int num = 123;
String str = Integer.toString(num);
System.out.println(str); // 输出："123"
```
.............................
还有遗留的等遇到会慢慢补充，这个会长期更新...
感谢大家的支持！！！
文章整理自互联网，只做测试使用。发布者：Lomu，转转请注明出处：https://www.it1024doc.com/5213.html
