List集合的进一步学习：性能优化

================================

|| 持续分享系列教程，关注一下不迷路 ||

|| B站视频教程：墨轩大楼 ||

|| 知识星球：墨轩编程自习室 ||

================================

在Java集合框架中，选择合适的集合类型和使用正确的操作方法可以显著提高程序的性能。以下是一些常见的性能优化技巧，并附有详细的代码示例。

1. 选择合适的集合类型

根据具体的需求选择合适的集合类型是性能优化的第一步。例如：

随机访问：如果需要频繁进行随机访问操作，应选择ArrayList。
频繁插入/删除：如果需要频繁进行插入和删除操作，应选择LinkedList。
线程安全：如果需要在多线程环境下使用，可以考虑Vector或使用Collections.synchronizedList包装ArrayList。

2. 批量操作

批量操作通常比单个操作更高效。例如，使用addAll方法一次添加多个元素比多次调用add方法更高效。

示例代码

import java.util.ArrayList;
import java.util.List;public class BatchOperationExample {public static void main(String[] args) {List<String> list = new ArrayList<>();// 单个添加操作long startTime = System.nanoTime();for (int i = 0; i < 1000000; i++) {list.add("Element" + i);}long endTime = System.nanoTime();System.out.println("Single add operations: " + (endTime - startTime) + " ns");// 清空列表list.clear();// 批量添加操作List<String> elements = new ArrayList<>();for (int i = 0; i < 1000000; i++) {elements.add("Element" + i);}startTime = System.nanoTime();list.addAll(elements);endTime = System.nanoTime();System.out.println("Batch add operations: " + (endTime - startTime) + " ns");}
}

3. 避免不必要的扩容

ArrayList和Vector在内部使用数组来存储元素。当数组容量不足时，会创建一个新的更大的数组，并将旧数组中的元素复制到新数组中。这个过程可能会导致性能下降。可以通过预分配足够的初始容量来避免这种情况。

示例代码

import java.util.ArrayList;
import java.util.List;public class InitialCapacityExample {public static void main(String[] args) {// 默认初始容量List<String> list1 = new ArrayList<>();long startTime = System.nanoTime();for (int i = 0; i < 1000000; i++) {list1.add("Element" + i);}long endTime = System.nanoTime();System.out.println("Default initial capacity: " + (endTime - startTime) + " ns");// 预分配初始容量List<String> list2 = new ArrayList<>(1000000);startTime = System.nanoTime();for (int i = 0; i < 1000000; i++) {list2.add("Element" + i);}endTime = System.nanoTime();System.out.println("Pre-allocated initial capacity: " + (endTime - startTime) + " ns");}
}

4. 使用迭代器进行批量删除

在遍历集合并删除元素时，使用迭代器比直接调用remove方法更高效。直接调用remove方法会导致集合重新计算索引，而使用迭代器则不会。

示例代码

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;public class IteratorRemoveExample {public static void main(String[] args) {List<Integer> list = new ArrayList<>();for (int i = 0; i < 1000000; i++) {list.add(i);}// 使用迭代器删除long startTime = System.nanoTime();Iterator<Integer> iterator = list.iterator();while (iterator.hasNext()) {if (iterator.next() % 2 == 0) {iterator.remove();}}long endTime = System.nanoTime();System.out.println("Using iterator remove: " + (endTime - startTime) + " ns");// 重置列表list.clear();for (int i = 0; i < 1000000; i++) {list.add(i);}// 直接调用remove方法startTime = System.nanoTime();for (int i = 0; i < list.size(); i++) {if (list.get(i) % 2 == 0) {list.remove(i--); // 注意索引调整}}endTime = System.nanoTime();System.out.println("Direct remove: " + (endTime - startTime) + " ns");}
}

5. 减少同步开销

在多线程环境下，尽量减少同步开销。例如，使用CopyOnWriteArrayList代替Vector或Collections.synchronizedList包装的ArrayList。

示例代码

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;public class SynchronizationExample {private static final int NUM_THREADS = 10;private static final int NUM_OPERATIONS = 10000;public static void main(String[] args) throws InterruptedException {testSynchronization(new ArrayList<>(), "ArrayList with Collections.synchronizedList");testSynchronization(new CopyOnWriteArrayList<>(), "CopyOnWriteArrayList");}private static void testSynchronization(List<Integer> list, String name) throws InterruptedException {if (list instanceof ArrayList) {list = Collections.synchronizedList(list);}ExecutorService executor = Executors.newFixedThreadPool(NUM_THREADS);long startTime = System.nanoTime();for (int i = 0; i < NUM_THREADS; i++) {executor.submit(() -> {for (int j = 0; j < NUM_OPERATIONS; j++) {list.add(j);}});}executor.shutdown();executor.awaitTermination(1, TimeUnit.MINUTES);long endTime = System.nanoTime();System.out.println(name + ": " + (endTime - startTime) + " ns");}
}

6. 使用缓存

对于频繁访问的数据，可以考虑使用缓存来提高性能。例如，使用ConcurrentHashMap来存储和检索数据。

示例代码

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;public class CacheExample {private static final ConcurrentMap<Integer, String> cache = new ConcurrentHashMap<>();public static void main(String[] args) {// 初始化缓存for (int i = 0; i < 1000000; i++) {cache.put(i, "Value" + i);}// 从缓存中获取数据long startTime = System.nanoTime();for (int i = 0; i < 1000000; i++) {String value = cache.get(i);}long endTime = System.nanoTime();System.out.println("Cache lookup: " + (endTime - startTime) + " ns");}
}