java之Collection

August 27, 2022

概述

此篇为 Collection，关于 Map，见此

The core collection interfaces

摘自https://www.jishuchi.com/read/onjava8/12011
黄色为接口，绿色为抽象类，蓝色为具体类。虚线箭头表示实现关系，实线箭头表示继承关系。

java.util.*

Interface	Hash Table	Resizable Array	Balanced Tree	Linked List	Hash Table + Linked List
Set	HashSet		TreeSet		LinkedHashSet
List		ArrayList		LinkedList
Deque		ArrayDeque		LinkedList
Map	HashMap		TreeMap		LinkedHashMap

https://docs.oracle.com/javase/tutorial/collections/index.html

Iterator

https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html

java

public interface Iterator<E> {
    boolean hasNext();
    E next();
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

若实现 Iterable 接口并实现 Iterator 方法，则还可以使用 for in 遍历
（注意，of 方法返回的集合是不可修改的）

java

List<Integer> list = List.of(21, 13, 32);

for (int i = 0; i < list.size(); i++)
    System.out.print(list.get(i) + ",");


Iterator it = list.iterator();
while (it.hasNext())
    System.out.print(it.next() + ",");

for (Integer i : list)
    System.out.print(i + ",");

Collection

https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html

java

public interface Collection<E> extends Iterable<E> {
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    Iterator<E> iterator();
    Object[] toArray();
    <T> T[] toArray(T[] a);
    default <T> T[] toArray(IntFunction<T[]> generator);
    boolean add(E e);
    boolean remove(Object o);
    boolean containsAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c);
    boolean removeAll(Collection<?> c);
    default boolean removeIf(Predicate<? super E> filter);
    boolean retainAll(Collection<?> c);
    void clear();
    default Spliterator<E> spliterator();
    default Stream<E> stream();
    default Stream<E> parallelStream();
    // 省略继承 Object 方法
}

Set

https://docs.oracle.com/javase/8/docs/api/java/util/Set.html

java

public interface Set<E> extends Collection<E> {
    // 省略继承 Collection<E> 方法
    // ! 以下 API 自 java 9
    static <E> Set<E> of();
    static <E> Set<E> of(E e1, E e2, ...省略, E e10);
    static <E> Set<E> of(E... elements);
    // ! 以下 API 自 java 10
    static <E> Set<E> copyOf(Collection<? extends E> coll);
}

List

https://docs.oracle.com/javase/8/docs/api/java/util/List.html

java

public interface List<E> extends Collection<E> {
    // 省略继承 Collection<E> 方法
    boolean addAll(int index, Collection<? extends E> c);
    default void replaceAll(UnaryOperator<E> operator);
    default void sort(Comparator<? super E> c);
    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);
    // ! 以下 API 自 java 9
    static <E> List<E> of();
    static <E> List<E> of(E e1, E e2,...省略, E e10);
    static <E> List<E> of(E... elements);
    // ! 以下 API 自 java 10
    static <E> List<E> copyOf(Collection<? extends E> coll);
}

Queue

https://docs.oracle.com/javase/8/docs/api/java/util/Queue.html

队列方法总结

	抛出异常	仅返回特定值
Insert	add(e)	offer(e)
Remove	remove()	poll()
Examine	element()	peek()

java

public interface Queue<E> extends Collection<E> {
    boolean add(E e);
    boolean offer(E e);V
    E remove();
    E poll();
    E element()
    E peek();
}

Deque

https://docs.oracle.com/javase/8/docs/api/java/util/Deque.html

队列方法总结

         首元素                   尾元素

	抛出异常	返回特定值	抛出异常	返回特定值
Insert	addFirst(e)	offerFirst(e)	addLast(e)	offerLast(e)
Remove	removeFirst()	pollFirst()	removeLast()	pollLast()
Examine	getFirst()	peekFirst()	getLast()	peekLast()

队列方法与双端队列方法的比较

队列方法	等效双端队列方法
add(e)	addLast(e)
offer(e)	offerLast(e)
remove()	removeFirst()
poll()	pollFirst()
element()	getFirst()
peek()	peekFirst()

栈方法与双端队列的比较

	栈方法	等效双端队列方法
入栈	push(e)	addFirst(e)
出栈并返回	pop()	removeFirst()
查看栈顶	peek()	peekFirst()

java

public interface Deque<E> extends Queue<E> {
    void addFirst(E e);
    void addLast(E e);
    boolean offerFirst(E e);
    boolean offerLast(E e);
    E removeFirst();
    E removeLast();
    E pollFirst();
    E pollLast();
    E getFirst();
    E getLast();
    E peekFirst();
    E peekLast();
    boolean removeFirstOccurrence(Object o);
    boolean removeLastOccurrence(Object o);
    boolean add(E e);
    boolean offer(E e);
    E remove();
    E poll();
    E element();
    E peek();
    boolean addAll(Collection<? extends E> c);
    void push(E e);
    E pop();
    boolean remove(Object o);
    boolean contains(Object o);
    int size();
    Iterator<E> iterator();
    Iterator<E> descendingIterator();
}

Priority Queue

java

public class PriorityQueue<E> extends AbstractQueue<E> implements java.io.Serializable {
    int size;
    public PriorityQueue();
    public PriorityQueue(int initialCapacity);
    public PriorityQueue(Comparator<? super E> comparator);
    public PriorityQueue(int initialCapacity, Comparator<? super E> comparator);
    public PriorityQueue(Collection<? extends E> c);
    public PriorityQueue(PriorityQueue<? extends E> c);
    public PriorityQueue(SortedSet<? extends E> c);
    public boolean add(E e)
    public boolean offer(E e)
    public E peek()
    public boolean remove(Object o)
    public boolean contains(Object o);
    public Object[] toArray()
    public <T> T[] toArray(T[] a)
    public Iterator<E> iterator();
    public boolean removeIf(Predicate<? super E> filter);
    public boolean removeAll(Collection<?> c);
    public boolean retainAll(Collection<?> c);
    public void forEach(Consumer<? super E> action);
}

←Back to home