目录
前言
集合类
ArrayList
1. 创建和初始化 ArrayList
2.添加元素 add
3.获取元素 get
4.删除元素 remove
5.检查元素
6.遍历 ArrayList
LinkedList
Stack
1. 创建Stack对象
2. 压入元素 (push)
3. 弹出元素 (pop)
4. 查看栈顶元素 (peek)
5. 检查栈是否为空 (empty)
Queue
1. 创建队列对象
2. 添加元素 (add 和 offer)
3. 移除元素 (poll 和 remove)
4. 查看队列头部元素 (peek 和 element)
5. 队列大小 (size)
6. 检查队列是否为空 (isEmpty)
PriorityQueue
小根堆：
大根堆
Set
1.创建 Set 实例
2. 添加元素
3. 删除元素
4. 检查是否包含某个元素
5. 获取集合的大小
6. 判断集合是否为空
Map
1. 基本创建 Map
2. 插入/更新元素
3. 获取元素
4. 检查键或值是否存在
5. 删除元素
6. 获取键集合、值集合和键值对集合(重)
7. 遍历 Map
8. 默认值处理
String类
1.字符串连接
2.字符串比较
3.字符串查找
4.字符串替换和修改
5.字符串转换
6.其他常用方法
StringBuffer（重）
1.追加字符串：append
2.插入字符串：insert
3.删除字符串：delete 和 deleteCharAt
4.反转字符串：reverse
5.转换为 String：toString
Math类
数组（Arrays）类
1.数组的排序
2.数组转化字符串
3.数组复制
4.数组填充
5.数组比较
其他操作 ：
常见数据类型的最大值和最小值
集合转化成数组
字符与字符串的转换
字符串和整型之间的转化
前言
相信大家在刷算法题的过程中，好不容易想出来大概的思路，也知道去用哪个集合类，但各个集合类的一些命令都长得太像，很容易将他们弄错，并且在各集合之间的转化也是特别烦人，还有很多实用的函数都知道可以去用，但总是会忘记。
本篇将会把刷题中常见的，实用的集合类的功能和各类函数都将详细说明（后续遇到慢慢补充）
集合类
ArrayList
1. 创建和初始化 ArrayList
ArrayList<Integer> list = new ArrayList<>();
默认容量为10
2.添加元素 add
添加单个元素（常用）：
list.add(1); list.add(2); list.add(3); list.add(4); list.add(5); //list{1 2 3 4 5}在指定位置添加元素：
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
获取指定索引位置的元素：
list.add(1); list.add(2); list.add(3); list.add(4); list.add(5); int element = list.get(1); // 获取索引为 1 的元素 24.删除元素 remove
boolean contains = list.contains(10); // 检查是否包含值为 10 的元素 false 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 45.检查元素
1)检查集合是否包含某个元素：
boolean contains = list.contains(10); // 检查是否包含值为 10 的元素 false2)检查集合是否为空：
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<E>接口
但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(); // falseQueue
1. 创建队列对象
Queue<Integer> queue = new LinkedList<>();// 或使用 ArrayDeque，性能更好Queue<Integer> queue = new ArrayDeque<>();2. 添加元素 (add 和 offer)
在刷题中，offer 比较常用
queue.add(10); // 抛出异常：如果队列已满，则抛出 IllegalStateExceptionqueue.offer(20); // 返回 true/false：如果队列已满，返回 false 3. 移除元素 (poll 和 remove)
poll() 更常用
int element = queue.poll(); // 移除并返回队列头部的元素，队列为空时返回 nullint element = queue.remove(); // 移除并返回队列头部的元素，队列为空时抛出 NoSuchElementException4. 查看队列头部元素 (peek 和 element)
peek() 方法更常用，因为它更安全，不会抛出异常。
int element = queue.peek(); // 返回队列头部的元素，队列为空时返回 nullint element = queue.element(); // 返回队列头部的元素，队列为空时抛出 NoSuchElementException5. 队列大小 (size)
返回队列中元素的数量，通常用于判断队列是否为空。
int size = queue.size(); // 获取队列中元素的数量6. 检查队列是否为空 (isEmpty)
返回 true 如果队列为空，false 如果队列不为空。常用于循环前检查队列是否有元素。
boolean isEmpty = queue.isEmpty(); // 判断队列是否为空
PriorityQueue
PriotyQueue跟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()); // 输出 20Set
1.创建 Set 实例
3种方法任选一种
Set<Integer> set = new HashSet<>();Set<Integer> linkedSet = new LinkedHashSet<>();Set<Integer> treeSet = new TreeSet<>();2. 添加元素
set.add(1); // 添加元素，如果元素已存在，返回 falseset.add(2);set.add(3);3. 删除元素
set.remove(2); // 删除元素24. 检查是否包含某个元素
boolean contains = set.contains(3); // 返回 true 如果包含元素35. 获取集合的大小
int size = set.size(); // 返回集合的元素个数6. 判断集合是否为空
boolean isEmpty = set.isEmpty(); // 如果集合为空，返回 true7.遍历
1）使用迭代器遍历
Iterator<Integer> iterator = set.iterator();while (iterator.hasNext()) { System.out.println(iterator.next());}2）使用增强型 for 循环遍历
for (Integer num : set) { System.out.println(num);}7.Set 转换为 List
List<Integer> list = new ArrayList<>(set); // 转换为 ListMap
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); // 根据键获取对应的值，若键不存在返回 null4. 检查键或值是否存在
boolean containsKey(Object key); // 判断map中是否存在指定的keyboolean containsValue(Object value); // 判断map中是否存在指定的value5. 删除元素
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 = hash.entrySet(); System.out.println(entrySet);
7. 遍历 Map
// 使用增强for循环遍历entrySetfor (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); // false2) 忽略大小写比较两个字符串是否相等。
String.equalsIgnoreCase(String anotherString)String str1 = "Hello";String str2 = "hello";boolean isEqual = str1.equalsIgnoreCase(str2); // true3)字符串按字典顺序比较，返回一个整数：
0 表示两个字符串相等；< 0 表示当前字符串在字典序中小于给定字符串；> 0 表示当前字符串在字典序中大于给定字符串。 String.compareTo(String anotherString)String str1 = "apple";String str2 = "banana";int result = str1.compareTo(str2); // result < 04)忽略大小写进行字典序比较。
String str1 = "apple";String str2 = "APPLE";int result = str1.compareToIgnoreCase(str2); // result == 03.字符串查找
1)返回指定子字符串首次出现的索引位置。如果没有找到，返回 -1。
String.indexOf(String str)String str = "Hello, World!";int index = str.indexOf("W"); // index = 7int index = str.indexOf("M"); // index = -12)返回指定子字符串最后一次出现的索引位置。
String.lastIndexOf(String str) String str = "aaaaabbbbba"; int index = str.lastIndexOf("a"); //index=103)判断当前字符串是否包含指定的子字符串，返回布尔值。
String.contains(CharSequence sequence)String str = "Hello, World!";boolean contains = str.contains("World"); // true4)判断当前字符串是否以指定的前缀开头。
String.startsWith(String prefix)String str = "Hello";boolean startsWith = str.startsWith("He"); // true5)判断当前字符串是否以指定的后缀结尾。
String.endsWith(String suffix)String str = "Hello";boolean endsWith = str.endsWith("lo"); // true4.字符串替换和修改
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(); // olleh5.转换为 String：toString
stringBuffer.append("hello"); String str = stringBuffer.toString(); //hello..................
StringBuilder（线程不安全） 跟StringBuffer（线程安全）类似 功能基本一致
String -> integer -> char数组
Math类
列举一些主要的数学函数
1.绝对值：abs
返回参数的绝对值。
Math.abs(-5); // 5Math.abs(3.14); // 3.14 平方根：sqrt
返回参数的平方根。如果参数为负数，则返回 NaN。
Math.sqrt(16); // 4.0Math.sqrt(2); // 1.4142135623730951幂运算：pow
返回第一个参数的第二个参数次方。
Math.pow(2, 3); // 8.0Math.pow(3, 0); // 1.0最大值和最小值：max 和 min
返回两个数中的最大值或最小值。
Math.max(5, 10); // 10Math.min(5, 10); // 5四舍五入：round
返回最接近的整数（四舍五入），并将结果作为 long 类型返回。
Math.round(3.6); // 4Math.round(3.4); // 3向上取整：ceil
返回大于或等于参数的最小整数值，结果是 double 类型。
Math.ceil(3.1); // 4.0Math.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_VALUELong.MAX_VALUE / Long.MIN_VALUEFloat.MAX_VALUE / Float.MIN_VALUEDouble.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); // 输出：123String str = "123";int num = Integer.valueOf(str); // 返回的是 Integer 对象System.out.println(num); // 输出：1232）整型转字符串（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".............................
还有遗留的等遇到会慢慢补充，这个会长期更新...
感谢大家的支持！！！