java集合基础学习一

学习总结自《java核心技术卷Ⅰ》

一.Java集合框架

java最初的版本只为最常用的数据结构提供了很少的一组类：Vector(向量),Stack(栈),Hashtable(哈希表)，BitSet(位集合)和Enumeration（枚举）接口。
其中的Enumeration接口提供了一种用于访问任意容器中各个元素的抽象机制，这句话的意思实际上说的就是我们可以实现这个接口来访问任意容器的元素：

public interface Enumeration<E> {
   
    boolean hasMoreElements();
    E nextElement();
}

1.java集合的接口和实现是分离的

我们通过自己创造队列是如何被定义的来了解如何分离的：

首先我们要定义一个队列接口：
1）队列接口应指出可以在队列的尾部添加元素，在队列的头部删除元素，并且可以查询队列中元素的个数。
其最简单形式类似下面：

public interface Queue<E>
{
 void add(E element);//尾部添加元素
 E remove();//头部删除元素
 int size();//查询元素个数
}

然后我们要实现它：
2）上面的接口并没有说明队列是如何实现的，所以我们要实现它来实现队列，队列通常有两种实现方式：循环数组实现，链表实现
下面分别大体实现下：
a.循环数组实现

public class CircularArrayQueue<E> implements Queue<E>
{
  private int head;//定义队列头元素
  private int tail;//队列尾元素
  CircularArrayQueue(int capacity){......}//队列构造函数
  public void add(E element){......}//添加元素
  public E remove(){......}//删除元素
  public int size(){......}//返回队列大小
  private E[] elements;//存储元素的数组
}

b.链表实现

public class LinkedListQueue<E> implements Queue<E>
{
  private Link head;
  private Link tail;
  LinkedListQueue(){...}
  public void add(E element){...}
  public E remove(){...}
  public int size(){...}
}

最后我们就可以在应用中用它了。
上面是我们自己写的，但实际上，java库的开发者已经把上面的工作全做了，而且很系统的开发了很多数据结构供我们使用。

2.下面我们就来看看java集合框架中有哪些接口，作用分别是什么？

1.Iterable接口： 很明显他是一个迭代器接口，实现它的类都是可迭代遍历的。

public interface Iterable<T> {
    
    Iterator<T> iterator();//定义迭代器方法
    
    //default是在java8中引入的关键字，在接口内部包含了一些默认的方法实现，
    //从而使得接口在进行扩展的时候，不会破坏与接口相关的实现类代码。
    /*
    * 对Iterable的每个元素执行给定的操作，知道所有元素都被处理或动作引发异常
    */
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
    /*
    *在Iterable描述的元素上创建一个Iterable
    */
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

2.Collection接口： 它继承了迭代器接口。它是集合接口，它里面定义了一些方法，这些方法都是操作集合的常用方法。
这个接口有两个基本方法：

public interface Collection<E>
{
 boolean add(E element);//添加元素方法
 Iterator<E> iterator();//迭代器
}

具体的API：

boolean	add(E e)
确保此集合包含指定的元素（可选操作）。

boolean	addAll(Collection<? extends E> c)
将指定集合中的所有元素添加到此集合（可选操作）。

void	clear()
从此集合中删除所有元素（可选操作）。

boolean	contains(Object o)
如果此集合包含指定的元素，则返回 true 。

boolean	containsAll(Collection<?> c)
如果此集合包含指定 集合中的所有元素，则返回true。

boolean	equals(Object o)
将指定的对象与此集合进行比较以获得相等性。

int	hashCode()
返回此集合的哈希码值。

boolean	isEmpty()
如果此集合不包含元素，则返回 true 。

Iterator<E>	iterator()
返回此集合中的元素的迭代器。

default Stream<E>	parallelStream()
返回可能并行的 Stream与此集合作为其来源。

boolean	remove(Object o)
从该集合中删除指定元素的单个实例（如果存在）（可选操作）。

boolean	removeAll(Collection<?> c)
删除指定集合中包含的所有此集合的元素（可选操作）。

default boolean	removeIf(Predicate<? super E> filter)
删除满足给定谓词的此集合的所有元素。

boolean	retainAll(Collection<?> c)
仅保留此集合中包含在指定集合中的元素（可选操作）。

int	size()
返回此集合中的元素数。

default Spliterator<E>	spliterator()
创建一个Spliterator在这个集合中的元素。

default Stream<E>	stream()
返回以此集合作为源的顺序 Stream 。

Object[]	toArray()
返回一个包含此集合中所有元素的数组。

<T> T[]	toArray(T[] a)
返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。

3.后面的List，Set ，Queue接口则是定义具体的数据结构的接口。

4.Map接口： 它用来定义键值对的数据结构的接口。它定义的接口方法如下：

void	clear()
从该地图中删除所有的映射（可选操作）。

default V	compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
尝试计算指定键的映射及其当前映射的值（如果没有当前映射， null ）。

default V	computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
如果指定的键尚未与值相关联（或映射到 null ），则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非 null 。

default V	computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
如果指定的密钥的值存在且非空，则尝试计算给定密钥及其当前映射值的新映射。

boolean	containsKey(Object key)
如果此映射包含指定键的映射，则返回 true 。

boolean	containsValue(Object value)
如果此地图将一个或多个键映射到指定的值，则返回 true 。

Set<Map.Entry<K,V>>	entrySet()
返回此地图中包含的映射的Set视图。

boolean	equals(Object o)
将指定的对象与此映射进行比较以获得相等性。

default void	forEach(BiConsumer<? super K,? super V> action)
对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。

V	get(Object key)
返回到指定键所映射的值，或 null如果此映射包含该键的映射。

default V	getOrDefault(Object key, V defaultValue)
返回到指定键所映射的值，或 defaultValue如果此映射包含该键的映射。

int	hashCode()
返回此地图的哈希码值。

boolean	isEmpty()
如果此地图不包含键值映射，则返回 true 。

Set<K>	keySet()
返回此地图中包含的键的Set视图。

default V	merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
如果指定的键尚未与值相关联或与null相关联，则将其与给定的非空值相关联。

V	put(K key, V value)
将指定的值与该映射中的指定键相关联（可选操作）。

void	putAll(Map<? extends K,? extends V> m)
将指定地图的所有映射复制到此映射（可选操作）。

default V	putIfAbsent(K key, V value)
如果指定的键尚未与某个值相关联（或映射到 null ）将其与给定值相关联并返回 null ，否则返回当前值。

V	remove(Object key)
如果存在（从可选的操作），从该地图中删除一个键的映射。

default boolean	remove(Object key, Object value)
仅当指定的密钥当前映射到指定的值时删除该条目。

default V	replace(K key, V value)
只有当目标映射到某个值时，才能替换指定键的条目。

default boolean	replace(K key, V oldValue, V newValue)
仅当当前映射到指定的值时，才能替换指定键的条目。

default void	replaceAll(BiFunction<? super K,? super V,? extends V> function)
将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。

int	size()
返回此地图中键值映射的数量。

Collection<V>	values()
返回此地图中包含的值的Collection视图。

5.Iterator接口： 迭代器接口，用于遍历集合元素

default void	forEachRemaining(Consumer<? super E> action)
对每个剩余元素执行给定的操作，直到所有元素都被处理或动作引发异常。

boolean	hasNext()
如果迭代具有更多元素，则返回 true 。

E	next()
返回迭代中的下一个元素。

default void	remove()
从底层集合中删除此迭代器返回的最后一个元素（可选操作）。

6.RandomAccess接口：
此接口的主要目的是允许通用算法更改其行为，以便在应用于随机访问列表或顺序访问列表时提供良好的性能。List实现使用的标记界面，表明它们支持快速（通常为恒定时间）随机访问。

其他所有下面的所有接口都是Collection，Map，Iterator，Iterable的进一步的具体应用。