我們發(fā)現(xiàn)。使用的時候，每個地方都需要轉(zhuǎn)換。

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

同樣代碼需要重復(fù)寫，那么我們是否可以封裝一次呢？

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

這里我發(fā)現(xiàn)一個問題，不支持泛型檢查，據(jù)我很淺的知識了解到，java算是動態(tài)類型數(shù)據(jù)。

并且是偽泛型類型所以不支持泛型類型判定

這點很不爽了，為啥不能泛型類型判定。也許是我知識淺薄~！望前輩指點；

再次查看調(diào)用

{            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) {            }        }

稍稍覺得清爽了一點吧。當(dāng)然，我這里都是用到基礎(chǔ)類型，如果用到復(fù)雜類型，和滿篇調(diào)用的時候才能體現(xiàn)出這段代碼的優(yōu)越性。

更加的符合面向?qū)ο缶幊痰闹貥?gòu)行和復(fù)用性；

可是上面代碼，不曉得大家注意沒，出現(xiàn)一個問題，那就是每一次調(diào)用都再一次的聲明了

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

對象，如果是需要考慮性能問題的時候，我們肯定不能不能這樣。每次調(diào)用都需要重新分配ArrayList的內(nèi)存空間。并且在 ArrayList.add() 的時候每一次都在檢查ArrayList的空間夠不夠，不夠，再次開辟新空間。重組。

雖然這個動作很快，可是如果我們緩存的數(shù)據(jù)過多。那么情況可就不一樣了。且伴隨著每一次的調(diào)用都是一個消耗。訪問次數(shù)過多的話。那么程序的的性能勢必會變的低下。

再次考慮，是否可以用迭代器實現(xiàn)功能呢？

查看了一下迭代器實現(xiàn)方式，我無法完成我需求的迭代器功能。只能依葫蘆畫瓢，實現(xiàn)了一個自定義的迭代器功能。

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

調(diào)用方式

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

總結(jié)了一些問題，

Java的泛型是偽泛型，底層其實都是通過object對象，裝箱拆箱完成的。