1. Java泛型深度解析与实战应用

泛型是Java 5引入的核心特性，它彻底改变了我们处理集合类的方式。记得我刚接触泛型时，常常被那些尖括号弄得晕头转向，但一旦掌握就会发现它带来的类型安全性和代码简洁性无可替代。

1.1 泛型本质与类型擦除机制

泛型的本质是参数化类型，即在编译时确定集合中元素的类型。但很多人不知道的是，Java泛型是通过类型擦除实现的。这意味着在运行时，ArrayList 和ArrayList 其实是同一个类。

// 编译前
List<String> strList = new ArrayList<>();
// 编译后(类型擦除)
List strList = new ArrayList();

这种设计带来了一个有趣的限制：不能创建泛型数组。比如new List [10]会编译错误，因为运行时无法区分数组元素的类型。

1.2 泛型通配符的三种形态

实际开发中，我们经常需要处理未知类型的集合，这时通配符就派上用场了：

1. 无界通配符<?>：表示完全未知类型
2. 上界通配符<? extends Number>：表示Number或其子类
3. 下界通配符<? super Integer>：表示Integer或其父类

// 上界通配符示例
public static double sum(List<? extends Number> list) {
    return list.stream().mapToDouble(Number::doubleValue).sum();
}

// 下界通配符典型应用 - Java集合的addAll方法
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    dest.addAll(src);
}

1.3 泛型方法的设计技巧

泛型方法可以独立于类存在，这在工具类中特别有用。我常用的一个技巧是使用泛型方法来避免类型转换：

public static <T> T getFirst(List<T> list) {
    return list.isEmpty() ? null : list.get(0);
}

// 使用时无需强制转换
String first = getFirst(stringList);

2. Java集合框架体系精讲

2.1 集合框架的顶层设计

Java集合框架主要分为两大分支：

• Collection接口：处理单元素集合
  • List：有序可重复
  • Set：无序唯一
  • Queue：队列结构
• Map接口：处理键值对

graph TD
    Collection --> List
    Collection --> Set
    Collection --> Queue
    Set --> HashSet
    Set --> TreeSet
    List --> ArrayList
    List --> LinkedList
    Map --> HashMap
    Map --> TreeMap

2.2 ArrayList与LinkedList的终极对决

在面试中，ArrayList和LinkedList的区别是必问题。根据我的经验，90%的情况下应该选择ArrayList，但有些特殊场景LinkedList更合适：

ArrayList优势：

• 随机访问O(1)时间复杂度
• 内存连续，CPU缓存友好
• 尾部插入删除高效

LinkedList优势：

• 头部插入删除O(1)时间复杂度
• 不需要扩容，适合频繁增删
• 实现了Deque接口，可作为栈或队列使用

// 性能测试对比
List<Integer> arrayList = new ArrayList<>();
List<Integer> linkedList = new LinkedList<>();

// 插入测试
long start = System.nanoTime();
for (int i = 0; i < 100000; i++) {
    arrayList.add(0, i);  // 头部插入
}
System.out.println("ArrayList耗时：" + (System.nanoTime()-start)/1000000 + "ms");

start = System.nanoTime();
for (int i = 0; i < 100000; i++) {
    linkedList.add(0, i);  // 头部插入
}
System.out.println("LinkedList耗时：" + (System.nanoTime()-start)/1000000 + "ms");

2.3 HashMap的实现原理与优化

HashMap是面试中的重灾区，它的实现经历了多次优化：

1. JDK7及之前 ：数组+链表
2. JDK8 ：数组+链表/红黑树（链表长度>8时转换）
3. JDK11 ：优化了哈希算法和树化逻辑

关键参数：

• 初始容量：默认16
• 负载因子：默认0.75（容量达到75%时扩容）
• 树化阈值：链表长度达到8时可能转为红黑树

// 优化HashMap初始容量
// 预计存储100个元素，计算最佳初始容量
int expectedSize = 100;
float loadFactor = 0.75f;
int initialCapacity = (int) (expectedSize / loadFactor) + 1;
Map<String, String> map = new HashMap<>(initialCapacity);

3. 集合使用中的陷阱与最佳实践

3.1 并发修改异常(ConcurrentModificationException)

这是集合使用中最常见的异常之一，通常发生在使用迭代器遍历时修改集合：

List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c"));

// 错误写法 - 会抛出ConcurrentModificationException
for (String s : list) {
    if ("b".equals(s)) {
        list.remove(s);  // 直接调用集合的remove方法
    }
}

// 正确写法1 - 使用迭代器的remove方法
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if ("b".equals(it.next())) {
        it.remove();  // 使用迭代器的remove方法
    }
}

// 正确写法2 - JDK8+使用removeIf
list.removeIf(s -> "b".equals(s));

3.2 对象相等性与集合的关系

当自定义对象作为Set的元素或Map的key时，必须正确重写equals和hashCode方法。我见过太多因为hashCode实现不当导致的性能问题：

class Student {
    String name;
    int age;
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return age == student.age && 
               Objects.equals(name, student.name);
    }
    
    @Override
    public int hashCode() {
        // JDK7+推荐写法
        return Objects.hash(name, age);
        
        // 传统写法
        // int result = name != null ? name.hashCode() : 0;
        // result = 31 * result + age;
        // return result;
    }
}

3.3 不可变集合的安全优势

Java 9引入的List.of(), Set.of(), Map.of()创建的不可变集合，在多线程环境下特别有用：

// 创建不可变集合
List<String> immutableList = List.of("a", "b", "c");
Set<Integer> immutableSet = Set.of(1, 2, 3);
Map<String, Integer> immutableMap = Map.of("a", 1, "b", 2);

// 尝试修改会抛出UnsupportedOperationException
immutableList.add("d");  // 抛出异常

4. 高级集合特性与性能优化

4.1 Java 8 Stream API的集合操作

Stream API极大简化了集合操作，但要注意它的一些特性：

1. 流只能消费一次 ：创建Stream后只能进行一次终端操作
2. 短路操作 ：findFirst、anyMatch等可能不需要处理全部元素
3. 并行流陷阱 ：parallel()不一定提升性能，可能适得其反

// 复杂Stream操作示例
Map<Department, Double> avgSalaryByDept = employees.stream()
    .filter(e -> e.getAge() > 30)
    .collect(Collectors.groupingBy(
        Employee::getDepartment,
        Collectors.averagingDouble(Employee::getSalary)
    ));

4.2 集合初始化容量优化

不合理的初始容量会导致频繁扩容，影响性能。根据我的经验：

1. ArrayList ：初始容量=(预估元素数量 × 1.5)
2. HashMap ：初始容量=(预估键值对数 / 负载因子) + 1
3. HashSet ：底层使用HashMap，规则同HashMap

// 优化ArrayList初始化
int expectedElements = 1000;
List<String> optimizedList = new ArrayList<>((int)(expectedElements * 1.5));

// 优化HashMap初始化
int expectedEntries = 1000;
float loadFactor = 0.75f;
Map<String, String> optimizedMap = new HashMap<>(
    (int)(expectedEntries / loadFactor) + 1
);

4.3 枚举集合的特殊优化

EnumSet和EnumMap是为枚举类型特殊优化的集合实现，性能远超普通集合：

enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY }

// EnumSet使用
EnumSet<Day> weekend = EnumSet.of(Day.SATURDAY, Day.SUNDAY);

// EnumMap使用
EnumMap<Day, String> activityMap = new EnumMap<>(Day.class);
activityMap.put(Day.MONDAY, "Work");

在实际项目中，我发现很多开发者忽视了这些专门为枚举设计的集合类，导致性能不必要的损失。特别是在处理大量枚举值时，EnumSet的性能优势尤为明显。