java集合相关操作

Java 集合框架（Java Collections Framework）为程序员提供了丰富的接口、类和方法，用于处理集合数据。这些集合包括列表（List）、集合（Set）、队列（Queue）和映射（Map）等。以下是一些常见的 Java 集合相关操作：

1. 遍历集合

可以使用 for-each循环、迭代器（Iterator）或Java 8的流（Stream）API来遍历集合。

List<String> list = Arrays.asList("a", "b", "c");  
  
// 使用for-each循环  
for (String s : list) {  
    System.out.println(s);  
}  
  
// 使用迭代器  
Iterator<String> iterator = list.iterator();  
while (iterator.hasNext()) {  
    System.out.println(iterator.next());  
}  
  
// 使用Java 8的流API  
list.stream().forEach(s -> System.out.println(s));

2. 添加元素

可以使用集合的add或put方法添加元素。

List<String> list = new ArrayList<>();  
list.add("a");  
list.add("b");  
  
Set<String> set = new HashSet<>();  
set.add("a");  
set.add("b");  
  
Map<String, Integer> map = new HashMap<>();  
map.put("one", 1);  
map.put("two", 2);

3. 删除元素

可以使用集合的remove方法删除元素。

List<String> list = Arrays.asList("a", "b", "c");  
list.remove("b"); // 从列表中删除元素"b"  
  
Set<String> set = new HashSet<>(Arrays.asList("a", "b", "c"));  
set.remove("b"); // 从集合中删除元素"b"  
  
Map<String, Integer> map = new HashMap<>();  
map.put("one", 1);  
map.put("two", 2);  
map.remove("one"); // 从映射中删除键为"one"的条目

4. 检查元素是否存在

可以使用集合的contains方法检查元素是否存在。

List<String> list = Arrays.asList("a", "b", "c");  
boolean containsA = list.contains("a"); // 返回true  
  
Set<String> set = new HashSet<>(Arrays.asList("a", "b", "c"));  
boolean containsB = set.contains("b"); // 返回true  
  
Map<String, Integer> map = new HashMap<>();  
map.put("one", 1);  
map.put("two", 2);  
boolean containsKeyOne = map.containsKey("one"); // 返回true  
boolean containsValue2 = map.containsValue(2); // 返回true

5. 获取集合大小

可以使用集合的size方法获取集合中元素的数量。

List<String> list = Arrays.asList("a", "b", "c");  
int size = list.size(); // 返回3  
  
Set<String> set = new HashSet<>(Arrays.asList("a", "b", "c"));  
int setSize = set.size(); // 返回3（集合中不会有重复元素）  
  
Map<String, Integer> map = new HashMap<>();  
map.put("one", 1);  
map.put("two", 2);  
int mapSize = map.size(); // 返回2（映射的size是键的数量）

6. 集合转换和合并

可以使用Java 8的流API、集合的构造函数或静态工厂方法来进行集合的转换和合并。

List<String> list1 = Arrays.asList("a", "b", "c");  
List<String> list2 = Arrays.asList("d", "e", "f");  
  
// 合并两个列表  
List<String> combinedList = Stream.concat(list1.stream(), list2.stream()).collect(Collectors.toList());  
  
// 将列表转换为集合  
Set<String> set = new HashSet<>(list1);  
  
// 将一个集合的元素添加到另一个集合  
Set<String> unionSet = new HashSet<>(list1);  
unionSet.addAll(list2);

7. 排序

对于列表，可以使用Collections.sort方法进行排序，或者对于实现了Comparable接口的对象，可以直接调用sort方法（Java 8及以后版本）。

import java.util.ArrayList;  
import java.util.Collections;  
import java.util.Comparator;  
import java.util.List;  
  
public class SortExample {  
    public static void main(String[] args) {  
        List<String> list = new ArrayList<>();  
        list.add("Banana");  
        list.add("Apple");  
        list.add("Cherry");  
  
        // 自然排序  
        Collections.sort(list);  
  
        // 自定义排序  
        list.sort(Comparator.comparing(String::length)); // 按长度排序  
    }  
}

8. 检查集合是否为空

使用集合的isEmpty()方法检查集合是否为空，如果集合为空则返回true,否则返回值为false

import java.util.ArrayList;  
import java.util.List;  
  
public class IsEmptyExample {  
    public static void main(String[] args) {  
        List<String> list = new ArrayList<>();  
  
        boolean isEmpty = list.isEmpty(); // 检查集合是否为空  
        System.out.println(isEmpty); // 输出: true  
    }  
}

9. 交集、并集、差集

Java 8之后，可以使用Stream API来执行集合的交集、并集和差集操作。

import java.util.Arrays;  
import java.util.List;  
import java.util.stream.Collectors;  
  
public class SetOperationsExample {  
    public static void main(String[] args) {  
        List<String> list1 = Arrays.asList("Apple", "Banana", "Cherry");  
        List<String> list2 = Arrays.asList("Banana", "Cherry", "Date");  
  
        // 交集  
        List<String> intersection = list1.stream()  
                .filter(list2::contains)  
                .collect(Collectors.toList());  
  
        // 并集  
        List<String> union = Stream.concat(list1.stream(), list2.stream())  
                .distinct()  
                .collect(Collectors.toList());  
  
        // 差集 (list1 - list2)  
        List<String> difference = list1.stream()  
                .filter(item -> !list2.contains(item))  
                .collect(Collectors.toList());  
    }  
}

10. 使用Map集合

Map集合用于存储键值对。

import java.util.HashMap;  
import java.util.Map;  
  
public class MapExample {  
    public static void main(String[] args) {  
        Map<String, Integer> map = new HashMap<>();  
        map.put("Apple", 5);  
        map.put("Banana", 3);  
  
        // 获取值  
        Integer appleCount = map.get("Apple");  
  
        // 检查键是否存在  
        boolean hasBanana = map.containsKey("Banana");  
  
        // 检查值是否存在  
        boolean hasCountThree = map.containsValue(3);  
  
        // 移除键值对  
        map.remove("Banana");  
  
        // 遍历Map  
        for (Map.Entry<String, Integer> entry : map.entrySet()) {  
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());  
        }  
    }  
}

11. 使用LinkedHashSet保持插入顺序

当你想保持元素插入的顺序时，可以使用LinkedHashSet。

import java.util.LinkedHashSet;  
import java.util.Set;  
  
public class LinkedHashSetExample {  
    public static void main(String[] args) {  
        Set<String> set = new LinkedHashSet<>();  
        set.add("Apple");  
        set.add("Banana");  
        set.add("Cherry");  
  
        // 输出将保持插入顺序  
        for (String fruit : set) {  
            System.out.println(fruit);  
        }  
    }  
}

12. 使用PriorityQueue实现优先队列

PriorityQueue是一个无界队列，它按照元素的自然顺序或者构造时提供的Comparator进行排序。

import java.util.PriorityQueue;  
  
public class PriorityQueueExample {  
    public static void main(String[] args) {  
        PriorityQueue<Integer> queue = new PriorityQueue<>();  
        queue.add(3);  
        queue.add(1);  
        queue.add(2);  
  
        // 输出将按照从小到大的顺序  
        while (!queue.isEmpty()) {  
            System.out.println(queue.poll());  
        }  
    }  
}

13. 使用TreeSet实现排序集合

TreeSet是一个基于TreeMap实现的NavigableSet接口的有序集合。

import java.util.TreeSet;  
  
public class TreeSetExample {  
    public static void main(String[] args) {  
        TreeSet<Integer> set = new TreeSet<>();  
        set.add(3);  
        set.add(1);  
        set.add(2);  
  
        // 输出将按照从小到大的顺序  
        for (Integer num : set) {  
            System.out.println(num);  
        }  
    }  
}

14. 使用Deque实现双端队列

Deque是一个双端队列，它支持在两端插入和移除元素。

import java.util.ArrayDeque;  
import java.util.Deque;  
  
public class DequeExample {  
    public static void main(String[] args) {  
        Deque<String> deque