java 容器深入研究之使用Abstract类定制

package org.rui.collection3.map;

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;

/***
 * 集合
 * 使用Abstract类
 *
 * @author lenovo
 *
 */
public class Countries
{
	public static final String[][] DATA =
	{
			// Africa
			{ "A", "a" },
			{ "B", "b" },
			{ "C", "c" },
			{ "D", "d" },
			{ "E", "e" },
			{ "F", "f" },
			{ "G", "g" },
			{ "H", "h" },
			{ "I", "i" },
			{ "J", "j" },
			{ "K", "k" },
			{ "L", "l" },
			{ "M", "m" },
			{ "N", "n" },
			{ "O", "o" },
			{ "P", "p" },
			{ "Q", "q" } };

	private static class FlyweightMap extends AbstractMap<String, String>
	{

		private static class Entry implements Map.Entry<String, String>
		{
			int index;

			Entry(int index)
			{
				this.index = index;
			}

			@Override
			public String getKey()
			{
				return DATA[index][0];
			}

			@Override
			public String getValue()
			{
				return DATA[index][1];
			}

			@Override
			public String setValue(String value)
			{
				throw new UnsupportedOperationException();
			}

			public int hashCode()
			{
				return index;
			}

			public boolean equals(Object o)
			{
				return DATA[index][0].equals(o);
			}
		}

		// use abstractset by implementing size & iterator 通过实现尺寸& iterato使用套抽象
		static class EnterSet extends AbstractSet<Map.Entry<String, String>>
		{
			private int size;

			EnterSet(int size) // 享元部分 只存储它的索引 而不是实际的健和值
			{
				if (size < 0)
				{
					this.size = 0;
				} else if (size > DATA.length)
				{
					this.size = DATA.length;
				} else
				{
					this.size = size;
				}
			}

			@Override
			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;
				}

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

				}
			}

			@Override
			public Iterator<java.util.Map.Entry<String, String>> iterator()
			{

				return new Iter();
			}

		}

		//
		public static Set<java.util.Map.Entry<String, String>> entries = new EnterSet(
				DATA.length);

		@Override
		public Set<java.util.Map.Entry<String, String>> entrySet()
		{

			return entries;
		}

	}

	// create a partial map of size countries 创建一个部分大小国家的地图
	static Map<String, String> select(final int size)
	{
		return new FlyweightMap()
		{
			@Override
			public Set<java.util.Map.Entry<String, String>> entrySet()
			{

				return new FlyweightMap.EnterSet(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);// a partial map
	}

	static List<String> names = new ArrayList<String>(map.keySet());

	// all the names;
	public static List<String> names()
	{
		return names;
	}

	// A partial list
	public static List<String> names(int size)
	{
		return new ArrayList<String>(select(size).keySet());
	}

	/********************main******************************/
	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 TreeMap<String, String>(capitals(3)));
		System.out.println(new LinkedHashMap<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 TreeSet<String>(capitals(6).keySet()));
		System.out.println(new LinkedHashSet<String>(names(6)));
		// System.out.println(new Hashtable<String, String>(capitals(3)));

		System.out.println(new ArrayList<String>(names(6)));
		System.out.println(new LinkedList<String>(names(6)));

		System.out.println(capitals().get("F"));

	}

}
/**
output:
{A=a, B=b, C=c, D=d, E=e, F=f, G=g, H=h, I=i, J=j}
[A, B, C, D, E, F, G, H, I, J]
{A=a, B=b, C=c}
{A=a, B=b, C=c}
{A=a, B=b, C=c}
{A=a, C=c, B=b}
[D, E, F, A, B, C]
[A, B, C, D, E, F]
[A, B, C, D, E, F]
[A, B, C, D, E, F]
[A, B, C, D, E, F]
f
*/

package org.rui.collection3.map;

import java.util.AbstractList;

/***
 * 它可以具有任意尺寸，并且用Integer数据 有效的 进行了预初始化
 * @author lenovo
 *
 */
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));
	}

}
/**output:
 * [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
 *  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]

 * */

package org.rui.collection3.map;

import java.util.AbstractMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
/**
 * 这里使用的是LinkedHashSet,而不是定制的Set类，因此享元未完全实现
 * @author lenovo
 *
 */
public class CountingMapData extends AbstractMap<Integer, String>
{

	private int size;
	private static String[] chars = "A B C D E F G".split(" ");

	public CountingMapData(int size)
	{
		if (size < 0)
			this.size = 0;
		this.size = size;
	}

	private static class Entry implements Map.Entry<Integer, String>
	{

		private int index;

		Entry(int index)
		{
			this.index = index;
		}

		@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();
		}

		@Override
		public boolean equals(Object obj)
		{
			return Integer.valueOf(index).equals(obj);
		}

		@Override
		public int hashCode()
		{

			return Integer.valueOf(index).hashCode();
		}
	}

	@Override
	public Set<java.util.Map.Entry<Integer, String>> entrySet()
	{
		// linedhashset 保留初始化顺序
		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));
	}

}
/**
 * {0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 6=G0, 7=A1,
 * 8=B1, 9=C1, 10=D1, 11=E1, 12=F1, 13=G1, 14=A2, 15=B2,
 * 16=C2, 17=D2, 18=E2, 19=F2, 20=G2, 21=A3, 22=B3, 23=C3,
 *  24=D3, 25=E3, 26=F3, 27=G3, 28=A4, 29=B4, 30=C4, 31=D4,
 *  32=E4, 33=F4, 34=G4, 35=A5, 36=B5, 37=C5, 38=D5, 39=E5,
 *   40=F5, 41=G5, 42=A6, 43=B6, 44=C6, 45=D6, 46=E6, 47=F6,
 *   48=G6, 49=A7, 50=B7, 51=C7, 52=D7, 53=E7, 54=F7, 55=G7,
 *   56=A8, 57=B8, 58=C8, 59=D8}

 * */