集合

2. 集合 -core java 7 第2卷

2.1 集合接口

Java类库中的 接口Collection是一种基本的接口. 如下:

public interface Collection<E> {
    boolean add(E element); //添加元素. 添加成功返回true
    Iterator<E> iterator(); //返回迭代器. 该方法来自接口Iterable.
    ... //其它方法
}

其中方法iterator()返回的是迭代器类型. 注意Java中的迭代器和c++容器中的迭代器不同. 它的迭代器
没有"当前元素"这样的概念. 而是"指向元素之间".所以当有3个元素的时候可以有4个迭代器位置.

Iterator接口如下:

public interface Iterator<E> {
    E next();  //返回下一个元素.并后移迭代器. 没有元素时抛出 NoSuchElementException异常
    boolean hasNext();  //是否有下一个元素.
    void remove();  //移除元素. 注意: 这里移除的是上次做next()调用时返回的元素.
                    //例如要remove第一个元素.则要先要iter.next()再iter.remove().
}

使用迭代器遍历容器的例子:
Collection<String> c = ....;
Iterator<String> iter = c.iterator();
while (iter.hasNext())
{
    String s = iter.next();
    //...
}
不过从Java1.5开始. 为遍历容器提供了一种"for each"缩写形式:
for (String s : c)  //要求c是实现了Iterable接口(即有iterator()方法)的对象
{
    //...
}

Collection接口还声明了下边的方法:
    boolean add(E o) //添加失败时返回false
    boolean addAll(Collection<? extends E> c)
    void clear()  //移除所有元素
    boolean contains(Object o) //包含指定的元素o则返回 true
    boolean containsAll(Collection<?> c) 
    boolean equals(Object o) //比较此 collection 与指定对象是否相等
    int hashCode() //返回此 collection 的哈希码值
    boolean isEmpty() //如果此 collection 不包含元素则返回 true
    Iterator<E> iterator() //返回迭代器
    boolean remove(Object o) //移除指定元素的单个实例, 移除失败则返回false
    boolean removeAll(Collection<?> c)
    boolean retainAll(Collection<?> c) //只保留它与c的交集.
    int size() //返回个数.
    Object[] toArray() //返回包含此 collection 中所有元素的数组
    <T> T[] toArray(T[] a) //返回的数组的运行时类型与指定数组的运行时类型相同

这个接口的方法比较多. 所以提供了一个抽象类 AbstractCollection. 具体的集合类可以从该类继承.

2.2 具体的集合

2.2.1 链表

List接口
public interface List<E> extends Collection<E>
实现该接口的类包括 LindedList, ArrayList, Stack, Vector
它从Collection接口增加的方法有:
    void add(int index, E element) //指定位置插入element
    boolean addAll(int index, Collection<? extends E> c)  //指定位置上插入c所有元素
    E get(int index) //返回指定位置的元素
    int indexOf(Object o) //返回首次出现指定元素的索引,找不到则返回 -1
    int lastIndexOf(Object o) //返回最后出现指定元素的索引找不到则返回 -1
    ListIterator<E> listIterator()  //返回ListIterator
    ListIterator<E> listIterator(int index) //返回起始位置为index的ListIterator
    E remove(int index) //移除指定位置的元素（可选操作）。
    boolean remove(Object o) //移除元素o的首次出现
    boolean removeAll(Collection<?> c) //移除c中包含的所有元素
    boolean retainAll(Collection<?> c) //仅保留c中所包含的元素
    E set(int index, E element) //用element替换指定位置的元素
    List<E> subList(int fromIndex, int toIndex) //返回子序列

注意listIterator()方法返回的是ListIterator类型的迭代器.
ListIterator是接口. 如下:
public interface ListIterator<E> extends Iterator<E>
它扩展了Iterator接口. 增加了下边几个方法:
    boolean hasPrevious()  //是否有前一个元素.
    E previous()  //返回前一个元素.
    int nextIndex()  //返回下一次next()返回的元素的索引.
    int previousIndex()  //返回下一次previousIndex()返回的元素的索引.
    void remove()   //移除上次调用next()或previousIndex()返回的元素.
    void set(E o)  //用o替换上次调用next()或previousIndex()返回的元素
注意其中的remove()和set()方法, 它们删除或替换的元素根据迭代器上次是前进还是后退而不同.

LinkedList类
public class LinkedList<E> extends AbstractSequentialList<E>
         implements List<E>, Queue<E>, Cloneable, Serializable
它除了实现接口List中的方法外还提供了:
    void addFirst(E o) //插入o到表头
    void addLast(E o) //插入o到表尾
    E getFirst() //返回表尾
    E getLast()  //返回表头
    此外还有Queue(队列)接口声明的几个方法:
    E element()  //返回队列的头
    boolean offer(E o) //插入队列尾部
    E peek()  //返回队列的头, 若队列为空则返回null
    E poll() //返回并移除队列的头,若队列为空则返回null
    E remove()  //返回并移除队列的头

2.2.2 数组列表 ArrayList类

该类也实现了List接口, 它封装了一个大小可变的对象数组. 所以可以高效的随机访问.
让它扩展RandomAccess接口(该接口没有方法而只是用来标识)来表明它可以快速随机访问.
用ArrayList代替Vector的原因是.Vector的所有方法都是同步的(效率低一些). 而ArrayList不是.

class ArrayList<E> extends AbstractList<E>
     implements List<E>, RandomAccess, Cloneable, Serializable

它的方法除了List接口声明的那些方法外还有:
void ensureCapacity(int minCapacity)   //指定容量的最小值.(容量也可以在构造方法中指定.)
void trimToSize()   //将容量调整为当前size()的大小.

2.2.3 Set

Set是没有重复元素的一种集合.
常见的. set有两种实现. 一种是哈希表实现的(元素是无序的). 一种是2叉树实现的(要求元素可比较大小).
它们在Java.util库中对应 HashSet 和 TreeSet 两个类. 两个类都实现了接口Set.

Set 接口
interface Set<E> extends Collection<E>
该接口并没有从Collection中添加新的方法.
虽然没有添加新方法. 但它们是不同的接口. 例如有方法
void fun(Set<int> s)
这就清楚的说明参数要一个Set对象而不是其它的Collection对象.

HashSet类
在需要快速搜索的时候需要使用散列表. 散列表为每个对象计算一个整数(散列码).
计算散列码的方法是hashCode(). 如果a.equals(b)为true, 则a和b的散列码要相同.

class HashSet<E>extends AbstractSet<E>
     implements Set<E>, Cloneable, Serializable
构造方法:
    HashSet() //空集合，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。
              // 加载因子决定当其中的元素越来越多时.何时对散列表进行再散列.
    HashSet(Collection<? extends E> c) //构造的集合包含c的元素.
    HashSet(int initialCapacity) //指定初始容量. 加载因子为默认的（0.75）。
    HashSet(int initialCapacity, float loadFactor) //指定初始容量和加载因子.
其它方法:
    Set接口中声明的那些方法.

2.2.4 TreeSet类

TreeSet是用红黑树实现的Set.
class TreeSet<E> extends AbstractSet<E>
     implements SortedSet<E>, Cloneable, Serializable

它的构造方法:
    TreeSet() //构造一个set, 其元素按元素的自然顺序排序(即要求元素的类实现了Comparable接口).
    TreeSet(Collection<? extends E> c) //构造的set包含 c 中的元素
                          //元素的排序用的也是自然顺序(即要求元素的类实现了Comparable接口).
    TreeSet(Comparator<? super E> c) // 构造TreeSet时指定了排序时用的比较器.
                                     // 比较器实现了Comparator接口.该接口声明了方法
                                     //   int compare(T a, T b).
    TreeSet(SortedSet<E> s) //让新set包含的元素与指定的已排序 set 包含的元素相同
                        //并按照相同的顺序对元素进行排序
其它方法:
    包括Set接口中声明的: add() / addAll() / clear() / contains() / isEmpty() /
                       iterator() / remove() / size() 
    以及SortedSet接口(它扩展Set接口)所添加的下列方法:
    Comparator<? super E> comparator()  //返回排序用的比较器.
                                        //若没指定比较器则返回null(即按自然顺序排序).
    E first()  //返回SortedSet中第一个(即最小的)元素
    E last()   //返回SortedSet中最后一个(即最大的)元素
    SortedSet<E> headSet(E toElement) //返回子集. 此子集Set的元素都小于参数toElement.
    SortedSet<E> tailSet(E fromElement)//返回子集. 此子集Set的元素都大于等于fromElement
    SortedSet<E> subSet(E fromElement, E toElement) //返回子集.
                 //此子集Set的元素大于等于fromElement, 小于toElement.

2.2.5 优先级队列 PriorityQueue

优先级队列是用最小堆实现的集合. 用来方便的找到其中最小的元素.
因为要比较元素之间的大小.所以其中的元素的类需要实现Comparable接口.或者构造集合时指定一个比较器.
class PriorityQueue<E> extends AbstractQueue<E> implements Serializable

构造方法:
    PriorityQueue() //用默认的初始容量(11)构造,
                    //比较大小时用自然顺序(要求元素的类实现Comparable接口)
    PriorityQueue(Collection<? extends E> c) //创建的新的优先级队列中包含c的元素.
    PriorityQueue(PriorityQueue<? extends E> c) //同上
    PriorityQueue(SortedSet<? extends E> c)  //同上
    PriorityQueue(int initialCapacity) //指定初始的容量
    PriorityQueue(int initialCapacity, Comparator<? super E> comparator)
                             //指定了初始容量和比较器
其它方法:
    boolean add(E o) 
    void clear()
    int size()
    Iterator<E> iterator()
    boolean remove(Object o) //移除指定元素的单个实例(若其存在)
    Comparator<? super E> comparator() //返回比较器.若没有指定比较器则返回null.
    boolean offer(E o) //插入o
    E peek() //查看(但不会移除)队列的头,如果此队列为空则返回 null
    E poll() //查看并移除此队列的头,如果此队列为空则返回 null
 

2.2.6 映射表 Map

映射表 Map 用来表示键值对的集合. 通常有两种实现: HashMap 类和 TreeMap 类. 它们扩展自Map接口.
而Map接口却没有扩展自Collection接口. 因为Collection接口不适合操作键值对.

先看看Map接口:
interface Map<K,V>
其中有一个嵌套接口:
    static interface Map.Entry<K,V>
    这个接口描述的是键值对.方法有getKey() / getValue() / setValue()

Map接口的方法如下:
    void clear() 
    boolean isEmpty()
    int size()
    int hashCode()
    boolean equals(Object o)
    V get(Object key) //返回此映射中映射到指定键的值。
    V put(K key, V value) //插入一个键值对(key, value)
    V remove(Object key) //移除key键对应的键值对
    void putAll(Map<? extends K,? extends V> t) //插入t中包含的所有键值对
    boolean containsKey(Object key) //是否包含键key
    boolean containsValue(Object value) //是否包含值value(一个value值可以对应多个键)
    Set<K> keySet() //返回此映射中包含的键的 set 视图。
    Collection<V> values() //返回map中值的 collection 视图。
    Set<Map.Entry<K,V>> entrySet() //返回map中包含的键值对的 set 视图。

HashMap 类
它用一个散列表来实现. 根据键的hash()值来确定元素的位置.
class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

构造方法:
    HashMap() //默认初始容量(即桶)(16) 和默认加载因子(0.75)
    HashMap(int initialCapacity) //指定初始容量
    HashMap(int initialCapacity, float loadFactor) //指定初始容量和加载因子
    HashMap(Map<? extends K,? extends V> m) //构造一个映射关系与指定 Map 相同的 HashMap
其它方法:
    实现Map接口所声明的方法.

TreeMap类
它用红黑树来实现. 它的插入等操作要求键之间可以比较大小. 所以键要实现 Comparable 接口. 或者
被指定的比较器所接受(如 comparator.compare(k1, k2) ).
class TreeMap<K,V> extends AbstractMap<K,V>
       implements SortedMap<K,V>, Cloneable, Serializable

其中 SortedMap接口 为:
    interface SortedMap<K,V> extends Map<K,V>
它比Map接口添加了下边几个方法:
    Comparator<? super K> comparator() //返回比较器,若无则返回 null。
    K firstKey() //返回当前第一个(最小的)键
    K lastKey()  //返回当前最后一个(最大的)键
    SortedMap<K,V> headMap(K toKey) //返回部分视图,其键值小于 toKey
    SortedMap<K,V> tailMap(K fromKey) //返回部分视图,其键大于等于 fromKey
    SortedMap<K,V> subMap(K fromKey, K toKey) //返回部分视图,
                     //其键值大于等于fromKey 小于toKey

所以 TreeMap类 的方法就是 Map接口 和 SortedMap接口 声明的那些方法.
此外TreeMap的构造方法有:
    TreeMap() 
    TreeMap(Comparator<? super K> c) //指定比较器
    TreeMap(Map<? extends K,? extends V> m) //新TreeMap中包含m的所有元素(即键值对)
                                            //排序则是按自然顺序进行排序
    TreeMap(SortedMap<K,? extends V> m) //新TreeMap中包含m的所有元素(即键值对)
                                        //排序和m的排序方式一样
 

2.3.3 集合和数组的转换

要将一个数组转换为集合. 使用java.util.Arrays类的静态方法:
    static <T> List<T> asList(T... a)
    //它返回的是数组a的List视图. 所以返回的list的长度是不可以改变的(改变则抛异常).
    //有时想创建固定长度的 List 对象. 则可以用该方法简便的来实现:
    //  List<String> l = Arrays.asList("abc" , "de", "f");
    // 另外. Arrays类还提供了其它静态方法.用来支持数组的排序 / 填充 / 2叉搜索 / 比较相等 .

要将集合转换为一个Java数组. 使用 Collection接口 中声明的方法:
    <T> T[] toArray(T[] a)
    //其中返回的数组类型和参数a的类型一样. 
    //若参数a的数组大小能够容纳该Collection的所有元素.
    //则将集合的所有元素放入a. 若a还有剩余空间. 则再多放一个null. 再返回a.
    //否则若参数a的大小小于集合的元素数. 将会分配一个新的数组并放入元素后返回.

2.4 算法

对于数组. Arrays类中提供了一些静态方法来支持 排序 / 填充 / 2叉搜索 等.
对于集合. Collections类也提供了一些静态方法来支持各种算法.

static <T> boolean addAll(Collection<? super T> c, T... a) //将a的元素添加c中
static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
          //2分搜索. 要求list已排序. 而且list的元素要实现Coparable接口.
          //若list不是"随机访问"的. 则本算法如何?
static <T> int binarySearch(List<? extends T> list,T key,Comparator<? super T> c)
          //2分搜索. 要求list已排序. 比较时将使用参数中指定的比较器c来比较元素.
static <T> void copy(List<? super T> dest, List<? extends T> src)
          //复制. 将src的所有元素复制到dest. 要求dest有足够的长度容纳这些元素.
static boolean disjoint(Collection<?> c1, Collection<?> c2)
          //是否c1和c2没有相同的元素
static <T> List<T> emptyList() //返回空的列表（不可变的）。
static <K,V> Map<K,V>  emptyMap() //返回空的映射（不可变的）。
static <T> Set<T>  emptySet() //返回空的 set（不可变的）。
static <T> Enumeration<T> enumeration(Collection<T> c) //返回参数c 上的枚举。
static <T> void fill(List<? super T> list, T obj) //用obj填充(替换)list上的所有元素.
static int frequency(Collection<?> c, Object o) //统计c中有多少个o?
static int indexOfSubList(List<?> source, List<?> target)
          //返回子序列target在序列source中的第一次出现的位置.若无则返回-1
static int lastIndexOfSubList(List<?> source, List<?> target)
          //返回子序列target在序列source中的最后一次出现的位置.若无则返回-1
static <T> ArrayList<T> list(Enumeration<T> e)
          //将一个Enumeration转换为一个ArrayList.
static <T extends Object & Comparable<? super T>> T
       max(Collection<? extends T> coll) //返回集合coll中的最大元素. 
static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
          // 返回集合coll中的最大元素. 比较时使用参数提供的比较器comp
static <T extends Object & Comparable<? super T>> T
       min(Collection<? extends T> coll)   //返回集合coll中的最小元素.
static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)
          // 返回集合coll中的最小元素. 比较时使用参数提供的比较器comp
static <T> List<T> nCopies(int n, T o) //返回一个不可修改的List. 元素由n个o组成.
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
          //用newVal替换list中的oldVal
static void reverse(List<?> list) //反转
static <T> Comparator<T> reverseOrder()
          //返回一个相反的比较器. 使用它比较时的结果和用compareTo()方法比较的结果相反.
          //例如若有 String[] a = ... 要对a进行反序排序. 可以:
          // Arrays.sort(a, Collections.reverseOrder());
static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
          //返回一个比较器，用它比较时的结果和用参数cmp比较的结果相反.
static void rotate(List<?> list, int distance)
          //list的所有元素循环移动distance个位置(最后的将移动到开头).
static void shuffle(List<?> list) //对list洗牌.
                   //若list不是随机访问的则会先复制到一个数组中来洗牌.
static void shuffle(List<?> list, Random rnd) //洗牌. rnd为指定的随机源.
static <T> Set<T> singleton(T o) //返回的set对象不可改变. 且只包含唯一的元素o.
static <T> List<T> singletonList(T o) //返回的list对象不可改变.且只包含唯一的元素o.
static <K,V> Map<K,V> singletonMap(K key, V value)
            //返回的Map对象不可改变. 且只包含唯一的一组映射(key, value).
static <T extends Comparable<? super T>> void sort(List<T> list) //升序排序
static <T> void sort(List<T> list, Comparator<? super T> c)
          //排序. 指定了比较器.
static void swap(List<?> list, int i, int j) //交换list中位置i和位置j上的元素.
static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c)
          //返回 c 的不可修改视图
static <T> List<T> unmodifiableList(List<? extends T> list)
          //返回 list 的不可修改视图
static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m)
          //返回 m 的不可修改视图
static <T> Set<T> unmodifiableSet(Set<? extends T> s)
          //返回 s 的不可修改视图
static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m)
          // 返回 m 的不可修改视图
static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s)
          //返回 s 的不可修改视图

2.5 遗留下来的集合

Hashtable类. 作用和HashMap一样. 接口也一样. 但它的方法是同步的.
Enumeration 接口. 它的作用和现在用的Iterator接口类似.
Vector类. 和ArrayList类的区别是它的方法是同步的.
Stack类. 继承自Vector类.
BitSet类. 用来方便的位操作.