初来乍到 Java 和 .Net 迭代器功能

最近有一个需求是这样的，

根据键值对存储类型数据，也算是数据缓存块模块功能设计。

一个键对应多个值。每一个键的值类型相同，但是每个不同的键之间类型不一定相同。

Java 设计如下

HashMap<String, ArrayList<Object>>

java把数据添加到集合中

TestIterator tIterator = new TestIterator();    ArrayList<Object> objs = new ArrayList<>();    objs.add("sdfsfdsfdsf");    objs.add("sdfsfdsfdsf");    objs.add("sdfsfdsfdsf");    objs.add("sdfsfdsfdsf");    tIterator.getList().put("Key1", objs);    objs = new ArrayList<>();    objs.add(1);    objs.add(2);    objs.add(3);    objs.add(4);    tIterator.getList().put("Key2", objs);    objs = new ArrayList<>();    objs.add(new String[]{"1", ""});    objs.add(new String[]{"2", ""});    objs.add(new String[]{"3", ""});    objs.add(new String[]{"4", ""});    tIterator.getList().put("Key3", objs);

添加进数据缓存后，然后读取数据，我们先忽略，缓存集合的线程安全性问题，

{      ArrayList<Object> getObjs = tIterator.getList().get("Key1");      for (Object getObj : getObjs) {        System.out.println("My is String：" + (String) getObj);      }    }    {      ArrayList<Object> getObjs = tIterator.getList().get("Key2");      for (Object getObj : getObjs) {        System.out.println("My is int：" + (int) getObj);      }    }    {      ArrayList<Object> getObjs = tIterator.getList().get("Key3");      for (Object getObj : getObjs) {        String[] strs = (String[]) getObj;        System.out.println("My is String[]：" + strs[0] + " : " + strs[1]);      }    }

我们发现。使用的时候，每个地方都需要转换。

(String[]) getObj;(int) getObj(String) getObj

同样代码需要重复写，那么我们是否可以封装一次呢？

public <T> ArrayList<T> getValue(String keyString, Class<T> t) {    ArrayList<T> rets = new ArrayList<>();    ArrayList<Object> getObjs = _List.get(keyString);    if (getObjs != null) {      for (Object getObj : getObjs) {        //if (getObj instanceof T) {        rets.add((T) getObj);        //}      }    }    return rets;  }

这里我发现一个问题，不支持泛型检查，据我很浅的知识了解到，java算是动态类型数据。

并且是伪泛型类型所以不支持泛型类型判定

这点很不爽了，为啥不能泛型类型判定。也许是我知识浅薄~！望前辈指点；

再次查看调用

{      ArrayList<String> value = tIterator.getValue("Key1", String.class);      for (String value1 : value) {      }    }    {      ArrayList<Integer> value = tIterator.getValue("Key1", Integer.class);      for (Integer value1 : value) {      }    }    {      ArrayList<String[]> value = tIterator.getValue("Key1", String[].class);      for (String[] value1 : value) {      }    }

稍稍觉得清爽了一点吧。当然，我这里都是用到基础类型，如果用到复杂类型，和满篇调用的时候才能体现出这段代码的优越性。

更加的符合面向对象编程的重构行和复用性；

可是上面代码，不晓得大家注意没，出现一个问题，那就是每一次调用都再一次的声明了

ArrayList<T> rets = new ArrayList<>();

对象，如果是需要考虑性能问题的时候，我们肯定不能不能这样。每次调用都需要重新分配ArrayList的内存空间。并且在 ArrayList.add() 的时候每一次都在检查ArrayList的空间够不够，不够，再次开辟新空间。重组。

虽然这个动作很快，可是如果我们缓存的数据过多。那么情况可就不一样了。且伴随着每一次的调用都是一个消耗。访问次数过多的话。那么程序的的性能势必会变的低下。

再次考虑，是否可以用迭代器实现功能呢？

查看了一下迭代器实现方式，我无法完成我需求的迭代器功能。只能依葫芦画瓢，实现了一个自定义的迭代器功能。

class TestIterator {  HashMap<String, ArrayList<Object>> _List = new HashMap<>();  public TestIterator() {  }  public <T> ArrayList<T> getValue(String keyString, Class<T> t) {    ArrayList<T> rets = new ArrayList<>();    ArrayList<Object> getObjs = _List.get(keyString);    if (getObjs != null) {      for (Object getObj : getObjs) {        //if (getObj instanceof T) {        rets.add((T) getObj);        //}      }    }    return rets;  }  public HashMap<String, ArrayList<Object>> getList() {    return _List;  }  public void setList(HashMap<String, ArrayList<Object>> _List) {    this._List = _List;  }  public <T> TestIterator.ArrayIterator<T> iterator(String keyString, Class<T> t) {    return new ArrayIterator<T>(keyString);  }  public class ArrayIterator<T> {    private String key;    int index = -1;    private T content;    public ArrayIterator(String key) {      this.key = key;    }    public void reset() {      index = -1;    }    public T getContent() {      //忽略是否存在键的问题      Object get = TestIterator.this._List.get(key).get(index);      return (T) get;    }    public boolean next() {      //忽略是否存在键的问题      if (index >= TestIterator.this._List.get(key).size()) {        reset();        return false;      }      index++;      return true;    }  }}

调用方式

    {      TestIterator.ArrayIterator<String> iterator1 = tIterator.iterator("Key1", String.class);      while (iterator1.next()) {        String content = iterator1.getContent();      }    }    {      TestIterator.ArrayIterator<Integer> iterator1 = tIterator.iterator("Key2", Integer.class);      while (iterator1.next()) {        Integer content = iterator1.getContent();      }    }    {      TestIterator.ArrayIterator<String[]> iterator = tIterator.iterator("Key3", String[].class);      while (iterator.next()) {        String[] content = iterator.getContent();      }    }

总结了一些问题，

Java的泛型是伪泛型，底层其实都是通过object对象，装箱拆箱完成的。

 /**   * Shared empty array instance used for empty instances.   */  private static final Object[] EMPTY_ELEMENTDATA = {};  /**   * Shared empty array instance used for default sized empty instances. We   * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when   * first element is added.   */  private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};  /**   * The array buffer into which the elements of the ArrayList are stored.   * The capacity of the ArrayList is the length of this array buffer. Any   * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA   * will be expanded to DEFAULT_CAPACITY when the first element is added.   */  transient Object[] elementData; // non-private to simplify nested class access

这个从我目前代码设计思路我能理解。如果让我自己设计。也行也会设计如此。

但是无法理解为什么使用泛型无法类型判定；

我这个自定义的迭代器无法使用 for each 功能;

说了这么多。接下来我们看看.net；

C# 设计如下

Dictionary<String, List<Object>>

TestIterator tIterator = new TestIterator();      List<Object> objs = new List<Object>();      objs.Add("sdfsfdsfdsf");      objs.Add("sdfsfdsfdsf");      objs.Add("sdfsfdsfdsf");      objs.Add("sdfsfdsfdsf");      tIterator["Key1"] = objs;      objs = new List<Object>();      objs.Add(1);      objs.Add(2);      objs.Add(3);      objs.Add(4);      tIterator["Key2"] = objs;      objs = new List<Object>();      objs.Add(new String[] { "1", "" });      objs.Add(new String[] { "2", "" });      objs.Add(new String[] { "3", "" });      objs.Add(new String[] { "4", "" });      tIterator["Key3"] = objs;

由于有了以上 Java 部分的代码和思路，那么我们直接创建自定义迭代器就可以了；

 public class TestIterator : Dictionary<String, List<Object>>  {    public IEnumerable<T> CreateEnumerator<T>(String name)    {      if (this.ContainsKey(name))      {        List<Object> items = this[name];        foreach (var item in items)        {          if (item is T)          {            Console.WriteLine(item);            yield return (T)item;          }        }      }    }  }

查看调用方式

foreach (var item in tIterator.CreateEnumerator<String>("tt1"))      {        Console.WriteLine(item + "艹艹艹艹");      }

输出结果：

yield return : sdfsfdsfdsfforeach : sdfsfdsfdsfyield return : sdfsfdsfdsfforeach : sdfsfdsfdsfyield return : sdfsfdsfdsfforeach : sdfsfdsfdsfyield return : sdfsfdsfdsfforeach : sdfsfdsfdsf

查看对比一下调用方式

foreach (var item in tIterator.CreateEnumerator<String>("Key1"))      {        Console.WriteLine("foreach : " + item);      }      Console.WriteLine("===============分割线==============");      IEnumerable<String> getObjs = tIterator.CreateEnumerator<String>("Key1").ToList();            foreach (var item in getObjs)      {        Console.WriteLine("foreach : " + item);      }

主要上面的两张调用方式。输出结果完全不同

yield return : sdfsfdsfdsfforeach : sdfsfdsfdsfyield return : sdfsfdsfdsfforeach : sdfsfdsfdsfyield return : sdfsfdsfdsfforeach : sdfsfdsfdsfyield return : sdfsfdsfdsfforeach : sdfsfdsfdsf===============分割线==============yield return : sdfsfdsfdsfyield return : sdfsfdsfdsfyield return : sdfsfdsfdsfyield return : sdfsfdsfdsfforeach : sdfsfdsfdsfforeach : sdfsfdsfdsfforeach : sdfsfdsfdsfforeach : sdfsfdsfdsf

可以看出第二种调用方式是全部返回了数据，那么就和之前java的设计如出一辙了.

 public <T> ArrayList<T> getValue(String keyString, Class<T> t) {    ArrayList<T> rets = new ArrayList<>();    ArrayList<Object> getObjs = _List.get(keyString);    if (getObjs != null) {      for (Object getObj : getObjs) {        //if (getObj instanceof T) {        rets.add((T) getObj);        //}      }    }    return rets;  }

虽然表面看上去没有声明List对象，可实际底层依然做好了底层对象的分配对性能也是有所消耗；

C# 迭代器实现了泛型类型判定检测；

且没有多余的开销，

总结。

Java的自定义迭代。多出了一下定义

 private String key;    int index = -1;    private T content;

不支持泛型的类型判别；

C# 的自定义迭代器 没什么多余的代码开销，但其实底层依然做了我们类使用Java的自定义代码段。只是我们无需再定义而已。

C# 支持 泛型类型的判别。

其实这些都是语法糖的问题。没有什么高明或者不高明之处。但是在面对快速开发和高性能程序的基础上，优势劣势。自己判别了。

以上代码不足之处，还请各位看客之处。

不喜勿碰~！~！~！

原标题：初来乍到 Java 和 .Net 迭代器功能

关键词：.NET