データ構造 - リストのインタフェース

簡単な紹介

Collectionインタフェースから継承されたListインタフェースは、3つのインタフェースの一つは、コレクションを拡張しています。リストの要素は、注文、およびインデックスの訪問でサポートされています。要素のリストは、同時に、重複ことができます。

public interface List<E> extends Collection<E>

方法

Collectionインタフェースメソッドのほとんどのリストは、ここにユニークな方法を話すことが重要であり、もちろん、あなた自身のユニークな方法を定義し、再び再定義している、他の方法は、インタフェースCollectionを参照してください。

// 替换所有 UnaryOperator会另开一篇讲解
default void replaceAll(UnaryOperator<E> operator) {
    Objects.requireNonNull(operator);
    final ListIterator<E> li = this.listIterator();
    while (li.hasNext()) {
        li.set(operator.apply(li.next()));
    }
}
// 排序
@SuppressWarnings({"unchecked", "rawtypes"})
default void sort(Comparator<? super E> c) {
    Object[] a = this.toArray();
    // 主要使用 Arrays.sort 进行排序
    Arrays.sort(a, (Comparator) c);
    // 迭代原集合
    ListIterator<E> i = this.listIterator();
    // 遍历新数组
    for (Object e : a) {
        i.next();
        // 使原集合中元素位置跟新数组中一致，这里直接替换
        i.set((E) e);
    }
}
// 根据索引查找
E get(int index);
// 根据索引设置元素
E set(int index, E element);
// 根据索引位置添加
void add(int index, E element);
// 根据索引位置删除
E remove(int index);
// 获取元素在集合中的第一个索引
int indexOf(Object o);
// 获取元素在集合中最后一个索引
int lastIndexOf(Object o);
// 获取一个列表迭代器
ListIterator<E> listIterator();
// 从某个位置开始构建迭代器
ListIterator<E> listIterator(int index);
// 截取某一段构建集合
List<E> subList(int fromIndex, int toIndex);

Collectionインタフェース用に関しては、Listインタフェースだけでなく、一般的なイテレータを提供するために、インデックス操作の多くを追加し、イテレータと反復子のリスト反復子、より便利な双方向動作を提供します

AbstractList抽象クラス

Listインタフェースを実装AbstractList、私たちはクラスの名前から見ることができ、クラスアクションの基本的な実現のいくつかのリストを提供する抽象クラスです。

public abstract class AbstractList<E> 
        extends AbstractCollection<E> implements List<E>

コンストラクタ

protected AbstractList() {
}

プロパティ

// 修改次数
protected transient int modCount = 0;

メソッドは実装されていません

abstract public E get(int index);

メソッドが実装されました

ほんの数AbstractList方法は（例えば、ハッシュコードに等しい）サブクラスによってオーバーライドされていない、ほとんどの方法は、サブクラスによってオーバーライドされます

加えます

public boolean add(E e) {
    add(size(), e);
    return true;
}
​
public void add(int index, E element) {
    throw new UnsupportedOperationException();
}
​
public boolean addAll(int index, Collection<? extends E> c) {
    // 是否越界校验
    rangeCheckForAdd(index);
    boolean modified = false;
    for (E e : c) {
        add(index++, e);
        modified = true;
    }
    return modified;
}
​
private void rangeCheckForAdd(int index) {
    if (index < 0 || index > size())
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

サブクラスはこのメソッドをオーバーライドする必要があり、（E e）の呼び出しは（int型のインデックス、Eの要素）を追加し、直接呼び出し注意が例外をスローします追加

設定値

public E set(int index, E element) {
    throw new UnsupportedOperationException();
}

また、例外をスローすることの直接の呼び出しに注意して、サブクラスはこのメソッドをオーバーライドする必要があります

[削除]

public E remove(int index) {
    throw new UnsupportedOperationException();
}
​
protected void removeRange(int fromIndex, int toIndex) {
    // 按起始位置构建列表迭代器
    ListIterator<E> it = listIterator(fromIndex);
    // 遍历范围内的所有元素
    for (int i=0, n=toIndex-fromIndex; i<n; i++) {
        // 迭代删除
        it.next();
        it.remove();
    }
}

直接呼び出し削除（int index）指定さサブクラスはこのメソッドをオーバーライドする必要があり、例外がスローされます

求めます

// 获取元素索引
public int indexOf(Object o) {
    // 获取此集合列表迭代器
    ListIterator<E> it = listIterator();
    if (o==null) {
        // 参数为空时找元素为空的索引
        while (it.hasNext())
            // 找到第一个就返回
            if (it.next()==null)
                return it.previousIndex();
    } else {
        // 参数不为空，找元素和参数equals一样的索引
        while (it.hasNext())
            // 找到第一个就返回
            if (o.equals(it.next()))
                return it.previousIndex();
    }
    // 没有找到返回-1
    return -1;
}
​
// 按索引查找
public int lastIndexOf(Object o) {
    // 获取此集合列表迭代器
    ListIterator<E> it = listIterator(size());
    if (o==null) {
        // 参数为空时找元素为空的索引，这里是从最后一个找起
        while (it.hasPrevious())
            // 找到第一个就返回（倒找找第一个，实际上就是最后一个）
            if (it.previous()==null)
                return it.nextIndex();
    } else {
        // 参数不为空，找元素和参数equals一样的索引（倒着找）
        while (it.hasPrevious())
            // 找到第一个就返回（倒找找第一个，实际上就是最后一个）
            if (o.equals(it.previous()))
                return it.nextIndex();
    }
    // 没有找到返回-1
    return -1;
}

明確な

public void clear() {
    // 从第一个元素开始删除
    removeRange(0, size());
}

hashCodeメソッド

public int hashCode() {
    // 初始化为1，如果元素为空，hashCode就为1
    int hashCode = 1;
    for (E e : this)
        // 上一次 hashCode 乘以31，加上当前元素的 hashCode
        hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
    // 返回 hashCode
    return hashCode;
}

equalsメソッドを

public boolean equals(Object o) {
    // 参数与当前集合内存地址一样，返回true
    if (o == this)
        return true;
    // 参数不是List或List子类的实例，返回false
    if (!(o instanceof List))
        return false;
    // 获取两个迭代器
    ListIterator<E> e1 = listIterator();
    ListIterator<?> e2 = ((List<?>) o).listIterator();
    // 同时迭代两个集合，同时有值才可以迭代
    while (e1.hasNext() && e2.hasNext()) {
        // 分别获取元素
        E o1 = e1.next();
        Object o2 = e2.next();
        // 判断两个元素是否一致，都为空或equals一致
        if (!(o1==null ? o2==null : o1.equals(o2)))
            return false;
    }
    // 能到这至少有一个迭代完，有一个没迭代完就返回false
    return !(e1.hasNext() || e2.hasNext());
}

イテレータ

// 获取迭代器
public Iterator<E> iterator() {
    return new Itr();
}
// 获取列表迭代器
public ListIterator<E> listIterator() {
    return listIterator(0);
}
// 从某一位置构建迭代器
public ListIterator<E> listIterator(final int index) {
    rangeCheckForAdd(index);
​
    return new ListItr(index);
}

内部クラスItrは

private class Itr implements Iterator<E> {
​
    int cursor = 0;
    int lastRet = -1;
    int expectedModCount = modCount;
    
    public boolean hasNext() {...}
    public E next() {...}
    public void remove() {...}
    final void checkForComodification() {...}
}

この内部クラスはイテレータ基本的な機能を達成することです

内部クラスListItr

private class ListItr extends Itr implements ListIterator<E> {
    ListItr(int index) {...}
    public boolean hasPrevious() {...}
    public E previous() {...}
    public int nextIndex() {...}
    public int previousIndex() {...}
    public void set(E e) {...}
    public void add(E e) {...}
}

この内部クラスはのITR継承し、反復子を達成するため、古典的なAdapterパターン、およびのITR延長、それは双方向の反復機能を持っています

外部内SubList

class SubList<E> extends AbstractList<E>

サブリストAbstractListクラス抽象クラスを継承するので、AbstractListが達成された種々の方法の例のリストを使用してもよいです。

外部クラスRandomAccessSubList

class RandomAccessSubList<E> 
        extends SubList<E> implements RandomAccess

RandomAccessSubListクラスのサブリストから継承し、実装ランダム・インタフェースは、RandomAccessインタフェースは、単にそのような支持体のランダムアクセスの一例を示しています。