容器深入研究（1）：完整的容器分类法、填充容器（上）

Myth丶恋晨 2023-07-22 02:44 96阅读 0赞

之前介绍了java容器类库的概念和基本功能，这些对于容器的使用来说已经足够了。本章将更深入的探索这个重要的类库。

### 一、完整的容器分类法 ###

下面是集合类库更加完备的图。包括抽象类和遗留构件（不包括Queue的实现）：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70][]

java SE5新添加了：

*  Queue接口（正如之前所介绍，LinkedList已经为实现该接口做了修改）及其实现PriorityQueue和各种风格的BlockingQueue，其中BlockingQueue将在并发中介绍。
 *  ConcurrentMap接口及其实现ConcurrentHashMap，它们也是用于多线程机制的，同样会在并发中介绍。
 *  CopyOnWriteArrayList和CopyOnWriteArraySet，它们也是用于多线程机制的。
 *  EnumSet和EnumMap，为使用enum而设计的Set和Map的特殊实现，将在枚举类型中介绍。
 *  在Collections类中的多个便利方法。

虚线框表示abstract类，你可以看到大量的类的名字都是以Abstract开头的。这些类可能初看起来有点令人困惑，但是它们只是部分实现了特定接口的工具。例如，如果你在创建自己的Set，那么并不用从Set接口开始并实现其中的全部方法，只需从AbstractSet继承，然后执行一些创建新类必需的工作。但是，事实上容器类库包含足够多的功能，任何时刻都可以满足你的需求，因此你通常可以忽略以Abstract开头的这些类。

### 二、填充容器 ###

虽然容器打印的问题解决了，容器的填充仍然像java.util.Arrays一样面临同样的不足。就像Arrays一样，相应的Collections类也有一些实用的static方法，其中包括fill()。与Arrays版本一样，此fill()方法也是只复制同一个对象引用来填充整个容器的，并且只对List对象有用，但是所产生的列表可以传递给构造器或addAll()方法：

import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    
    class StringAddress {
    	private String s;
    
    	public StringAddress(String s) {
    		this.s = s;
    	}
    
    	public String toString() {
    		return super.toString() + " " + s;
    	}
    }
    
    public class FillingLists {
    	public static void main(String[] args) {
    		List<StringAddress> list = new ArrayList<>(Collections.nCopies(4, new StringAddress("Hello")));
    		System.out.println(list);
    		Collections.fill(list, new StringAddress("World!"));
    		System.out.println(list);
    	}
    }

这个示例展示了两种用于单个对象的引用来填充Collection的方式，第一种是使用Collections.nCopies()创建传递给构造器的List，这里填充的是ArrayList。

StringAddress的toString()方法调用Object.toString()并产生该类的名字，后面紧跟该对象的散列码的无符号十六进制表示（通过hashCode()生成的）。从输出中你可以看到所有引用都被设置为指向相同的对象，在第二种方法的Collection.fill()被调用之后也是如此。fill()方法的用处更有限，因为它只能替换已经在List中存在的元素，而不能添加新的元素。

### 三、一种Generator解决方案 ###

事实上，所有的Collection子类型都有一个接受另一个Collection对象的构造器，用所接收的Collection对象中的元素来填充新的容器。为了更加容易地创建测试数据，我们需要做的是构建接收Generator和quantity数值并将它们作为构造器参数的类：

import java.util.ArrayList;
    
    public class CollectionData<T> extends ArrayList<T> {
    	public CollectionData(Generator<T> gen, int quantity) {
    		for (int i = 0; i < quantity; i++) {
    			add(gen.next());
    		}
    	}
    
    	public static <T> CollectionData<T> list(Generator<T> gen, int quantity) {
    		return new CollectionData<T>(gen, quantity);
    	}
    }

这个类使用Generator在容器中放置所需数量的对象，然后所产生的容器可以传递给任何Collection的构造器，这个构造器会把其中的数据复制到自身中。addAll()方法是所有Collection子类型的一部分，它也可以用来组装现有的Collection。

泛型便利方法可以减少在使用类时所必需的类型检查数量。

CollectionData是适配器设计模式的一个实例，它将Generator适配到Collection的构造器上。

下面是初始化LinkedHashSet的一个示例：

import java.util.LinkedHashSet;
    import java.util.Set;
    
    import com.buba.util.CollectionData;
    import com.buba.util.Generator;
    
    class Government implements Generator<String> {
    
    	String[] foundation = "strange women lying in ponds distributing swords is no basis for a system of government"
    			.split(" ");
    	private int index;
    
    	@Override
    	public String next() {
    		return foundation[index++];
    	}
    
    }
    
    public class CollectionDataTest {
    	public static void main(String[] args) {
    		Set<String> set = new LinkedHashSet<>(new CollectionData<String>(new Government(), 15));
    		set.addAll(CollectionData.list(new Government(), 15));
    		System.out.println(set);
    	}
    }

这些元素的顺序与它们的插入顺序相同，因为LinkedHashSet维护的是保持了插入顺序的链接列表。

在数组中定义的所有操作符现在通过CollectionData适配器都是可用的。下面是使用了其中两个操作符的示例：

import java.util.ArrayList;
    import java.util.HashSet;
    
    import com.buba.util.CollectionData;
    import com.buba.util.RandomGenerator;
    
    public class CollectionDataGeneration {
    	public static void main(String[] args) {
    		System.out.println(new ArrayList<String>(CollectionData.list(new RandomGenerator.String(9), 10)));
    		System.out.println(new HashSet<Integer>(new CollectionData<Integer>(new RandomGenerator.Integer(), 10)));
    	}
    }

RandomGenerator.String所产生的String长度是通过构造器参数控制的。

### 四、Map生成器 ###

我们可以对Map使用相同的方式，但是这需要有一个Pair类，因为为了组装Map，每次调用Generator的next()方法都必须产生一个对象对（一个键和一个值）：

public class Pair<K, V> {
    	public final K key;
    	public final V value;
    
    	public Pair(K k, V v) {
    		key = k;
    		value = v;
    	}
    }

key和value域都是public和final的，这是为了使Pair成为只读的数据传输对象（或信使）。

Map适配器现在可以使用各种不同的Generator、Iterator和常量值的组合来填充Map初始化对象：

import java.util.LinkedHashMap;
    
    public class MapData<K, V> extends LinkedHashMap<K, V> {
    
    	public MapData(Generator<Pair<K, V>> gen, int quantity) {
    		for (int i = 0; i < quantity; i++) {
    			Pair<K, V> p = gen.next();
    			put(p.key, p.value);
    		}
    	}
    
    	public MapData(Generator<K> genK, Generator<V> genV, int quantity) {
    		for (int i = 0; i < quantity; i++) {
    			put(genK.next(), genV.next());
    		}
    	}
    
    	public MapData(Generator<K> genK, V value, int quantity) {
    		for (int i = 0; i < quantity; i++) {
    			put(genK.next(), value);
    		}
    	}
    
    	public MapData(Iterable<K> genK, Generator<V> genV) {
    		for (K k : genK) {
    			put(k, genV.next());
    		}
    	}
    
    	public MapData(Iterable<K> genK, V value) {
    		for (K k : genK) {
    			put(k, value);
    		}
    	}
    
    	public static <K, V> MapData<K, V> map(Generator<Pair<K, V>> gen, int quantity) {
    		return new MapData<K, V>(gen, quantity);
    	}
    
    	public static <K, V> MapData<K, V> map(Generator<K> genK, Generator<V> genV, int quantity) {
    		return new MapData<K, V>(genK, genV, quantity);
    	}
    
    	public static <K, V> MapData<K, V> map(Generator<K> genK, V value, int quantity) {
    		return new MapData<K, V>(genK, value, quantity);
    	}
    
    	public static <K, V> MapData<K, V> map(Iterable<K> genK, Generator<V> genV) {
    		return new MapData<K, V>(genK, genV);
    	}
    
    	public static <K, V> MapData<K, V> map(Iterable<K> genK, V value) {
    		return new MapData<K, V>(genK, value);
    	}
    }

这给了你一个机会，去选择使用单一的Generator<Pair<K,V>>、两个分离的Generator、一个Generator和一个常量值、一个Iterable（包括任何Collection）和一个Generator，还是一个Iterable和一个单一值。泛型便利方法可以减少任何在创建MapData类时所必需的类型检查数量。

下面是一个使用MapData的示例。LettersGenerator通过产生一个Iterator还实现了Iterable，通过这种方式，它可以被用来测试MapData.map()方法，而这些方法都需要用到Iterable：

import java.util.Iterator;
    
    import com.buba.util.CountingGenerator;
    import com.buba.util.Generator;
    import com.buba.util.MapData;
    import com.buba.util.Pair;
    import com.buba.util.RandomGenerator;
    
    class Letters implements Generator<Pair<Integer, String>>, Iterable<Integer> {
    
    	private int size = 9;
    	private int number = 1;
    	private char letter = 'A';
    
    	@Override
    	public Iterator<Integer> iterator() {
    		return new Iterator<Integer>() {
    
    			@Override
    			public boolean hasNext() {
    				return number < size;
    			}
    
    			@Override
    			public Integer next() {
    				return number++;
    			}
    		};
    	}
    
    	@Override
    	public Pair<Integer, String> next() {
    		return new Pair<Integer, String>(number++, "" + letter++);
    	}
    }
    
    public class MapDataTest {
    	public static void main(String[] args) {
    		System.out.println(MapData.map(new Letters(), 11));
    		System.out.println(MapData.map(new CountingGenerator.Character(), new RandomGenerator.String(3), 8));
    		System.out.println(MapData.map(new CountingGenerator.Character(), "Value", 6));
    		System.out.println(MapData.map(new Letters(), new RandomGenerator.String(3)));
    		System.out.println(MapData.map(new Letters(), "Pop"));
    	}
    }

可以使用工具来创建任何用于Map或Collection的生成数据集，然后通过构造器或Map.putAll()和Collection.addAll()方法来初始化Map和Collection。

**如果本文对您有很大的帮助，还请点赞关注一下。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70]: /images/20230528/49f0399f43084581b503b4648d213333.png