17.2.3使用抽象类

AbstractMap

注意：有哪些操作会对集合进行了遍历，即使遍历过了，map中的数据是否已经完成了初始化？并不提供修改的操作。创建只读map的操作。

  2. public class Countries {
  3.     public static final String[][] DATA = {
  4.             // Asia 部分国家以及首都 数据源
  5.             {"CHINA", "Beijing"}, {"CYPRUS", "Nicosia"},
  6.             {"INDIA", "New Delhi"}, {"INDONESIA", "Jakarta"},
  7.             {"IRAN", "Tehran"}, {"IRAQ", "Baghdad"},
  8.             {"ISRAEL", "Jerusalem"}, {"JAPAN", "Tokyo"},
  9.             {"JORDAN", "Amman"}, {"KUWAIT", "Kuwait City"},
  10.             {"LAOS", "Vientiane"}, {"LEBANON", "Beirut"},
  11.     };
  12.      private static class FlyweightMap extends AbstractMap<String, String> {
  13.         //构建自定义Map 2，包含Entry 元组 提供对外的getKey getValue
  14.         private static class Entry implements Map.Entry<String, String> {
  15.             int index;
  17.             Entry(int index) {
  18.                 this.index = index;
  19.             }
  21.             public boolean equals(Object o) {
  22.                 return DATA[index][0].equals(o);
  23.             }
  24.             //迭代的时候 对外暴漏数据源
  25.             public String getKey() {
  26.                 return DATA[index][0];
  27.             }
  28.             //迭代的时候 对外暴漏数据源
  29.             public String getValue() {
  30.                 return DATA[index][1];
  31.             }
  33.             public String setValue(String value) {
  34.                 throw new UnsupportedOperationException();
  35.             }
  37.             public int hashCode() {
  38.                 return DATA[index][0].hashCode();
  39.             }
  40.         }
  42.         // Use AbstractSet by implementing size() & iterator()
  43.         //3,EntrySet：元组的Set集合 提供对外遍历的能力
  44.         static class EntrySet extends AbstractSet<Map.Entry<String, String>> {
  45.             private int size;
  47.             EntrySet(int size) {
  48.                 if (size < 0)
  49.                     this.size = 0;
  50.                     // Can't be any bigger than the array:
  51.                 else if (size > DATA.length)
  52.                     this.size = DATA.length;
  53.                 else
  54.                     this.size = size;
  55.             }
  57.             public int size() {
  58.                 return size;
  59.             }
  61.             //提供的遍历的能力
  62.             private class Iter implements Iterator<Map.Entry<String, String>> {
  63.                 // Only one Entry object per Iterator:
  64.                 private Entry entry = new Entry(-1);
  66.                 public boolean hasNext() {
  67.                     return entry.index < size - 1;
  68.                 }
  70.                 public Map.Entry<String, String> next() {
  71.                     entry.index++;
  72.                     return entry;
  73.                 }
  75.                 public void remove() {
  76.                     throw new UnsupportedOperationException();
  77.                 }
  78.             }
  80.             //EntrySet 对外提供迭代器
  81.             public Iterator<Map.Entry<String, String>> iterator() {
  82.                 return new Iter();
  83.             }
  84.         }
  85.         //初始化动作1-1 执行FlyweightMap中的静态域
  86.         private static Set<Map.Entry<String, String>> entries = new EntrySet(DATA.length);
  88.         public Set<Map.Entry<String, String>> entrySet() {
  89.             return entries;
  90.         }
  91.     };
  93.     static Map<String, String> select(final int size) {
  94.         return new FlyweightMap() {
  95.             //1，匿名内部类重写 entrySet()，提供了自定义的EntrySet的实现。
  96.             public Set<Map.Entry<String, String>> entrySet() {
  97.                 return new EntrySet(size);
  98.             }
  99.         };
  100.     }
  101.     //初始化动作1
  102.     static Map<String, String> map = new FlyweightMap();
  104.      //静态方法的调用 会触发静态域的初始化
  105.     public static Map<String, String> capitals() {
  106.         return map; // The entire map
  107.     }
  108.     public static Map<String, String> capitals(int size) {
  109.         return select(size); // A partial map
  110.     }
  111.      public static void main(String[] args) {
  112.         // 触发条件 调用了Countries的静态方法 ，将按照变量声明的顺序执行初始化操作
  113.         // 执行完初始化动作发现capitals中的数据已经全部为二维数组中的最后一项
  114.         Map<String, String> capitals = capitals();
  115.         System.out.println();
  116.          //在对map集合进行get的时候 调用的是抽象类中的方法 然后执行的迭代。
  117.          //具体的迭代器以及entryset属于FlyweightMap内部类提供的，
  118.         String s = capitals.get("CHINA");
  119.         System.out.println(s);
  120.          //在不输出capitals的前提下，查看capitals中的值 发现并没有进行初始化
  121.         System.out.println();
  122.      }
  123. }

AbstractList

创建只读的List，并提供数据源，对于基本类型的数据并不需要提供

Integer示例
会进行自增操作，should 由JVM实现


import java.util.*;

public class CountingIntegerList extends AbstractList<Integer> {
    private int size;

    public CountingIntegerList(int size) {
        this.size = size < 0 ? 0 : size;
    }

    public Integer get(int index) {
        return Integer.valueOf(index);
    }

    public int size() {
        return size;
    }

    public static void main(String[] args) {
        CountingIntegerList integerList = new CountingIntegerList(6);
        Integer integer = integerList.get(5);
        System.out.println();
        //并不支持修改
        integerList.set(0,99);
        System.out.println(integerList);
    }
}

Character示例
会进行自增操作，should 由JVM实现

public class CharacterArrayList extends AbstractList<Character> {
    int size;

    int index;

    public CharacterArrayList(int size) {
        this.size = size < 0 ? 0 : size;
    }

    public Character get(int index) {
        return Character.valueOf((char)(index+97));
    }

    public int size() {
        return this.size;
    }

    public static void main(String[] args) {
        CharacterArrayList stringList = new CharacterArrayList(3);
        System.out.println();
    }
}

String示例
会进行自增操作，should 由JVM实现

ublic class StringArrayList extends AbstractList<String> {
    //固定的数据源
    String[] array = {"one", "two", "three", "four", "five"};
    int size;

    int index;

    public StringArrayList(int size) {
        this.size = size < 0 ? 0 : size;
    }

    public String get(int index) {
        return array[index];
    }

    public int size() {
        return this.size;
    }

    public static void main(String[] args) {
        StringArrayList stringList = new StringArrayList(3);
        System.out.println();
    }
}