Javaadvancedcollectiontutorial - from Basics to advanced

tutorialoverview

本tutorial将详细介绍Javaadvancedcollection core concepts and 实践techniques, includingconcurrentcollection, 不可变collection, collectiontoolclass advanced用法, collectionperformanceoptimization, collection 自定义implementationetc. in 容. through本tutorial Learning, you willable towriting更加 high 效, threadsecurity collectioncode, 充分利用Javacollectionframework advanced features.

concurrentcollection

concurrentcollection is for many threadenvironmentdesign collectionclass, 它们providing了threadsecurity operation, 避免了显式synchronization 需要. Java in java.util.concurrentpackageinproviding了 many 种concurrentcollection:

1. ConcurrentHashMap

ConcurrentHashMap is HashMap threadsecurityversion, 它using分段locktechniques, 允许 many 个thread同时读写不同段, improving了concurrentperformance.

import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

public class ConcurrentHashMapExample {
    public static void main(String[] args) {
        // creationConcurrentHashMap
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        
        // 添加元素
        map.put("key1", 1);
        map.put("key2", 2);
        map.put("key3", 3);
        
        // 读取元素
        System.out.println("key1 值: " + map.get("key1"));
        
        // replace元素
        map.replace("key2", 2, 20);
        System.out.println("replace after key2 值: " + map.get("key2"));
        
        // 原子operation: such as果key不存 in 则添加
        map.putIfAbsent("key4", 4);
        map.putIfAbsent("key1", 100); // 不会replace, 因 for key1已存 in 
        System.out.println("key4 值: " + map.get("key4"));
        System.out.println("key1 值: " + map.get("key1"));
        
        // 移除元素
        map.remove("key3", 3);
        System.out.println("key3 is 否存 in : " + map.containsKey("key3"));
        
        // 遍历元素
        System.out.println("\n遍历ConcurrentHashMap:");
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

2. CopyOnWriteArrayList

CopyOnWriteArrayList is ArrayList threadsecurityversion, 它through写时copymechanismimplementationthreadsecurity, 适合读 many 写 few 场景.

import java.util.concurrent.CopyOnWriteArrayList;
import java.util.List;

public class CopyOnWriteArrayListExample {
    public static void main(String[] args) {
        // creationCopyOnWriteArrayList
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        
        // 添加元素
        list.add("元素1");
        list.add("元素2");
        list.add("元素3");
        
        // 读取元素
        System.out.println("index1 元素: " + list.get(1));
        
        // modify元素
        list.set(1, "modify after  元素2");
        System.out.println("modify after index1 元素: " + list.get(1));
        
        // 移除元素
        list.remove(2);
        System.out.println("移除 after list big  small : " + list.size());
        
        // 遍历元素
        System.out.println("\n遍历CopyOnWriteArrayList:");
        for (String element : list) {
            System.out.println(element);
        }
        
        // 批量添加元素
        List<String> newElements = List.of("元素4", "元素5");
        list.addAll(newElements);
        System.out.println("\n批量添加 after list:");
        list.forEach(System.out::println);
    }
}

3. CopyOnWriteArraySet

CopyOnWriteArraySet is HashSet threadsecurityversion, 它 in 部usingCopyOnWriteArrayListimplementation, 同样适合读 many 写 few 场景.

import java.util.concurrent.CopyOnWriteArraySet;
import java.util.Set;

public class CopyOnWriteArraySetExample {
    public static void main(String[] args) {
        // creationCopyOnWriteArraySet
        CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet<>();
        
        // 添加元素
        set.add("元素1");
        set.add("元素2");
        set.add("元素3");
        set.add("元素1"); // 重复元素, 不会添加
        
        // check元素 is 否存 in 
        System.out.println("元素2 is 否存 in : " + set.contains("元素2"));
        
        // 移除元素
        set.remove("元素3");
        System.out.println("移除 after collection big  small : " + set.size());
        
        // 遍历元素
        System.out.println("\n遍历CopyOnWriteArraySet:");
        for (String element : set) {
            System.out.println(element);
        }
    }
}

4. ConcurrentLinkedQueue

ConcurrentLinkedQueue is a 无界 threadsecurityqueue, 它using链表implementation, 适合 high concurrent场景.

import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.Queue;

public class ConcurrentLinkedQueueExample {
    public static void main(String[] args) {
        // creationConcurrentLinkedQueue
        ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();
        
        // 添加元素
        queue.offer("元素1");
        queue.offer("元素2");
        queue.offer("元素3");
        
        // 查看队首元素
        System.out.println("队首元素: " + queue.peek());
        
        // 移除并返回队首元素
        System.out.println("移除 元素: " + queue.poll());
        System.out.println("移除 after 队首元素: " + queue.peek());
        
        // 遍历元素
        System.out.println("\n遍历ConcurrentLinkedQueue:");
        for (String element : queue) {
            System.out.println(element);
        }
        
        // checkqueue is 否 for 空
        System.out.println("queue is 否 for 空: " + queue.isEmpty());
        
        // 获取queue big  small 
        System.out.println("queue big  small : " + queue.size());
    }
}

5. BlockingQueue

BlockingQueue is a support阻塞operation queueinterface, 它providing了 in queue for 空时阻塞获取operation, in queue满时阻塞添加operation capacity. common implementationclass has ArrayBlockingQueue, LinkedBlockingQueue, PriorityBlockingQueueetc..

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

public class BlockingQueueExample {
    public static void main(String[] args) {
        // creation容量 for 3 ArrayBlockingQueue
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(3);
        
        // 添加元素
        try {
            queue.put("元素1");
            queue.put("元素2");
            queue.put("元素3");
            System.out.println("queue已满, 尝试添加第四个元素...");
            // 尝试添加第四个元素, 最 many etc.待2秒
            boolean added = queue.offer("元素4", 2, TimeUnit.SECONDS);
            System.out.println("元素4 is 否添加成功: " + added);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        // 移除元素
        try {
            System.out.println("移除元素: " + queue.take());
            System.out.println("移除 after queue big  small : " + queue.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        // 遍历元素
        System.out.println("\n遍历BlockingQueue:");
        for (String element : queue) {
            System.out.println(element);
        }
    }
}

// produce者-consume者example
class ProducerConsumerExample {
    private static BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);
    
    public static void main(String[] args) {
        // creationproduce者thread
        Thread producer = new Thread(() -> {
            try {
                for (int i = 1; i <= 10; i++) {
                    queue.put(i);
                    System.out.println("produce者produce: " + i);
                    Thread.sleep(500);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        
        // creationconsume者thread
        Thread consumer = new Thread(() -> {
            try {
                for (int i = 1; i <= 10; i++) {
                    Integer value = queue.take();
                    System.out.println("consume者consume: " + value);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        
        // 启动thread
        producer.start();
        consumer.start();
    }
}

不可变collection

不可变collection is 指creation after 不能modify collection, 它们providing了更 good threadsecurity性 and reliability. Java 9引入了便捷 method来creation不可变collection:

1. usingof()methodcreation不可变collection

import java.util.List;
import java.util.Set;
import java.util.Map;

public class ImmutableCollectionsExample {
    public static void main(String[] args) {
        // creation不可变List
        List<String> immutableList = List.of("元素1", "元素2", "元素3");
        System.out.println("不可变List: " + immutableList);
        
        // 尝试modify不可变List (会抛出UnsupportedOperationException) 
        try {
            immutableList.add("元素4");
        } catch (UnsupportedOperationException e) {
            System.out.println("尝试modify不可变List失败: " + e.getMessage());
        }
        
        // creation不可变Set
        Set<String> immutableSet = Set.of("元素1", "元素2", "元素3");
        System.out.println("\n不可变Set: " + immutableSet);
        
        // 尝试modify不可变Set (会抛出UnsupportedOperationException) 
        try {
            immutableSet.add("元素4");
        } catch (UnsupportedOperationException e) {
            System.out.println("尝试modify不可变Set失败: " + e.getMessage());
        }
        
        // creation不可变Map
        Map<String, Integer> immutableMap = Map.of(
            "key1", 1,
            "key2", 2,
            "key3", 3
        );
        System.out.println("\n不可变Map: " + immutableMap);
        
        // 尝试modify不可变Map (会抛出UnsupportedOperationException) 
        try {
            immutableMap.put("key4", 4);
        } catch (UnsupportedOperationException e) {
            System.out.println("尝试modify不可变Map失败: " + e.getMessage());
        }
        
        // creationpackage含 many 个元素 不可变Map (Java 9+) 
        Map<String, Integer> largeImmutableMap = Map.ofEntries(
            Map.entry("key1", 1),
            Map.entry("key2", 2),
            Map.entry("key3", 3),
            Map.entry("key4", 4),
            Map.entry("key5", 5)
        );
        System.out.println("\n big 型不可变Map: " + largeImmutableMap);
    }
}

2. usingCollections.unmodifiable*methodcreation不可变collection

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.HashSet;

public class UnmodifiableCollectionsExample {
    public static void main(String[] args) {
        // creation可变List
        List<String> mutableList = new ArrayList<>();
        mutableList.add("元素1");
        mutableList.add("元素2");
        mutableList.add("元素3");
        
        // creation不可变List视graph
        List<String> unmodifiableList = Collections.unmodifiableList(mutableList);
        System.out.println("不可变List视graph: " + unmodifiableList);
        
        // 尝试modify不可变List视graph (会抛出UnsupportedOperationException) 
        try {
            unmodifiableList.add("元素4");
        } catch (UnsupportedOperationException e) {
            System.out.println("尝试modify不可变List视graph失败: " + e.getMessage());
        }
        
        // 注意: 原始可变List仍然可以modify, 并且会影响不可变视graph
        mutableList.add("元素4");
        System.out.println("modify原始List after , 不可变视graph: " + unmodifiableList);
        
        // creation不可变Set视graph
        Set<String> mutableSet = new HashSet<>();
        mutableSet.add("元素1");
        mutableSet.add("元素2");
        Set<String> unmodifiableSet = Collections.unmodifiableSet(mutableSet);
        System.out.println("\n不可变Set视graph: " + unmodifiableSet);
        
        // creation不可变Map视graph
        Map<String, Integer> mutableMap = new HashMap<>();
        mutableMap.put("key1", 1);
        mutableMap.put("key2", 2);
        Map<String, Integer> unmodifiableMap = Collections.unmodifiableMap(mutableMap);
        System.out.println("\n不可变Map视graph: " + unmodifiableMap);
    }
}

collectiontoolclass advanced用法

Javaproviding了Collections and Arraysetc.toolclass, 它们package含了许 many 用于operationcollection 静态method:

1. Collectionstoolclass

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Comparator;

public class CollectionsadvancedExample {
    public static void main(String[] args) {
        // creationList
        List<Integer> numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(2);
        numbers.add(8);
        numbers.add(1);
        numbers.add(9);
        System.out.println("原始List: " + numbers);
        
        // sort
        Collections.sort(numbers);
        System.out.println("sort after List: " + numbers);
        
        // 逆序sort
        Collections.sort(numbers, Comparator.reverseOrder());
        System.out.println("逆序sort after List: " + numbers);
        
        // 洗牌 (随机打乱顺序) 
        Collections.shuffle(numbers);
        System.out.println("洗牌 after List: " + numbers);
        
        // find元素 (需要先sort) 
        Collections.sort(numbers);
        int index = Collections.binarySearch(numbers, 5);
        System.out.println("\nsort after List: " + numbers);
        System.out.println("元素5 index: " + index);
        
        // 填充collection
        List<String> strings = new ArrayList<>(5);
        for (int i = 0; i < 5; i++) {
            strings.add("");
        }
        Collections.fill(strings, "Hello");
        System.out.println("\n填充 after  List: " + strings);
        
        // replace元素
        Collections.replaceAll(numbers, 5, 50);
        System.out.println("\nreplace元素 after  List: " + numbers);
        
        // 拷贝collection
        List<Integer> destination = new ArrayList<>(numbers.size());
        for (int i = 0; i < numbers.size(); i++) {
            destination.add(0);
        }
        Collections.copy(destination, numbers);
        System.out.println("\n拷贝 after  List: " + destination);
        
        // 最 small /最 big 值
        System.out.println("\nListin 最 small 值: " + Collections.min(numbers));
        System.out.println("Listin 最 big 值: " + Collections.max(numbers));
        
        // 频率statistics
        System.out.println("\n元素2 出现次数: " + Collections.frequency(numbers, 2));
        
        // 旋转collection
        Collections.rotate(numbers, 2);
        System.out.println("\n旋转2位 after  List: " + numbers);
    }
}

2. Arraystoolclass

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class ArraysadvancedExample {
    public static void main(String[] args) {
        // creationarray
        int[] numbers = {5, 2, 8, 1, 9};
        System.out.println("原始array: " + Arrays.toString(numbers));
        
        // sort
        Arrays.sort(numbers);
        System.out.println("sort after array: " + Arrays.toString(numbers));
        
        // 二分find
        int index = Arrays.binarySearch(numbers, 5);
        System.out.println("元素5 index: " + index);
        
        // 填充array
        int[] filledArray = new int[5];
        Arrays.fill(filledArray, 10);
        System.out.println("\n填充 after  array: " + Arrays.toString(filledArray));
        
        // 拷贝array
        int[] copiedArray = Arrays.copyOf(numbers, numbers.length);
        System.out.println("\n拷贝 after  array: " + Arrays.toString(copiedArray));
        
        // 拷贝array 一部分
        int[] partialArray = Arrays.copyOfRange(numbers, 1, 4);
        System.out.println("拷贝array 一部分: " + Arrays.toString(partialArray));
        
        // 比较array
        boolean equal = Arrays.equals(numbers, copiedArray);
        System.out.println("\n两个array is 否相etc.: " + equal);
        
        // 哈希码
        System.out.println("array 哈希码: " + Arrays.hashCode(numbers));
        
        // array转List
        List<Integer> numberList = Arrays.stream(numbers).boxed().toList();
        System.out.println("\narray转List: " + numberList);
        
        // stringarray转List
        String[] strings = {"Hello", "World", "Java"};
        List<String> stringList = Arrays.asList(strings);
        System.out.println("\nstringarray转List: " + stringList);
        
        // usingStreamoperationarray
        System.out.println("\nusingStreamoperationarray:");
        Arrays.stream(numbers)
              .filter(n -> n > 5)
              .forEach(n -> System.out.print(n + " "));
        System.out.println();
    }
}

collectionperformanceoptimization

in usingcollection时, 合理选择 and using可以显著improving程序performance:

1. collection选择 performance考量

List选择:
- ArrayList: 随机访问 fast , 插入delete slow , 适合读 many 写 few 场景
- LinkedList: 插入delete fast , 随机访问 slow , 适合写 many 读 few 场景
- Vector: threadsecurity但performance较差, 推荐usingCollections.synchronizedList or CopyOnWriteArrayList
Set选择:
- HashSet: find, 插入, deleteoperation fast , 基于HashMapimplementation
- LinkedHashSet: 保持插入顺序, performance略 low 于HashSet
- TreeSet: has 序collection, 基于红黑treeimplementation, find, 插入, deleteoperation时间complexity for O(log n)
Map选择:
- HashMap: find, 插入, deleteoperation fast , 无序
- LinkedHashMap: 保持插入顺序, performance略 low 于HashMap
- TreeMap: has 序map, 基于红黑treeimplementation, find, 插入, deleteoperation时间complexity for O(log n)
- Hashtable: threadsecurity但performance较差, 推荐usingConcurrentHashMap
- ConcurrentHashMap: threadsecurity且performance较 good , 适合 high concurrent场景

2. collection初始化容量

for collection指定合适初始容量可以reducing扩容operation, improvingperformance:

import java.util.ArrayList;
import java.util.HashMap;

public class CollectionCapacityExample {
    public static void main(String[] args) {
        // 不指定初始容量
        long startTime1 = System.currentTimeMillis();
        ArrayList<Integer> list1 = new ArrayList<>();
        for (int i = 0; i < 1000000; i++) {
            list1.add(i);
        }
        long endTime1 = System.currentTimeMillis();
        System.out.println("不指定初始容量 ArrayList耗时: " + (endTime1 - startTime1) + " 毫秒");
        
        // 指定初始容量
        long startTime2 = System.currentTimeMillis();
        ArrayList<Integer> list2 = new ArrayList<>(1000000);
        for (int i = 0; i < 1000000; i++) {
            list2.add(i);
        }
        long endTime2 = System.currentTimeMillis();
        System.out.println("指定初始容量 ArrayList耗时: " + (endTime2 - startTime2) + " 毫秒");
        
        // 不指定初始容量
        long startTime3 = System.currentTimeMillis();
        HashMap<Integer, Integer> map1 = new HashMap<>();
        for (int i = 0; i < 1000000; i++) {
            map1.put(i, i);
        }
        long endTime3 = System.currentTimeMillis();
        System.out.println("\n不指定初始容量 HashMap耗时: " + (endTime3 - startTime3) + " 毫秒");
        
        // 指定初始容量 and load因子
        long startTime4 = System.currentTimeMillis();
        HashMap<Integer, Integer> map2 = new HashMap<>(1000000, 0.75f);
        for (int i = 0; i < 1000000; i++) {
            map2.put(i, i);
        }
        long endTime4 = System.currentTimeMillis();
        System.out.println("指定初始容量 HashMap耗时: " + (endTime4 - startTime4) + " 毫秒");
    }
}

3. collection遍历performance

不同遍历方式performance has 所不同:

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class CollectionIterationExample {
    public static void main(String[] args) {
        // creationpackage含1000000个元素 List
        List<Integer> list = new ArrayList<>(1000000);
        for (int i = 0; i < 1000000; i++) {
            list.add(i);
        }
        
        // using增强for循环遍历
        long startTime1 = System.currentTimeMillis();
        int sum1 = 0;
        for (Integer number : list) {
            sum1 += number;
        }
        long endTime1 = System.currentTimeMillis();
        System.out.println("using增强for循环遍历耗时: " + (endTime1 - startTime1) + " 毫秒,  and : " + sum1);
        
        // using普通for循环遍历 (基于index) 
        long startTime2 = System.currentTimeMillis();
        int sum2 = 0;
        for (int i = 0; i < list.size(); i++) {
            sum2 += list.get(i);
        }
        long endTime2 = System.currentTimeMillis();
        System.out.println("using普通for循环遍历耗时: " + (endTime2 - startTime2) + " 毫秒,  and : " + sum2);
        
        // usingIterator遍历
        long startTime3 = System.currentTimeMillis();
        int sum3 = 0;
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            sum3 += iterator.next();
        }
        long endTime3 = System.currentTimeMillis();
        System.out.println("usingIterator遍历耗时: " + (endTime3 - startTime3) + " 毫秒,  and : " + sum3);
        
        // usingStream遍历
        long startTime4 = System.currentTimeMillis();
        int sum4 = list.stream().mapToInt(Integer::intValue).sum();
        long endTime4 = System.currentTimeMillis();
        System.out.println("usingStream遍历耗时: " + (endTime4 - startTime4) + " 毫秒,  and : " + sum4);
        
        // usingparallelStream遍历
        long startTime5 = System.currentTimeMillis();
        int sum5 = list.parallelStream().mapToInt(Integer::intValue).sum();
        long endTime5 = System.currentTimeMillis();
        System.out.println("usingparallelStream遍历耗时: " + (endTime5 - startTime5) + " 毫秒,  and : " + sum5);
    }
}

collection 自定义implementation

in 某些特殊场景 under , 我们可能需要自定义collectionimplementation以满足specificrequirements:

1. 自定义Listimplementation

import java.util.AbstractList;
import java.util.List;
import java.util.NoSuchElementException;

public class CustomListExample {
    public static void main(String[] args) {
        // creation自定义List
        List<Integer> rangeList = new RangeList(1, 10);
        System.out.println("RangeList(1, 10): " + rangeList);
        System.out.println("list big  small : " + rangeList.size());
        System.out.println("index5 元素: " + rangeList.get(5));
        System.out.println(" is 否package含元素7: " + rangeList.contains(7));
        System.out.println(" is 否package含元素15: " + rangeList.contains(15));
    }
}

// 自定义Listimplementation, 表示一个整数范围
class RangeList extends AbstractList<Integer> {
    private final int start;
    private final int end;
    
    public RangeList(int start, int end) {
        if (start > end) {
            throw new IllegalArgumentException("start must be less than or equal to end");
        }
        this.start = start;
        this.end = end;
    }
    
    @Override
    public Integer get(int index) {
        if (index < 0 || index >= size()) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size());
        }
        return start + index;
    }
    
    @Override
    public int size() {
        return end - start + 1;
    }
}

2. 自定义Setimplementation

import java.util.AbstractSet;
import java.util.Iterator;
import java.util.Set;

public class CustomSetExample {
    public static void main(String[] args) {
        // creation自定义Set
        Set<String> caseInsensitiveSet = new CaseInsensitiveSet();
        caseInsensitiveSet.add("Hello");
        caseInsensitiveSet.add("hello"); // 应该被视 for 重复元素
        caseInsensitiveSet.add("World");
        caseInsensitiveSet.add("WORLD"); // 应该被视 for 重复元素
        
        System.out.println("CaseInsensitiveSet: " + caseInsensitiveSet);
        System.out.println("collection big  small : " + caseInsensitiveSet.size());
        System.out.println(" is 否package含元素'hello': " + caseInsensitiveSet.contains("hello"));
        System.out.println(" is 否package含元素'Hello': " + caseInsensitiveSet.contains("Hello"));
        System.out.println(" is 否package含元素'WORLD': " + caseInsensitiveSet.contains("WORLD"));
    }
}

// 自定义Setimplementation, ignorestring big  small 写
class CaseInsensitiveSet extends AbstractSet<String> {
    private Set<String> delegate = new java.util.HashSet<>();
    
    @Override
    public boolean add(String s) {
        return delegate.add(s.toLowerCase());
    }
    
    @Override
    public boolean contains(Object o) {
        if (o instanceof String) {
            return delegate.contains(((String) o).toLowerCase());
        }
        return false;
    }
    
    @Override
    public boolean remove(Object o) {
        if (o instanceof String) {
            return delegate.remove(((String) o).toLowerCase());
        }
        return false;
    }
    
    @Override
    public Iterator<String> iterator() {
        return delegate.iterator();
    }
    
    @Override
    public int size() {
        return delegate.size();
    }
}

实践case

concurrentcollectionimplementationthreadsecurity 计数器

本caseusingConcurrentHashMapimplementation一个threadsecurity 计数器, support many threadconcurrentoperation.

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ConcurrentCounterExample {
    public static void main(String[] args) throws InterruptedException {
        // creation计数器
        ConcurrentCounter counter = new ConcurrentCounter();
        
        // creationthread池
        ExecutorService executor = Executors.newFixedThreadPool(10);
        
        // creationCountDownLatch, 用于etc.待所 has threadcompletion
        CountDownLatch latch = new CountDownLatch(1000);
        
        // submitting1000个task, 每个task增加计数器100次
        for (int i = 0; i < 1000; i++) {
            executor.submit(() -> {
                try {
                    for (int j = 0; j < 100; j++) {
                        counter.increment("total");
                        counter.increment("thread-" + Thread.currentThread().getId());
                    }
                } finally {
                    latch.countDown();
                }
            });
        }
        
        // etc.待所 has taskcompletion
        latch.await();
        
        // 关闭thread池
        executor.shutdown();
        
        // 打印结果
        System.out.println("总计数: " + counter.get("total"));
        System.out.println("计数器 big  small : " + counter.size());
        
        // reset计数器
        counter.reset("total");
        System.out.println("reset after 总计数: " + counter.get("total"));
    }
}

// usingConcurrentHashMapimplementation threadsecurity计数器
class ConcurrentCounter {
    private final ConcurrentHashMap<String, Long> counts = new ConcurrentHashMap<>();
    
    /**
     * 增加指定键 计数
     * @param key 计数器键
     * @return 增加 after  值
     */
    public long increment(String key) {
        return counts.merge(key, 1L, Long::sum);
    }
    
    /**
     * 增加指定键 计数
     * @param key 计数器键
     * @param delta 增加 值
     * @return 增加 after  值
     */
    public long increment(String key, long delta) {
        return counts.merge(key, delta, Long::sum);
    }
    
    /**
     * 获取指定键 计数
     * @param key 计数器键
     * @return 计数 值, such as果键不存 in 则返回0
     */
    public long get(String key) {
        return counts.getOrDefault(key, 0L);
    }
    
    /**
     * reset指定键 计数
     * @param key 计数器键
     */
    public void reset(String key) {
        counts.remove(key);
    }
    
    /**
     * reset所 has 计数
     */
    public void resetAll() {
        counts.clear();
    }
    
    /**
     * 获取计数器  big  small 
     * @return 计数器  big  small 
     */
    public int size() {
        return counts.size();
    }
}

互动练习

练习1: concurrentcollectionusing

usingConcurrentHashMapimplementation一个 simple cachesystem, support添加, 获取 and deletecache项, 并确保threadsecurity.

练习2: 不可变collection

creation一个method, 接收一个Listserving asparameter, 返回该List 不可变replica. 然 after creation另一个method, 接收一个Mapserving asparameter, 返回该Map 不可变replica.

练习3: collectionperformanceoptimization

比较ArrayList and LinkedList in 不同operation (随机访问, 插入, delete) under performancediff. creationpackage含100000个元素 ArrayList and LinkedList, 分别test随机访问第50000个元素, in in间位置插入元素, deletein间位置元素时间.

练习4: 自定义collection

creation一个自定义 Setimplementation, 只store唯一偶数. 当尝试添加奇数时, 应该ignore该operation.