集合框架

一、数组（Array）

定义

  • 固定长度的连续内存空间，存储 相同类型 的元素。
  • 支持 随机访问（通过索引），时间复杂度 O(1)。

声明与初始化

// 1. 声明并指定长度（默认初始化为0或null）
int[] arr1 = new int[5]; 
String[] arr3 = new String[4];

// 2. 声明并直接初始化
int[] arr2 = {1, 2, 3, 4, 5};
String[] arr5 = {"haha","ada","asda","dfa"};

// 3. 二维数组
int[][] matrix = new int[3][3];
String[][] arr6 = new String[4][4];

常用操作

操作 代码示例
访问元素 int x = arr[0];
修改元素 arr[0] = 10;
获取长度 int len = arr.length;
遍历数组 for (int num : arr) { ... }
排序升序 Arrays.sort(arr);
排序降序 Arrays.sort(arr, Collections.reverseOrder());
填充数组 Arrays.fill(arr, 5);
复制数组 int[] newArr = Arrays.copyOf(arr, arr.length);

适用场景

  • 需要快速随机访问。
  • 数据长度固定且已知。

二、List（列表）

定义

  • 有序集合，允许重复元素。
  • 主要实现类：ArrayList（动态数组）、LinkedList（双向链表）。

声明与初始化

// 1. ArrayList（推荐）
List<Integer> list1 = new ArrayList<>(); 

// 2. LinkedList（频繁插入/删除时使用）
List<String> list2 = new LinkedList<>();

// 初始化并添加元素
List<Integer> list3 = new ArrayList<>(Arrays.asList(1, 2, 3));

常用方法

方法 功能 代码示例
add(E e) 末尾添加元素 list1.add(10);
add(int index, E) 指定位置插入元素 list1.add(1, 20);
remove(int index) 删除指定位置元素 list1.remove(0);
get(int index) 获取指定位置元素 String item = list2.get(0);
size() 返回元素个数 int size = list1.size();
isEmpty() 判断是否为空 boolean isEmpty = list1.isEmpty();

适用场景

  • ArrayList：频繁查询，尾部插入/删除。
  • LinkedList：频繁在头部或中间插入/删除。

三、Set（集合）

定义

  • 无序集合，不允许重复元素。
  • 主要实现类：HashSet（哈希表）、TreeSet（红黑树，有序）。

声明与初始化

// 1. HashSet（快速查找，无序）
Set<Integer> set1 = new HashSet<>(); 

// 2. TreeSet（自动排序）
Set<String> set2 = new TreeSet<>(); 

// 初始化并添加元素
Set<Integer> set3 = new HashSet<>(Arrays.asList(3, 1, 2));

常用方法

方法 功能 代码示例
add(E e) 添加元素 set1.add(10);
remove(Object) 删除元素 set1.remove(5);
contains(Object) 判断是否包含元素 boolean contains = set1.contains(3);
size() 返回元素个数 int size = set1.size();
clear() 清空集合 set1.clear();

适用场景

  • 去重、快速判断元素是否存在。
  • TreeSet：需要有序集合或范围查询（如找最小/最大值）。

四、Map（映射）

定义

  • 键值对（Key-Value） 集合，Key 唯一。
  • 主要实现类：HashMap（哈希表）、TreeMap（红黑树，Key有序）。

声明与初始化

// 1. HashMap（快速查找，无序）
Map<String, Integer> map1 = new HashMap<>(); 

// 2. TreeMap（Key有序）
Map<Integer, String> map2 = new TreeMap<>(); 

// 初始化并添加元素
Map<String, Integer> map3 = new HashMap<>() {{
    put("Alice", 90);
    put("Bob", 85);
}};

常用方法

方法 功能 代码示例
put(K key, V val) 添加/更新键值对 map1.put("Charlie", 100);
get(K key) 根据 Key 获取 Value int score = map1.get("Alice");
containsKey(K) 判断是否包含 Key boolean exists = map1.containsKey("Bob");
remove(K key) 删除键值对 map1.remove("Charlie");
keySet() 返回所有 Key 的集合 Set<String> keys = map1.keySet();
entrySet() 返回所有键值对的集合 for (Map.Entry<String, Integer> entry : map1.entrySet()) { System.out.println(entry.getKey() + ": " + entry.getValue()); }
getOrDefault(K key, V defaultValue) 获取 Key 对应的值，如果没有，返回默认值 int score = map1.getOrDefault("Eve", 50);

适用场景

  • 快速查找 Key 对应 Value。
  • TreeMap：需要 Key 有序或范围查询（如找最小/最大 Key）。

五、Stack（栈）

定义

  • 后进先出（LIFO） 结构。
  • Java 中推荐用 Deque 代替 Stack 类。

声明与初始化

Deque<Integer> stack = new ArrayDeque<>(); // 推荐方式

常用方法

方法 功能 代码示例
push(E e) 入栈 stack.push(10);
pop() 出栈（并返回元素） int item = stack.pop();
peek() 查看栈顶元素 int top = stack.peek();
isEmpty() 判断栈是否为空 boolean empty = stack.isEmpty();

适用场景

  • 括号匹配、逆波兰表达式、DFS算法。

六、Queue（队列）

定义

  • 先进先出（FIFO） 结构。
  • 主要实现类：LinkedList、PriorityQueue（优先队列）。

声明与初始化

// 1. 普通队列
Queue<Integer> queue = new LinkedList<>(); 

// 2. 优先队列（元素按优先级排序）
Queue<Integer> priorityQueue = new PriorityQueue<>();

常用方法

方法 功能 代码示例
offer(E e) 入队（推荐） queue.offer(10);
poll() 出队（并返回元素） int item = queue.poll();
peek() 查看队首元素 int front = queue.peek();
isEmpty() 判断队列是否为空 boolean empty = queue.isEmpty();

适用场景

  • BFS算法、任务调度。
  • PriorityQueue：需要按优先级处理元素（如 Dijkstra 算法）。

七、总结表格

数据结构 特点 常用实现类 典型应用场景
数组 固定长度，快速访问 int[], String[] 需要随机访问
List 有序，允许重复 ArrayList, LinkedList 动态集合操作
Set 无序，唯一 HashSet, TreeSet 去重、快速存在性检查
Map Key-Value 映射 HashMap, TreeMap 键值对存储
Stack 后进先出 ArrayDeque DFS、括号匹配
Queue 先进先出或优先级排序 LinkedList, PriorityQueue BFS、任务调度

八、排序

一、数组排序（Array）

1.升序排序（默认排序）

对于数组来说，Java 提供了 Arrays.sort() 方法来进行排序，默认情况下是升序排序。

import java.util.Arrays;

public class ArraySort {
    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 1, 2};
        Arrays.sort(arr);  // 默认升序排序
        System.out.println(Arrays.toString(arr));  // 输出: [1, 2, 3, 5, 8]
    }
}

2. 降序排序

如果想要对数组进行降序排序，可以使用 Arrays.sort() 并结合 Comparator。但是 Arrays.sort() 本身不支持直接降序排序。需要使用 Integer 类型的包装类来实现（因为它支持 reverseOrder()）。

import java.util.Arrays;
import java.util.Collections;

public class ArraySortDescending {
    public static void main(String[] args) {
        Integer[] arr = {5, 3, 8, 1, 2};
        Arrays.sort(arr, Collections.reverseOrder());  // 降序排序
        System.out.println(Arrays.toString(arr));  // 输出: [8, 5, 3, 2, 1]
    }
}

3. 自定义排序

还可以根据自己的需求，使用 Comparator 来进行更灵活的排序（例如按绝对值排序等）。

import java.util.Arrays;

public class CustomSort {
    public static void main(String[] args) {
        Integer[] arr = {5, -3, 8, -1, 2};
        Arrays.sort(arr, (a, b) -> Math.abs(a) - Math.abs(b));  // 按绝对值排序
        System.out.println(Arrays.toString(arr));  // 输出: [1, 2, -3, 5, 8]
    }
}

小结：

  • Arrays.sort()：对数组进行排序（升序）。
  • Arrays.sort(arr, Collections.reverseOrder())：对数组进行降序排序。
  • 使用 Comparator：可以进行自定义排序。

二、List排序（ArrayList, LinkedList）

1. 升序排序

对 List 进行排序，通常使用 Collections.sort() 方法。默认是升序排序。

import java.util.*;

public class ListSort {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>(Arrays.asList(5, 3, 8, 1, 2));
        Collections.sort(list);  // 默认升序排序
        System.out.println(list);  // 输出: [1, 2, 3, 5, 8]
    }
}

2. 降序排序

要进行降序排序，可以使用 Collections.reverseOrder() 方法。

import java.util.*;

public class ListSortDescending {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>(Arrays.asList(5, 3, 8, 1, 2));
        Collections.sort(list, Collections.reverseOrder());  // 降序排序
        System.out.println(list);  // 输出: [8, 5, 3, 2, 1]
    }
}

3. 自定义排序

可以传递一个 Comparator 实现来进行自定义排序。例如，按数字的绝对值排序：

import java.util.*;

public class ListCustomSort {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>(Arrays.asList(5, -3, 8, -1, 2));
        Collections.sort(list, (a, b) -> Math.abs(a) - Math.abs(b));  // 按绝对值排序
        System.out.println(list);  // 输出: [1, 2, -3, 5, 8]
    }
}

还可以使用 Lambda 表达式来简化 Comparator 的实现。

import java.util.*;

public class ListLambdaSort {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("Banana", "Apple", "Orange"));
        Collections.sort(list, (a, b) -> a.compareTo(b));  // 升序排序（按字母顺序）
        System.out.println(list);  // 输出: [Apple, Banana, Orange]
    }
}

小结：

  • Collections.sort(list)：对 List 进行升序排序。
  • Collections.sort(list, Collections.reverseOrder())：对 List 进行降序排序。
  • 使用 Comparator 或 Lambda 表达式：自定义排序规则。

总结对比：数组与List排序

排序方式 数组 List
升序排序 Arrays.sort(arr) Collections.sort(list)
降序排序 Arrays.sort(arr, Collections.reverseOrder()) Collections.sort(list, Collections.reverseOrder())
自定义排序 Arrays.sort(arr, (a, b) -> a.compareTo(b)) Collections.sort(list, (a, b) -> a.compareTo(b))

注意事项：

  1. 数组排序时，如果是基本类型（如 int[]），默认会按值进行排序；如果是对象数组（如 Integer[]），你可以用 Comparator 来控制排序方式。
  2. List 可以使用 ArrayList 或 LinkedList 来进行排序，ArrayList 更适合频繁查询，LinkedList 更适合频繁插入和删除。
  3. 自定义排序时，可以使用 Lambda 表达式让代码更简洁。

九、高频考点

1.ArrayList vs LinkedList：

  • 随机访问：ArrayList 快（O(1) vs O(n)）。
  • 插入/删除：LinkedList 在中间操作更快（O(n) vs O(n)，但实际链表更快）。

2.HashSet vs TreeSet：

  • HashSet 查找 O(1)，TreeSet 查找 O(log n)。
  • TreeSet 支持 ceiling()（最小 ≥ Key）和 floor()（最大 ≤ Key）。

3.PriorityQueue 内部排序：

  • 默认最小堆，可通过 Comparator 自定义排序规则。

4.Map 的遍历方式：

// 遍历所有键值对
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    String key = entry.getKey();
    int value = entry.getValue();
}
posted @ 2025-02-22 18:10  咋还没来  阅读(43)  评论(0)    收藏  举报