Java 集合框架

#集合框架
常用接口和它们的实现类的结构图如下：

（空心箭头为继承，实心箭头为实现；尖角矩形框为接口，圆角矩形框为类）

集合框架采用了设计模式中的接口适配器模式，用抽象类继承接口，不同类型的子类可以继承抽象类而非实现接口，不需要实现所有的功能，可以只实现自己需要的功能

• Iterator接口
  集合框架介绍之前不得不提的一个接口，它与集合框架密切相关，常用来遍历集合元素
  代码如下：

    package java.util;
  
    import java.util.function.Consumer;
  
    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接口
  Iterable接口存在于 java.lang包中是Java集合的顶级接口之一，
  代码如下：

   	package java.lang;
   	
   	import java.util.Iterator;
   	import java.util.Objects;
   	import java.util.Spliterator;
   	import java.util.Spliterators;
   	import java.util.function.Consumer;
   
   	public interface Iterable<T> {
   		//返回调用集合的一个迭代器
   		Iterator<T> iterator(); 
   	
   		//对集合中每个未处理元素执行action指定的动作
   	    default void forEach(Consumer<? super T> action) {
   	        Objects.requireNonNull(action);
   	        for (T t : this) {
   	            action.accept(t);
   	        }
   	    }
   	    
   		//返回调用集合的Spliterator（JDK8新增）
   	    default Spliterator<T> spliterator() {
   	        return Spliterators.spliteratorUnknownSize(iterator(), 0);
   	    }
   	}
  

• Collection接口
  Collection接口是构建集合框架的基础，定义集合的所有类都必须实现该接口，代码如下：

   	package java.util;
   	import java.util.function.Predicate;
   	import java.util.stream.Stream;
   	import java.util.stream.StreamSupport;
   	
   	public interface Collection<E> extends Iterable<E> {
   
   		int size();
         
   		boolean isEmpty();
   	      
   		boolean contains(Object o);
   
   		Iterator<E> iterator();
   
   	    Object[] toArray();
   	    
   		//返回调用集合中元素的类型为a数组中元素类型的子类型的集合
   	    <T> T[] toArray(T[] a);
   
   		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) {
   	        Objects.requireNonNull(filter);
   	        boolean removed = false;
   	        final Iterator<E> each = iterator();
   	        while (each.hasNext()) {
   	            if (filter.test(each.next())) {
   	                each.remove();
   	                removed = true;
   	            }
   	        }
   	        return removed;
   	    }
   	    
   		//从调用集合中移除除c中元素之外的所有元素
   	    boolean retainAll(Collection<?> c);
   
   	    void clear();
   
   	    boolean equals(Object o);
   
   	    int hashCode();
   
   	    default Spliterator<E> spliterator() {
   	        return Spliterators.spliterator(this, 0);
   	    }
   
   		//返回一个调用集合作为元素来源的流
   	    default Stream<E> stream() {
   	        return StreamSupport.stream(spliterator(), false);
   	    }
   		
   		//返回一个调用集合作为元素来源的并行流
   	    default Stream<E> parallelStream() {
   	        return StreamSupport.stream(spliterator(), true);
   	    }
   	}
  

---

• Queue接口
  Queue接口拓展了Collection接口，并且声明了队列的行为，先进先出的列表，代码如下：

   package java.util;
   
   public interface Queue<E> extends Collection<E> {
  
       boolean add(E e);
  
       boolean offer(E e);
  
   	//移除头部元素，若队列为空，抛出NoSuchElementException异常
       E remove();
  
   	//返回头部元素，操作过程移除元素，若队列为空，返回null
       E poll();
   	
   	//返回头部元素，操作过程不移除元素，若队列为空，抛出NoSuchElementException异常
       E element();
  
   	//返回头部元素，若队列为空，返回null，不移除元素
       E peek();
   }
  

• Deque接口

   package java.util;
  
   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();
  
   	//返回头元素，若队列为空，返回null
       E element();
  
       E peek();
  
       void push(E e);
  
       E pop();
  
       boolean remove(Object o);
  
       boolean contains(Object o);
  
       public int size();
  
       Iterator<E> iterator();
  
       //返回一个从双端队列尾部向头部移动的迭代器
       Iterator<E> descendingIterator();
   
   }
  

---

• List接口
  List接口拓展了Collection，并且声明了用来存储一连串有序元素的集合行为
  代码如下：

   package java.util;
  
   import java.util.function.UnaryOperator;
  
   public interface List<E> extends Collection<E> {
      
       int size();
  
       boolean isEmpty();
  
       boolean contains(Object o);
  
       Iterator<E> iterator();
  
       Object[] toArray();
  
       <T> T[] toArray(T[] a);
       
       boolean add(E e);
  
       boolean remove(Object o);
       
       boolean containsAll(Collection<?> c);
  
       boolean addAll(Collection<? extends E> c);
  
       boolean addAll(int index, Collection<? extends E> c);
  
       boolean removeAll(Collection<?> c);
  
       boolean retainAll(Collection<?> c);
  
   	//使用operator函数获得的值更新列表中的每个元素
       default void replaceAll(UnaryOperator<E> operator) {
           Objects.requireNonNull(operator);
           final ListIterator<E> li = this.listIterator();
           while (li.hasNext()) {
               li.set(operator.apply(li.next()));
           }
       }
  
   	//使用c指定的比较器对列表排序
       default void sort(Comparator<? super E> c) {
           Object[] a = this.toArray();
           Arrays.sort(a, (Comparator) c);
           ListIterator<E> i = this.listIterator();
           for (Object e : a) {
               i.next();
               i.set((E) e);
           }
       }
  
       void clear();
  
       boolean equals(Object o);
  
       int hashCode();
  
       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();
  
       //返回调用列表的一个迭代器，该迭代器从列表中由index指定的索引位置开始
       ListIterator<E> listIterator(int index);
  
       List<E> subList(int fromIndex, int toIndex);
  
       default Spliterator<E> spliterator() {
           return Spliterators.spliterator(this, Spliterator.ORDERED);
       }
   }
  

---

• Set接口
  Set接口定义了组，它拓展了Collection接口，并且声明了集合中不允许有重复元素的组行为
  代码如下：

   package java.util;
  
   public interface Set<E> extends Collection<E> {
   
       int size();
  
       boolean isEmpty();
  
       boolean contains(Object o);
  
       Iterator<E> iterator();
  
       Object[] toArray();
   
       <T> T[] toArray(T[] a);
   
       boolean add(E e);
  
       boolean remove(Object o);
   
       boolean containsAll(Collection<?> c);
  
       boolean addAll(Collection<? extends E> c);
  
       boolean retainAll(Collection<?> c);
  
       boolean removeAll(Collection<?> c);
  
       void clear();
   
       boolean equals(Object o);
  
       int hashCode();
   
       default Spliterator<E> spliterator() {
           return Spliterators.spliterator(this, Spliterator.DISTINCT);
       }
   }
  

• SortedSet接口
  SortedSet接口拓展了Set接口，并且声明了以升序进行排序的组行为
  代码如下：

   package java.util;
   
   public interface SortedSet<E> extends Set<E> {
   
       //返回已排序调用组的比较器。如果组使用自然排序，返回null
       Comparator<? super E> comparator();
  
   	//返回的SortedSet对象包含索引位置在fromElement与toElement-1之间的元素
       SortedSet<E> subSet(E fromElement, E toElement);
  
   	//返回的SortedSet对象包含已排序调用组中那些小于toElement的元素
       SortedSet<E> headSet(E toElement);
  
   	//返回的SortedSet对象包含已排序调用组中那些大于fromElement的元素
       SortedSet<E> tailSet(E fromElement);
  
       E first();
  
       E last();
  
       default Spliterator<E> spliterator() {
           return new Spliterators.IteratorSpliterator<E>(
                   this, Spliterator.DISTINCT | 
                   Spliterator.SORTED | 
                   Spliterator.ORDERED) {
               @Override
               public Comparator<? super E> getComparator() {
                   return SortedSet.this.comparator();
               }
           };
       }
   }
  

• NavigableSet接口
  NavigableSet接口拓展了SortedSet接口，并且声明了支持基于最接近匹配原则检索元素的集合行为
  代码如下：

   package java.util;
  
   public interface NavigableSet<E> extends SortedSet<E> {
   
       //查找小于e的最大元素
       E lower(E e);
   
       //查找小于等于e的最大元素
       E floor(E e);
  
       //查找大于等于e的最小元素
       E ceiling(E e);
   
       //查找大于e的最大元素
       E higher(E e);
  
       E pollFirst();
  
       E pollLast();
  
       Iterator<E> iterator();
   
       NavigableSet<E> descendingSet();
  
   	Iterator<E> descendingIterator();
   
       NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
                              E toElement,   boolean toInclusive);
   
       NavigableSet<E> headSet(E toElement, boolean inclusive);
  
       NavigableSet<E> tailSet(E fromElement, boolean inclusive);
  
       SortedSet<E> subSet(E fromElement, E toElement);
  
       SortedSet<E> headSet(E toElement);
  
       SortedSet<E> tailSet(E fromElement);
   }
  

---