java泛型集合的使用

Java泛型集合是Java集合框架中广泛使用的一种类型安全机制。使用泛型集合可以提高代码的类型安全性和可读性。下面详细介绍Java泛型集合的基本概念、常用集合类及其使用方法，并提供示例代码。

基本概念

Java泛型集合允许在集合中存储特定类型的对象，并在编译时进行类型检查。这可以避免运行时的类型转换错误和提高代码的可读性和可维护性。

常用集合类

Java集合框架中最常用的泛型集合类包括：

List
Set
Map

示例代码

示例1：使用`List`

1import java.util.ArrayList;
2import java.util.List;
3
4public class ListExample {
5    public static void main(String[] args) {
6        // 创建一个存储字符串的List
7        List<String> stringList = new ArrayList<>();
8
9        // 添加元素
10        stringList.add("Hello");
11        stringList.add("World");
12
13        // 访问元素
14        String first = stringList.get(0);
15        String second = stringList.get(1);
16
17        // 遍历List
18        for (String item : stringList) {
19            System.out.println(item);
20        }
21    }
22}

示例2：使用`Set`

1import java.util.HashSet;
2import java.util.Set;
3
4public class SetExample {
5    public static void main(String[] args) {
6        // 创建一个存储整数的Set
7        Set<Integer> integerSet = new HashSet<>();
8
9        // 添加元素
10        integerSet.add(1);
11        integerSet.add(2);
12        integerSet.add(3);
13
14        // 访问元素
15        boolean containsTwo = integerSet.contains(2);
16
17        // 遍历Set
18        for (Integer number : integerSet) {
19            System.out.println(number);
20        }
21    }
22}

1import java.util.HashMap;
2import java.util.Map;
3
4public class MapExample {
5    public static void main(String[] args) {
6        // 创建一个存储字符串键和整数值的Map
7        Map<String, Integer> map = new HashMap<>();
8
9        // 添加键值对
10        map.put("one", 1);
11        map.put("two", 2);
12        map.put("three", 3);
13
14        // 访问键值对
15        Integer valueForOne = map.get("one");
16
17        // 遍历Map
18        for (Map.Entry<String, Integer> entry : map.entrySet()) {
19            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
20        }
21    }
22}

泛型集合的常见操作

1. 创建泛型集合

1List<String> stringList = new ArrayList<>();
2Set<Integer> integerSet = new HashSet<>();
3Map<String, Integer> map = new HashMap<>();

2. 添加元素

1stringList.add("Hello");
2integerSet.add(1);
3map.put("one", 1);

3. 访问元素

1String first = stringList.get(0);
2boolean containsTwo = integerSet.contains(2);
3Integer valueForOne = map.get("one");

4. 遍历集合

1// 遍历List
2for (String item : stringList) {
3    System.out.println(item);
4}
5
6// 遍历Set
7for (Integer number : integerSet) {
8    System.out.println(number);
9}
10
11// 遍历Map
12for (Map.Entry<String, Integer> entry : map.entrySet()) {
13    System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
14}

类型通配符

类型通配符通常使用?表示，可以表示任何类型。这在处理不确定类型的集合时非常有用。

示例4：使用类型通配符

1import java.util.Collection;
2import java.util.List;
3import java.util.Set;
4
5public class WildcardExample {
6    public static void printCollection(Collection<?> collection) {
7        for (Object item : collection) {
8            System.out.println(item);
9        }
10    }
11
12    public static void main(String[] args) {
13        List<String> stringList = new ArrayList<>();
14        stringList.add("Hello");
15        stringList.add("World");
16
17        Set<Integer> integerSet = new HashSet<>();
18        integerSet.add(1);
19        integerSet.add(2);
20
21        // 调用泛型方法
22        printCollection(stringList);
23        printCollection(integerSet);
24    }
25}

在这个例子中，printCollection方法接受任何类型的Collection，使用类型通配符?。

泛型上下界

泛型上下界可以限制类型参数的范围，使其只能是某个特定类型的子类型或超类型。

示例5：使用泛型上下界

1import java.util.List;
2import java.util.Comparator;
3
4public class BoundedWildcardExample {
5    public static <T extends Comparable<T>> T max(List<T> list) {
6        if (list.isEmpty()) {
7            throw new IllegalArgumentException("List must not be empty.");
8        }
9
10        T maxElement = list.get(0);
11        for (T element : list) {
12            if (element.compareTo(maxElement) > 0) {
13                maxElement = element;
14            }
15        }
16
17        return maxElement;
18    }
19
20    public static void main(String[] args) {
21        List<Integer> intList = List.of(1, 2, 3);
22        List<String> stringList = List.of("a", "b", "c");
23
24        Integer maxInt = max(intList);
25        String maxString = max(stringList);
26
27        System.out.println("Max Int: " + maxInt); // 输出 Max Int: 3
28        System.out.println("Max String: " + maxString); // 输出 Max String: c
29    }
30}

在这个例子中，max方法接受一个List，并且类型参数T必须是Comparable的子类型。这样可以确保List中的元素可以相互比较。

泛型方法

泛型方法可以在非泛型类或接口中声明。泛型方法允许在方法内部使用泛型类型参数，从而实现类型安全的代码。

示例6：使用泛型方法

1import java.util.List;
2
3public class GenericMethodExample {
4    public static <T> void printList(List<T> list) {
5        for (T item : list) {
6            System.out.println(item);
7        }
8    }
9
10    public static void main(String[] args) {
11        List<Integer> intList = List.of(1, 2, 3);
12        List<String> stringList = List.of("Hello", "World");
13
14        printList(intList);
15        printList(stringList);
16    }
17}

在这个例子中，printList方法接受任何类型的List，使用类型参数T。