android 集合架构二-list

上篇文章介绍了一下相关的集合接口，本片文章主要介绍一下List的子类，在这里不能每一个类都涉及到，选择一些常见和具有代表性的来看一下。

本片主要是讲list相关实现的类，从api上可以搜索一下相关子类：

   

    从上面可以看出，这个类是实现List 接口的直接子类，查看源码来了解这个类是如何设计的？ 为什么如此设计？

   查看api，可以到这个类的简介：

    abstractlist是List接口的抽象实现，是一个支持随机存取存储备份优化。此实现不支持添加或替换。子类必须实现抽象方法get()和size()

  

 private class SimpleListIterator implements Iterator<E> {
        int pos = -1;

        int expectedModCount;

        int lastPosition = -1;

        SimpleListIterator() {
        	LinkedList<String> lll;
        	ArrayList ar;
            expectedModCount = modCount;
        }

        public boolean hasNext() {
            return pos + 1 < size();
        }

        public E next() {
            if (expectedModCount == modCount) {
                try {
                    E result = get(pos + 1);
                    lastPosition = ++pos;
                    return result;
                } catch (IndexOutOfBoundsException e) {
                    throw new NoSuchElementException();
                }
            }
            throw new ConcurrentModificationException();
        }

        public void remove() {
            if (this.lastPosition == -1) {
                throw new IllegalStateException();
            }

            if (expectedModCount != modCount) {
                throw new ConcurrentModificationException();
            }

            try {
                AbstractList.this.remove(lastPosition);
            } catch (IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }

            expectedModCount = modCount;
            if (pos == lastPosition) {
                pos--;
            }
            lastPosition = -1;
        }
    }

 这个类实现了Iterator 接口

 private final class FullListIterator extends SimpleListIterator implements ListIterator<E> {
        FullListIterator(int start) {
            if (start >= 0 && start <= size()) {
                pos = start - 1;
            } else {
                throw new IndexOutOfBoundsException();
            }
        }

        public void add(E object) {
            if (expectedModCount == modCount) {
                try {
                    AbstractList.this.add(pos + 1, object);
                } catch (IndexOutOfBoundsException e) {
                    throw new NoSuchElementException();
                }
                pos++;
                lastPosition = -1;
                if (modCount != expectedModCount) {
                    expectedModCount = modCount;
                }
            } else {
                throw new ConcurrentModificationException();
            }
        }

        public boolean hasPrevious() {
            return pos >= 0;
        }

        public int nextIndex() {
            return pos + 1;
        }

        public E previous() {
            if (expectedModCount == modCount) {
                try {
                    E result = get(pos);
                    lastPosition = pos;
                    pos--;
                    return result;
                } catch (IndexOutOfBoundsException e) {
                    throw new NoSuchElementException();
                }
            }
            throw new ConcurrentModificationException();
        }

        public int previousIndex() {
            return pos;
        }

        public void set(E object) {
            if (expectedModCount == modCount) {
                try {
                    AbstractList.this.set(lastPosition, object);
                } catch (IndexOutOfBoundsException e) {
                    throw new IllegalStateException();
                }
            } else {
                throw new ConcurrentModificationException();
            }
        }
    }

实现了ListIterator 接口，上面这个类，分别是为了实现List接口里面的方法，  public Iterator<E> iterator() 和 public ListIterator<E> listIterator() 这俩个方法

public void add(int location, E object) {
        throw new UnsupportedOperationException();
    }

 因为数据存储方式不同，所以添加数据需要在子类中实现

@Override
    public boolean add(E object) {
        add(size(), object);
        return true;
    }

这个方法不用解释也能看明白吧，就不复习入门知识了。

 public boolean addAll(int location, Collection<? extends E> collection) {
        Iterator<? extends E> it = collection.iterator();
        while (it.hasNext()) {
            add(location++, it.next());
        }
        return !collection.isEmpty();
    }

使用iterator遍历方法，添加数据

 @Override
    public void clear() {
        removeRange(0, size());
    }

清理此集合，具体实现查看removeRange

 protected void removeRange(int start, int end) {
        Iterator<?> it = listIterator(start);
        for (int i = start; i < end; i++) {
            it.next();
            it.remove();
        }
    }

一看就明白，使用listIterator遍历，利用next 和 remove，上面已经实现了ListIterator 接口的类 FullListIterator

  @Override
    public boolean equals(Object object) {
        if (this == object) {
            return true;
        }
        if (object instanceof List) {
            List<?> list = (List<?>) object;
            if (list.size() != size()) {
                return false;
            }

            Iterator<?> it1 = iterator(), it2 = list.iterator();
            while (it1.hasNext()) {
                Object e1 = it1.next(), e2 = it2.next();
                if (!(e1 == null ? e2 == null : e1.equals(e2))) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

没有什么好解释的，还是利用遍历

public abstract E get(int location);

由于不同的存储方式，需要在子类中具体实现

 public int hashCode() {
        int result = 1;
        Iterator<?> it = iterator();
        while (it.hasNext()) {
            Object object = it.next();
            result = (31 * result) + (object == null ? 0 : object.hashCode());
        }
        return result;
    }

略过。。。。

剩余的方法也不一一列出来了，只是为了明白这个类是如何设计的，可以很清晰的看到： 大部分方法都是根据迭代遍历来进行操作的，也有部分方法由于存储方式的不同，所以需要在具体的子类中实现