泛型之思考

之前偶然的灵光一现，认识到了泛型是可以增强代码的可读性的，但是泛型的目的应该并不仅仅如此吧，那么就泛型的出现，还给了我们什么样的便利呢？

看到书上的总结，说的是泛型提供了编译期检查，避免了强制转型，当然也提到了增强了代码的可读性。

对书中的这些东西，目前仅仅理解了增强代码的可读性，当我们在进行业务功能的开发时，合理的使用泛型，便于后期项目的维护，但是避免了强制转型？这真的是泛型的作用吗？其实还是进行了强制转型的，只是并没显示出来，而是内部进行了处理，还有编译期检测，正常情况下，我们在编写代码的时候，会准确的知道自己使用的是什么类型，所以对编译期检查，目前也感觉毫无用处，那么泛型当初的设计，其设计之初的理念究竟是什么呢？

下面是使用泛型对arraylist的简单实现，希望可以体会泛型的设计思想，但是领悟到的也仅仅就是之前说的不需要自己强制转型，编译期检查，以及代码可读性，哪位小伙伴有其他的想法呢？分享一下呗

package arraylist;

import java.util.Collection;
import java.util.Iterator;

public class MyArrayList4<T> implements Collection<T> {

    private Object[] arr={};

    private int size;

    class MyArrayList4Iterator<T> implements Iterator<T> {

        int current = -1;

        int size = size();

        @Override
        public boolean hasNext() {
            current++;
            return current < size ? true : false;
        }

        @Override
        public T next() {
            return (T)arr[current];
        }
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean contains(Object o) {
        return getIndex(o) == -1 ? false : true;
    }

    private int getIndex(Object obj) {
        for (int i = 0; i < size; i++) {
            if (arr[i].equals(obj)) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public Iterator<T> iterator() {
        return new MyArrayList4Iterator<>();
    }

    @Override
    public Object[] toArray() {
        return arr;
    }

    @Override
    public <T1> T1[] toArray(T1[] a) {
        return a;
    }

    @Override
    public boolean add(T t) {
        resize();
        arr[size - 1] = t;
        return true;
    }


    private void resize() {
        size++;
        if (size > arr.length) {
            Object[] temp;
            temp = new Object[arr.length == 0 ? 10 : arr.length * 2];
            for (int i = 0; i < arr.length; i++) {
                temp[i] = arr[i];
            }
            arr = temp;
        }
    }

    @Override
    public boolean remove(Object o) {
        int i = getIndex(o);
        if (i == -1) {
            return false;
        } else {
            for (int j = i; j < size - 1; j++) {
                arr[j] = arr[j + 1];
            }
            return true;
        }
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        Iterator iterator = c.iterator();
        while (iterator.hasNext()) {
            if (!contains(iterator.hasNext())) {
                return false;
            }
        }
        return true;
    }

    @Override
    public boolean addAll(Collection<? extends T> c) {
        Iterator<? extends T> iterator = c.iterator();
        while (iterator.hasNext()){
            add(iterator.next());
        }
        return true;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {

    }
}