Java集合常见问题面试题

内存泄漏问题

Q1: 集合使用中常见的内存泄漏问题有哪些？如何解决？

public class CollectionMemoryLeakExample {// 1. 静态集合导致的内存泄漏public class StaticCollectionLeak {// 不好的实践：使用静态集合存储临时对象private static final List<Object> leakyList = new ArrayList<>();public void addItem(Object item) {leakyList.add(item);  // 对象永远不会被回收}// 好的实践：使用局部集合或弱引用private static final WeakHashMap<Object, Object> safeMap = new WeakHashMap<>();public void addItemSafely(Object key, Object value) {safeMap.put(key, value);  // 当key不再被引用时，entry会被回收}}// 2. 集合引用导致的内存泄漏public class CollectionReferenceLeak {private List<Object> items = new ArrayList<>();// 不好的实践：返回集合引用public List<Object> getItems() {return items;  // 外部可以修改集合内容}// 好的实践：返回不可修改的视图public List<Object> getItemsSafely() {return Collections.unmodifiableList(items);}// 更好的实践：返回副本public List<Object> getItemsCopy() {return new ArrayList<>(items);}}// 3. 监听器泄漏public class ListenerLeak {// 不好的实践：使用强引用存储监听器private List<EventListener> listeners = new ArrayList<>();// 好的实践：使用弱引用存储监听器private List<WeakReference<EventListener>> safeListeners = new ArrayList<>();public void addEventListener(EventListener listener) {safeListeners.add(new WeakReference<>(listener));}public void fireEvent(Event event) {safeListeners.removeIf(ref -> ref.get() == null);for (WeakReference<EventListener> ref : safeListeners) {EventListener listener = ref.get();if (listener != null) {listener.onEvent(event);}}}}
}

并发修改问题

Q2: 如何处理集合的并发修改问题？

public class ConcurrentModificationExample {// 1. 迭代时修改public class IterationModification {// 不好的实践：直接在迭代时修改public void removeBadly(List<String> list) {try {for (String item : list) {if (item.isEmpty()) {list.remove(item);  // 抛出ConcurrentModificationException}}} catch (ConcurrentModificationException e) {// 处理异常}}// 好的实践：使用迭代器public void removeSafely(List<String> list) {Iterator<String> iterator = list.iterator();while (iterator.hasNext()) {String item = iterator.next();if (item.isEmpty()) {iterator.remove();  // 安全地删除元素}}}// 另一种好的实践：使用removeIfpublic void removeModern(List<String> list) {list.removeIf(String::isEmpty);}}// 2. 并发访问public class ConcurrentAccess {// 不好的实践：在多线程环境中使用非线程安全的集合private List<String> unsafeList = new ArrayList<>();// 好的实践：使用线程安全的集合private List<String> safeList = Collections.synchronizedList(new ArrayList<>());// 更好的实践：使用并发集合private List<String> concurrentList = new CopyOnWriteArrayList<>();public void demonstrateSafeIteration() {// 同步集合的安全迭代synchronized (safeList) {for (String item : safeList) {// 处理item}}// 并发集合的安全迭代（无需同步）for (String item : concurrentList) {// 处理item}}}
}

性能问题

Q3: 集合使用中常见的性能问题有哪些？如何优化？

public class CollectionPerformanceIssues {// 1. 初始容量问题public class CapacityIssues {// 不好的实践：频繁扩容public void badCapacityUsage() {List<String> list = new ArrayList<>();for (int i = 0; i < 10000; i++) {list.add("item" + i);  // 多次扩容}}// 好的实践：预设容量public void goodCapacityUsage() {int expectedSize = 10000;List<String> list = new ArrayList<>(expectedSize);for (int i = 0; i < expectedSize; i++) {list.add("item" + i);  // 只扩容一次}}}// 2. 查找性能问题public class SearchPerformanceIssues {// 不好的实践：使用不当的数据结构public boolean badSearch(List<String> list, String target) {return list.contains(target);  // O(n)复杂度}// 好的实践：使用合适的数据结构public boolean goodSearch(Set<String> set, String target) {return set.contains(target);  // O(1)复杂度}// 更好的实践：使用索引public class IndexedSearch {private Map<String, List<Integer>> index = new HashMap<>();private List<String> data = new ArrayList<>();public void addItem(String item) {int position = data.size();data.add(item);index.computeIfAbsent(item, k -> new ArrayList<>()).add(position);}public List<Integer> findItem(String item) {return index.getOrDefault(item, Collections.emptyList());}}}// 3. 遍历性能问题public class IterationPerformanceIssues {// 不好的实践：低效遍历public void badIteration(List<String> list) {for (int i = 0; i < list.size(); i++) {String item = list.get(i);  // LinkedList的get操作是O(n)}}// 好的实践：使用迭代器public void goodIteration(List<String> list) {for (String item : list) {  // 使用迭代器，O(1)访问下一个元素// 处理item}}// 并行处理public void parallelProcessing(List<String> list) {list.parallelStream().filter(item -> item != null).map(String::toUpperCase).forEach(this::process);}}
}

功能问题

Q4: 如何解决集合的常见功能问题？

public class CollectionFunctionalIssues {// 1. 排序问题public class SortingIssues {// 自定义排序public class CustomSorting {private class User {private String name;private int age;// getter和setter}public void demonstrateSorting() {List<User> users = new ArrayList<>();// 基本排序Collections.sort(users, Comparator.comparing(User::getAge));// 复杂排序Collections.sort(users, Comparator.comparing(User::getAge).thenComparing(User::getName).reversed());}}// 稳定排序public void demonstrateStableSort() {List<String> list = new ArrayList<>();// 不稳定排序Set<String> treeSet = new TreeSet<>(list);// 稳定排序Collections.sort(list);}}// 2. 去重问题public class DuplicationIssues {// 简单去重public <T> List<T> removeDuplicates(List<T> list) {return new ArrayList<>(new LinkedHashSet<>(list));}// 自定义去重public <T> List<T> removeDuplicatesBy(List<T> list, Function<T, Object> keyExtractor) {return list.stream().collect(Collectors.collectingAndThen(Collectors.toMap(keyExtractor,Function.identity(),(existing, replacement) -> existing,LinkedHashMap::new),map -> new ArrayList<>(map.values())));}}// 3. 深拷贝问题public class DeepCopyIssues {// 使用序列化实现深拷贝public <T extends Serializable> List<T> deepCopy(List<T> source) {try {ByteArrayOutputStream bos = new ByteArrayOutputStream();ObjectOutputStream oos = new ObjectOutputStream(bos);oos.writeObject(source);ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());ObjectInputStream ois = new ObjectInputStream(bis);return (List<T>) ois.readObject();} catch (Exception e) {throw new RuntimeException("Deep copy failed", e);}}// 使用拷贝构造函数public class CopyConstructor {private class DataHolder {private List<String> data;public DataHolder(DataHolder other) {this.data = new ArrayList<>(other.data);}}}}
}