容器深入研究（2）：填充容器（下）

深藏阁楼爱情的钟 2023-07-22 09:08 5阅读 0赞

### 一、使用Abstract类 ###

对于生产用于容器的测试数据问题，另一种解决方式是创建定制的Collection和Map实现。每个java.util容器都有其自己的Abstract类，它们提供了该容器的部分实现，因此你必须做的只是去实现那些产生想要的容器所必需的方法。如果所产生的容器是只读的，就像它通常用测试数据那样，那么你需要提供的方法数量将减少到最少。

尽管在本例中不是特别需要，但是下面的解决方案还是提供了一个机会来演示另一种设计模式：享元。你可以在普通的解决方案需要过多的对象，或者产生普通对象太占用空间时使用享元。享元模式使得对象的一部分可以被具体化，因此， 与对象中的所有事物都包含在对象内部不同，我们可以在更加高效的外部表中查找对象的一部分或整体。（或者通过某些其他节省空间的计算来产生对象的一部分或整体）。

这个示例的关键之处在于演示通过继承java.util.Abstract来创建定制的Map和Collection到底有多简单。为了创建只读的Map，可以继承AbstractMap并实现entrySet()。为了创建只读的Set，可以继承AbstractSet并实现iterator()和size()。

本例中使用的数据集是由世界上的国家以及他们的首都构成的Map。capitals()方法产生国家与首都的Map，name()方法产生国名的List。在两种情况下，你都可以通过提供表所需尺寸的int参数来获取部分列表：

import java.util.AbstractMap;
    import java.util.AbstractSet;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Hashtable;
    import java.util.Iterator;
    import java.util.LinkedHashMap;
    import java.util.LinkedHashSet;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.TreeMap;
    import java.util.TreeSet;
    
    public class Countries {
    	public static final String[][] DATA = {
    			// 亚洲
    			{ "中国", "北京" }, { "以色列", "耶路撒冷" }, { "巴勒斯坦", "耶路撒冷" }, { "韩国", "首尔" }, { "也门", "萨那" }, { "卡塔尔", "多哈" },
    			{ "朝鲜", "平壤" }, { "菲律宾", "马尼拉" }, { "黎巴嫩", "贝鲁特" }, { "日本", "东京" }, { "新加坡", "新加坡" }, { "蒙古", "乌兰巴托" },
    			{ "马来西亚", "吉隆坡" }, { "马尔代夫", "马累" }, { "土耳其", "安卡拉" }, { "印度", "新德里" }, { "文莱", "斯里巴加湾市" },
    			{ "哈萨克斯坦", "阿斯塔纳" }, { "巴基斯坦", "伊斯兰堡" }, { "东帝汶", "帝力" }, { "乌兹别克斯坦", "塔什干" }, { "泰国", "曼谷" },
    			{ "印度尼西亚", "雅加达" }, { "吉尔吉斯斯坦", "比什凯克" }, { "越南", "河内" }, { "伊拉克", "巴格达" }, { "塔吉克斯坦", "杜尚别" },
    			{ "斯里兰卡", "科伦坡" }, { "伊朗", "德黑兰" }, { "土库曼斯坦", "阿什哈巴德" }, { "缅甸", "内比都" }, { "约旦", "安曼" }, { "阿塞拜疆", "巴库" },
    			{ "孟加拉国", "达卡" }, { "沙特阿拉伯", "利雅得" }, { "格鲁吉亚", "第比利斯" }, { "不丹", "廷布" }, { "阿联酋", "阿布扎比" },
    			{ "亚美尼亚", "埃里温" }, { "阿富汗", "喀布尔" }, { "阿曼", "马斯喀特" }, { "塞浦路斯", "尼科西亚" }, { "柬埔寨", "金边" },
    			{ "科威特", "科威特城" }, { "尼泊尔", "加德满都" }, { "巴林", "麦纳麦" }, { "老挝", "万象" }, { "叙利亚", "大马士革" },
    			//
    	};
    
    	/**
    	 * 轻量级Map
    	 */
    	private static class FlyweightMap extends AbstractMap<String, String> {
    		/**
    		 * 维护内部Entry对象
    		 */
    		private static class Entry implements Map.Entry<String, String> {
    			int index;
    
    			Entry(int index) {
    				this.index = index;
    			}
    
    			public boolean equals(Object o) {
    				return DATA[index][0].equals(o);
    			}
    
    			public String getKey() {
    				return DATA[index][0];
    			}
    
    			public String getValue() {
    				return DATA[index][1];
    			}
    
    			public String setValue(String value) {
    				throw new UnsupportedOperationException();
    			}
    
    			public int hashCode() {
    				return DATA[index][0].hashCode();
    			}
    		}
    
    		/**
    		 * EntrySet实现
    		 */
    		static class EntrySet extends AbstractSet<Map.Entry<String, String>> {
    			private int size;
    
    			EntrySet(int size) {
    				if (size < 0) {
    					this.size = 0;
    				} else if (size > DATA.length) {
    					this.size = DATA.length;
    				} else {
    					this.size = size;
    				}
    			}
    
    			public int size() {
    				return size;
    			}
    
    			/**
    			 * 内部迭代器
    			 */
    			private class Iter implements Iterator<Map.Entry<String, String>> {
    				private Entry entry = new Entry(-1);
    
    				@Override
    				public boolean hasNext() {
    					return entry.index < size - 1;
    				}
    
    				@Override
    				public java.util.Map.Entry<String, String> next() {
    					entry.index++;
    					return entry;
    				}
    			}
    
    			public Iterator<Map.Entry<String, String>> iterator() {
    				return new Iter();
    			}
    		}
    
    		private static Set<Map.Entry<String, String>> entries = new EntrySet(DATA.length);
    
    		public Set<Map.Entry<String, String>> entrySet() {
    			return entries;
    		}
    	}
    
    	// 选择指定数量的数据
    	static Map<String, String> select(int size) {
    		return new FlyweightMap() {
    			public Set<Map.Entry<String, String>> entrySet() {
    				return new EntrySet(size);
    			}
    		};
    	}
    
    	static Map<String, String> map = new FlyweightMap();
    
    	// 获取国家首都数据
    	public static Map<String, String> capitals() {
    		return map;
    	}
    
    	public static Map<String, String> capitals(int size) {
    		return select(size);
    	}
    
    	static List<String> names = new ArrayList<String>(map.keySet());
    
    	// 获取国家数据
    	public static List<String> names() {
    		return names;
    	}
    
    	public static List<String> names(int size) {
    		return new ArrayList<String>(select(size).keySet());
    	}
    
    	public static void main(String[] args) {
    		System.out.println(capitals(10));
    		System.out.println(names(10));
    		System.out.println(new HashMap<String, String>(capitals(3)));
    		System.out.println(new LinkedHashMap<String, String>(capitals(3)));
    		System.out.println(new TreeMap<String, String>(capitals(3)));
    		System.out.println(new Hashtable<String, String>(capitals(3)));
    		System.out.println(new HashSet<String>(names(6)));
    		System.out.println(new LinkedHashSet<String>(names(6)));
    		System.out.println(new TreeSet<String>(names(6)));
    		System.out.println(new ArrayList<String>(names(6)));
    		System.out.println(new LinkedList<String>(names(6)));
    		System.out.println(capitals().get("中国"));
    	}
    }

二维数组String DATA是public的，因此它可以在其他地方使用。FlyweightMap必须实现entrySet()方法，它需要定制的Set实现和定制Map.Entry类。这里正是享元部分：每个Map.Entry对象都只存储了它的索引，而不是实际的键和值。当你调用getKey和getValue()时，它们会使用该索引来返回恰当的DATA元素。EntrySet可以确保它们的size不会大于DATA。

你可以在EntrySet.Iterator中看到享元其他部分的实现。与为DATA中的每个数据对都创建Map.Entry对象不同，每个迭代器都只有一个Map.Entry。Entry对象被用作数据的视窗，它只包含在静态字符串数组中索引。你每次调用迭代器的next()方法时，Entry中的index都会递增，使其指向下一个元素对，然后从next()返回该Iterator所持有的单一的Entry对象。

select()方法将产生一个包含指定尺寸的EntrySet的FlyweightMap，它会被用于重载过的capitals()和names()方法，正如你在main()中所演示的那样。

对于某些测试，Countries的尺寸受限会成为问题。我们可以采用与定制容器相同的方式来解决，其中定制容器是经过初始化的，并且具有任意尺寸的数据集。下面的类是一个List，它可以具有任意尺寸，并且用Integer数据（有效的）进行了预初始化：

import java.util.AbstractList;
    
    public class CountingIntegerList extends AbstractList<Integer> {
    
    	private int size;
    
    	public CountingIntegerList(int size) {
    		this.size = size < 0 ? 0 : size;
    	}
    
    	@Override
    	public Integer get(int index) {
    		return Integer.valueOf(index);
    	}
    
    	@Override
    	public int size() {
    		return size;
    	}
    
    	public static void main(String[] args) {
    		System.out.println(new CountingIntegerList(30));
    	}
    }

为了从AbstractList创建只读的List，你必须实现get()和size()。这里再次使用了享元解决方案：当你寻找值时，get()将产生它，因此这个List实际上并不比组装。

下面是包含经过预初始化，并且都是唯一的Integer和String的Map，它可以具有任意尺寸：

import java.util.AbstractMap;
    import java.util.LinkedHashSet;
    import java.util.Map;
    import java.util.Set;
    
    public class CountingMapData extends AbstractMap<Integer, String> {
    
    	private int size;
    	private static String[] chars = "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z".split(" ");
    
    	public CountingMapData(int size) {
    		if (size < 0) {
    			this.size = 0;
    		}
    		this.size = size;
    	}
    
    	public static class Entry implements Map.Entry<Integer, String> {
    
    		int index;
    
    		Entry(int index) {
    			this.index = index;
    		}
    
    		public boolean equals(Object o) {
    			return Integer.valueOf(index).equals(o);
    		}
    
    		@Override
    		public Integer getKey() {
    			return index;
    		}
    
    		@Override
    		public String getValue() {
    			return chars[index % chars.length] + Integer.toString(index / chars.length);
    		}
    
    		@Override
    		public String setValue(String value) {
    			throw new UnsupportedOperationException();
    		}
    
    		public int hashCode() {
    			return Integer.valueOf(index).hashCode();
    		}
    	}
    
    	@Override
    	public Set<java.util.Map.Entry<Integer, String>> entrySet() {
    		Set<Map.Entry<Integer, String>> entries = new LinkedHashSet<Map.Entry<Integer, String>>();
    		for (int i = 0; i < size; i++) {
    			entries.add(new Entry(i));
    		}
    		return entries;
    	}
    
    	public static void main(String[] args) {
    		System.out.println(new CountingMapData(60));
    	}
    }

这里使用的是LinkedHashSet，而不是定制的Set类，因此享元并未完全实现。

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