Java集合(2)：两个生成器的例子：Collection生成器CollectionData及Map生成器MapData

Collection生成器CollectionData

CollectionData体现了适配器模式的设计思想，它能把实现Generator接口的类的对象(包括上一章数组中的各种RandomGenerator)都复制到自身当中。

 import java.util.ArrayList;
 import java.util.LinkedHashSet;
 import java.util.Set;

 interface Generator<T> {
     T next();
 }

 class CollectionData<T> extends ArrayList<T> {
     private static final long serialVersionUID = 1L;
     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);
     }
 }

 class Animal implements Generator<String> {
     private String[] items = { "Dog", "Pig", "Cat" };
     private int index;
     @Override
     public String next() {
         return items[index++];
     }
 }

 public class Test2 {
     public static void main(String[] args) {
         Set<String> set = new LinkedHashSet<String>(new CollectionData<String>(new Animal(), 3));
         System.out.println(set); // [Dog, Pig, Cat]
         set.addAll(CollectionData.list(new Animal(), 3));
         System.out.println(set); // [Dog, Pig, Cat]
     }
 }

Map生成器MapData

我们可以使用同样的方式生成Map，我们可以Generator<K>，Generator<V>分开生成，也可以使用Pair<K, V>组装好K,V再生成。

 import java.util.Iterator;

 import java.util.LinkedHashMap;

 class Pair<K, V> {
     public final K key;
     public final V value;

     public Pair(K k, V v) {
         this.key = k;
         this.value = v;
     }
 }

 class MapData<K, V> extends LinkedHashMap<K, V> {
     private static final long serialVersionUID = 1L;

     // A single Pair Generator:
     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 static <K, V> MapData<K, V> map(Generator<Pair<K, V>> gen, int quantity) {
         return new MapData<K, V>(gen, quantity);
     }

     // Two separate Generators:
     public MapData(Generator<K> genK, Generator<V> genV, int quantity) {
         for (int i = 0; i < quantity; i++) {
             put(genK.next(), genV.next());
         }
     }

     public static <K, V> MapData<K, V> map(Generator<K> genK, Generator<V> genV, int quantity) {
         return new MapData<K, V>(genK, genV, quantity);
     }

     // A key Generator and a single value:
     public MapData(Generator<K> genK, V value, int quantity) {
         for (int i = 0; i < quantity; i++) {
             put(genK.next(), value);
         }
     }

     public static <K, V> MapData<K, V> map(Generator<K> genK, V value, int quantity) {
         return new MapData<K, V>(genK, value, quantity);
     }

     // An Iterable and a single value:
     public MapData(Iterable<K> genK, V value) {
         for (K key : genK) {
             put(key, value);
         }
     }

     public static <K, V> MapData<K, V> map(Iterable<K> genK, V value) {
         return new MapData<K, V>(genK, value);
     }
 }

 class Letters implements Generator<Pair<Integer, String>>, Iterable<Integer> {
     private int size = 9;
     private int number = 1;
     private char letter = 'A';

     @Override
     public Pair<Integer, String> next() {
         return new Pair<Integer, String>(number++, "" + letter++);
     }

     @Override
     public Iterator<Integer> iterator() {
         return new Iterator<Integer>() {
             @Override
             public Integer next() {
                 return number++;
             }

             @Override
             public boolean hasNext() {
                 return number < size;
             }

             @Override
             public void remove() {
                 throw new UnsupportedOperationException();
             }
         };
     }
 }

 public class Test3 {
     public static void main(String[] args) {
         // A single Pair Generator test
         MapData<Integer, String> data1 = MapData.map(new Letters(), 11);
         System.out.println(data1); // {1=A, 2=B, 3=C, 4=D, 5=E, 6=F, 7=G, 8=H, 9=I, 10=J, 11=K}
         // An Iterable and a single value test
         MapData<Integer, String> data2 = MapData.map(new Letters(), "Pop");
         System.out.println(data2); // {1=Pop, 2=Pop, 3=Pop, 4=Pop, 5=Pop, 6=Pop, 7=Pop, 8=Pop}
     }
 }