泛型在集合类中的应用实例

泛型在集合类中的应用实例主要体现在Java中的java.util包下的各种集合类，如ArrayList, LinkedList, HashSet, HashMap等。这些集合类通过使用泛型，可以存储和操作特定类型的对象，从而提供了类型安全和代码重用的优势。

以下是一些泛型在集合类中的应用实例：

1. ArrayList

import java.util.ArrayList;

public class GenericArrayListExample {
    public static void main(String[] args) {
        // 创建一个存储String类型的ArrayList
        ArrayList<String> stringList = new ArrayList<>();
        stringList.add("Hello");
        stringList.add("World");

        // 遍历并打印元素
        for (String s : stringList) {
            System.out.println(s);
        }
    }
}

2. LinkedList

import java.util.LinkedList;

public class GenericLinkedListExample {
    public static void main(String[] args) {
        // 创建一个存储Integer类型的LinkedList
        LinkedList<Integer> integerList = new LinkedList<>();
        integerList.add(1);
        integerList.add(2);
        integerList.add(3);

        // 遍历并打印元素
        for (Integer i : integerList) {
            System.out.println(i);
        }
    }
}

3. HashSet

import java.util.HashSet;

public class GenericHashSetExample {
    public static void main(String[] args) {
        // 创建一个存储String类型的HashSet
        HashSet<String> stringSet = new HashSet<>();
        stringSet.add("Apple");
        stringSet.add("Banana");
        stringSet.add("Cherry");

        // 遍历并打印元素
        for (String s : stringSet) {
            System.out.println(s);
        }
    }
}

4. HashMap

import java.util.HashMap;

public class GenericHashMapExample {
    public static void main(String[] args) {
        // 创建一个存储String到Integer映射的HashMap
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Alice", 25);
        map.put("Bob", 30);
        map.put("Charlie", 35);

        // 遍历并打印键值对
        for (String key : map.keySet()) {
            System.out.println(key + ": " + map.get(key));
        }
    }
}

5. 自定义泛型集合类

你也可以创建自己的泛型集合类，例如一个简单的泛型栈：

import java.util.EmptyStackException;

public class GenericStack<T> {
    private Object[] elements;
    private int size = 0;
    private static final int INITIAL_CAPACITY = 10;

    public GenericStack() {
        elements = new Object[INITIAL_CAPACITY];
    }

    public void push(T item) {
        ensureCapacity();
        elements[size++] = item;
    }

    @SuppressWarnings("unchecked")
    public T pop() {
        if (size == 0) {
            throw new EmptyStackException();
        }
        T item = (T) elements[--size];
        elements[size] = null; // 帮助垃圾回收
        return item;
    }

    private void ensureCapacity() {
        if (elements.length == size) {
            elements = java.util.Arrays.copyOf(elements, 2 * size + 1);
        }
    }

    public static void main(String[] args) {
        GenericStack<Integer> stack = new GenericStack<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);

        while (!stack.isEmpty()) {
            System.out.println(stack.pop());
        }
    }
}

通过这些实例，可以看到泛型在集合类中的应用极大地提高了代码的灵活性和安全性，避免了类型转换错误，并且使代码更加简洁和易于维护。