容器深入研究--Map生成器

Leefs 2020-01-07 AM 2247℃ 0条

# 容器深入研究--Map生成器

### 前言

本篇讲述《Java编程思想》第17.2.2小节，Map生成器

### 概述

为了组装Map,每次调用Generator的next()方法都必须产生一个对象对（一个键和一个值）：

```java
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初始化对象：**

```java
public class MapData<K,V> extends LinkedHashMap<K,V> {
    // 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);
        }
    }
    // 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());
        }
    }
    // 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);
        }
    }
    // An Iterable and a value Generator:
    public MapData(Iterable<K> genK, Generator<V> genV) {
        for(K key : genK) {
            put(key, genV.next());
        }
    }
    // An Iterable and a single value:
    public MapData(Iterable<K> genK, V value) {
        for(K key : genK) {
            put(key, value);
        }
    }
    // Generic convenience methods:
    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);
    }
}
```

> 代码分析

1. 1.此类继承LinkedHashMap父类，拥有父类的方法
2. 2.有五个不同参数类型的构造方法，分别以不同的方式初始化，生成对象。

+ (1)A single Pair Generator
+ (2)Two separate Generators
+ (3)A key Generator and a single value
+ (4)An Iterable and a value Generator
+ (5)An Iterable and a single value

**MapData.map()方法测试**

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

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

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

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

public void remove() {
                throw new UnsupportedOperationException();
            }
        };
    }
}
public class MapDataTest {
    public static void main(String[] args) {
        // Pair Generator:
        System.out.print(MapData.map(new Letters(), 11));
        // Two separate generators:
        System.out.print(MapData.map(new CountingGenerator.Character(),
                new RandomGenerator.String(3), 8));
        // A key Generator and a single value:
        System.out.print(MapData.map(new CountingGenerator.Character(), "Value", 6));
        // An Iterable and a value Generator:
        System.out.print(MapData.map(new Letters(), new RandomGenerator.String(3)));
        // An Iterable and a single value:
        System.out.print(MapData.map(new Letters(), "Pop"));
    }
}
```

> 运行结果

```java
{1=A, 2=B, 3=C, 4=D, 5=E, 6=F, 7=G, 8=H, 9=I, 10=J, 11=K}{a=YNz, b=brn, c=yGc, d=FOW, e=ZnT, f=cQr, g=Gse, h=GZM}{a=Value, b=Value, c=Value, d=Value, e=Value, f=Value}{1=mJM, 2=RoE, 3=suE, 4=cUO, 5=neO, 6=EdL, 7=smw, 8=HLG}{1=Pop, 2=Pop, 3=Pop, 4=Pop, 5=Pop, 6=Pop, 7=Pop, 8=Pop}
```

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

**示例中所用到的工具类**

**CountingGenerator.java**

```java
public class CountingGenerator {
    public static class Boolean implements Generator<java.lang.Boolean> {
        private boolean value = false;

public java.lang.Boolean next() {
            value = !value; // Just flips back and forth
            return value;
        }
    }

public static class Byte implements Generator<java.lang.Byte> {
        private byte value = 0;

public java.lang.Byte next() {
            return value++;
        }
    }

static char[] chars = ("abcdefghijklmnopqrstuvwxyz"
            + "ABCDEFGHIJKLMNOPQRSTUVWXYZ").toCharArray();

public static class Character implements Generator<java.lang.Character> {
        int index = -1;

public java.lang.Character next() {
            index = (index + 1) % chars.length;
            return chars[index];
        }
    }

public static class String implements Generator<java.lang.String> {
        private int length = 7;
        Generator<java.lang.Character> cg = new Character();

public String() {
        }

public String(int length) {
            this.length = length;
        }

public java.lang.String next() {
            char[] buf = new char[length];
            for (int i = 0; i < length; i++)
                buf[i] = cg.next();
            return new java.lang.String(buf);
        }
    }

public static class Short implements Generator<java.lang.Short> {
        private short value = 0;

public java.lang.Short next() {
            return value++;
        }
    }

public static class Integer implements Generator<java.lang.Integer> {
        private int value = 0;

public java.lang.Integer next() {
            return value++;
        }
    }

public static class Long implements Generator<java.lang.Long> {
        private long value = 0;

public java.lang.Long next() {
            return value++;
        }
    }

public static class Float implements Generator<java.lang.Float> {
        private float value = 0;

public java.lang.Float next() {
            float result = value;
            value += 1.0;
            return result;
        }
    }

public static class Double implements Generator<java.lang.Double> {
        private double value = 0.0;

public java.lang.Double next() {
            double result = value;
            value += 1.0;
            return result;
        }
    }
}
```

**RandomGenerator.java**

```java
public class RandomGenerator {
    private static Random r = new Random(47);

public static class Boolean implements Generator<java.lang.Boolean> {
        public java.lang.Boolean next() {
            return r.nextBoolean();
        }
    }

public static class Byte implements Generator<java.lang.Byte> {
        public java.lang.Byte next() {
            return (byte) r.nextInt();
        }
    }

public static class Character implements Generator<java.lang.Character> {
        public java.lang.Character next() {
            return CountingGenerator.chars[r
                    .nextInt(CountingGenerator.chars.length)];
        }
    }

public static class String extends CountingGenerator.String {
        // Plug in the random Character generator:
        {
            cg = new Character();
        } // Instance initializer

public String() {
        }

public String(int length) {
            super(length);
        }
    }

public static class Short implements Generator<java.lang.Short> {
        public java.lang.Short next() {
            return (short) r.nextInt();
        }
    }

public static class Integer implements Generator<java.lang.Integer> {
        private int mod = 10000;

public Integer() {
        }

public Integer(int modulo) {
            mod = modulo;
        }

public java.lang.Integer next() {
            return r.nextInt(mod);
        }
    }

public static class Long implements Generator<java.lang.Long> {
        private int mod = 10000;

public Long() {
        }

public Long(int modulo) {
            mod = modulo;
        }

public java.lang.Long next() {
            return new java.lang.Long(r.nextInt(mod));
        }
    }

public static class Float implements Generator<java.lang.Float> {
        public java.lang.Float next() {
            // Trim all but the first two decimal places:
            int trimmed = Math.round(r.nextFloat() * 100);
            return ((float) trimmed) / 100;
        }
    }

public static class Double implements Generator<java.lang.Double> {
        public java.lang.Double next() {
            long trimmed = Math.round(r.nextDouble() * 100);
            return ((double) trimmed) / 100;
        }
    }
}
```

标签: Java, Java编程思想, 容器深入研究

非特殊说明，本博所有文章均为博主原创。

如若转载，请注明出处：https://lilinchao.com/archives/391.html

上一篇填充容器--一种Generator解决方案

下一篇【转载】设计模式之享元模式

容器深入研究--Map生成器

评论已关闭

栏目分类

标签云

友情链接申请

容器深入研究--Map生成器

评论已关闭

 栏目分类

标签云

友情链接申请

栏目分类

标签云

友情链接申请