Java刷题常见的集合类，各种函数的使用以及常见的类型转化等等

用户11369558

发布于 2024-12-24 11:26:35

9900

代码可运行

文章被收录于专栏：JavaJava

运行总次数：0

代码可运行

前言

相信大家在刷算法题的过程中，好不容易想出来大概的思路，也知道去用哪个集合类，但各个集合类的一些命令都长得太像，很容易将他们弄错，并且在各集合之间的转化也是特别烦人，还有很多实用的函数都知道可以去用，但总是会忘记。

本篇将会把刷题中常见的，实用的集合类的功能和各类函数都将详细说明（后续遇到慢慢补充）

集合类

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 的元素  2

4.删除元素 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 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<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(); // 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

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()); // 输出 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);
}

7.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 = hash.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（线程安全）类似功能基本一致

String -> integer -> char数组

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"

.............................

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

感谢大家的支持！！！

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2024-12-08，如有侵权请联系 cloudcommunity@tencent.com 删除

集合

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！