关于集合类的总结

 

 

1、集合的概念

为什么出现集合类？为了对对象进行存储。

当你事先要知道要存放数据的个数，或者你需要一种比数组下标存取机制更灵活的方法时，你就需要用到集合类。 

集合类型主要有3种：set(集）、list(列表）和map(映射),set和list是继承自connection接口的,存放亍java.util包中。 

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements,Map提供key到value的映射 

Collection 

├List 

│├LinkedList(重点） 

│├ArrayList (重点）

│└Vector 

│ └Stack 

└Set 

│ ├HashSet(重点） 

│ ├TreeSet (重点）

│

Map 

├Hashtable (重点）

├HashMap (重点）

└WeakHashMap 

 

2、Collection接口

既然Collection接口是集合中的顶层接口，那么它中定义的所有功能子类都可以使 用。查阅API中描述的Collection接口。Collection 层次结构 中的根接口。Collection 表 示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素， 而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。

3、List接口

List接口有多个子类，这里我们介绍几个最常用的集合，其他的集合不是很常用，大家如果有用到可以查阅相关API，集合用法差别不是特别大。首先我们来学习List下的常用集合ArrayList、Vector、LinkedList集合。

ArrayList：是数组结构，长度是可变的（原理是创建新数组+复制数组），查询速度很快，增删较慢，不同步的。

Vector：可以增长的数组结构。同步的。效率非常低。已被ArrayList替代。

LinkedList：是链表结构，不同步的，增删速度很快，查询速度较慢。

4、Set接口

Set:不包含重复元素的集合，不保证顺序。而且方法和Collection一致。Set集合取出元素的方式只有一种：迭代器。

Set集合有多个子类，这里我们介绍其中的HashSet、TreeSet和LinkedHashSet这三个集合。

HashSet:哈希表结构，不同步，保证元素唯一性的方式依赖于：hashCode(),equals()方法。查询速度快。

5、迭代器

a) 通常遍历List和Set都是使用迭代器iterator进行遍历 

b) 代码实现

 

public class IteratorDeamo { public static void main(String[] args)  { getByIterator(); } public static void getByIterator() { //定义一个集合 ArrayList al=new ArrayList(); //添加对象 al.add("java1"); al.add("java2"); al.add("java3"); //使用迭代器 Iterator it=al.iterator(); while(it.hasNext()) { System.out.println(it.next()); }  }}

 

6、哈希表

  哈希映射结构由一个存储元素的内部数组组成。 由于内部采用数组存储，因此必然存在一个用于确定任意键访问数组的索引机制。 实际上，该机制需要提供一个小于数组大小的整数索引值。 该机制称作哈希函数。在 Java 基于哈希的 Map 中，哈希函数将对象转换为一个适合内部数组的整数。每个对象都包含一 个返回整数值的 hashCode() 方法。要将该值映射到数组，只需将其转换为一个 正值，然后在将该值除以数组大小后取余数即可。 

 

附录：各个类操作（供查用）

a) ArrayList类

boolean add(E e) 

//将指定的元素添加到此列表的尾部。 

void add(int index, E element) 

//将指定的元素插入此列表中的指定位置。 

boolean addAll(Collection<? extends E> c)

//按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素//添加到此列表的尾部。 

boolean addAll(int index, Collection<? extends E> c) 

//从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。 

void clear() //移除此列表中的所有元素。 

boolean contains(Object o) 

//如果此列表中包含指定的元素，则返回 true。  

E get(int index) 

//返回此列表中指定位置上的元素。 

int indexOf(Object o) 

//返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。 

boolean isEmpty() 

//如果此列表中没有元素，则返回 true 

int lastIndexOf(Object o) 

//返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。 

E remove(int index) 

//移除此列表中指定位置上的元素。 

boolean remove(Object o) 

//移除此列表中首次出现的指定元素（如果存在）。 

protected  void removeRange(int fromIndex, int toIndex) 

//移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。 

E set(int index, E element) 

//用指定的元素替代此列表中指定位置上的元素。 

int size() 

//返回此列表中的元素数。 

Object[] toArray() 

//按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。 

<T> T[] toArray(T[] a) 

//按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返//回数组的运行时类型是指定数组的运行时类型。 

b) LinkedList类

boolean add(E e) 

//将指定元素添加到此列表的结尾。 

void add(int index, E element) 

//在此列表中指定的位置插入指定的元素。 

boolean addAll(Collection<? extends E> c) 

//添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭 //代器返回这些元素的顺序。 

boolean addAll(int index, Collection<? extends E> c) 

//将指定 collection 中的所有元素从指定位置开始插入此列表。 

 void addFirst(E e) 

 //将指定元素插入此列表的开头。 

 void addLast(E e) 

 //将指定元素添加到此列表的结尾。 

 void clear() 

 //从此列表中移除所有元素。 

 Object clone() 

 //返回此 LinkedList 的浅表副本。 

 boolean contains(Object o) 

 //如果此列表包含指定元素，则返回 true。 

 Iterator<E> descendingIterator() 

 //返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。 

 E element() 

 //获取但不移除此列表的头（第一个元素）。 

 E get(int index) 

 //返回此列表中指定位置处的元素。 

 E getFirst() 

 //返回此列表的第一个元素。 

 E getLast() 

 //返回此列表的最后一个元素。 

 int indexOf(Object o) 

 //返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返  //回 -1。 

 int lastIndexOf(Object o) 

 //返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返   //回 -1。 

 ListIterator<E> listIterator(int index) 

 //返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。 

 boolean offer(E e) 

 //将指定元素添加到此列表的末尾（最后一个元素）。 

 boolean offerFirst(E e) 

 //在此列表的开头插入指定的元素。 

 boolean offerLast(E e) 

 //在此列表末尾插入指定的元素。 

 E peek() 

//获取但不移除此列表的头（第一个元素）。 

 E peekFirst() 

 //获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。 

 E peekLast() 

        //获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。 

 E poll() 

//获取并移除此列表的头（第一个元素） 

 E pollFirst() 

//获取并移除此列表的第一个元素；如果此列表为空，则返回 null。 

 E pollLast() 

 //获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。 

 E pop() 

 //从此列表所表示的堆栈处弹出一个元素。 

 void push(E e) 

 // 将元素推入此列表所表示的堆栈。 

 E remove() 

 //获取并移除此列表的头（第一个元素）。 

 E remove(int index) 

 //移除此列表中指定位置处的元素。 

 boolean remove(Object o) 

 //从此列表中移除首次出现的指定元素（如果存在）。 

 E removeFirst() 

 //移除并返回此列表的第一个元素。 

 boolean removeFirstOccurrence(Object o) 

 //从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。 

 E removeLast() 

 //移除并返回此列表的最后一个元素。 

 boolean removeLastOccurrence(Object o) 

 //从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。 

 E set(int index, E element) 

 //将此列表中指定位置的元素替换为指定的元素。 

 int size() 

 //返回此列表的元素数。 

 Object[] toArray() 

 //返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数  //组。 

<T> T[]  toArray(T[] a) 

 //返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数                               //组；返回数组的运行时类型为指定数组的类型。 

 

c) HashSet类

 boolean add(E e) 

 //如果此 set 中尚未包含指定元素，则添加指定元素。 

 void clear() 

 //从此 set 中移除所有元素。  

 boolean contains(Object o) 

 //如果此 set 包含指定元素，则返回 true。 

 boolean isEmpty() 

 //如果此 set 不包含任何元素，则返回 true。 

 Iterator<E> iterator() 

 //返回对此 set 中元素进行迭代的迭代器。 

 boolean remove(Object o) 

 //如果指定元素存在于此 set 中，则将其移除。 

 int size() 

 //返回此 set 中的元素的数量（set 的容量）。 

 

d) TreeSet类

boolean add(E e) 

//将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。 

boolean addAll(Collection<? extends E> c) 

//将指定 collection 中的所有元素添加到此 set 中。 

E ceiling(E e) 

//返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回  //null。 

void clear() 

//移除此 set 中的所有元素。 

 Object clone() 

 //返回 TreeSet 实例的浅表副本。 

 Comparator<? super E> comparator() 

 //返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，   //则返回 null。 

 boolean contains(Object o) 

 //如果此 set 包含指定的元素，则返回 true。 

 Iterator<E> descendingIterator() 

 //返回在此 set 元素上按降序进行迭代的迭代器。 

 NavigableSet<E> descendingSet() 

 //返回此 set 中所包含元素的逆序视图。 

 E first() 

 //返回此 set 中当前第一个（最低）元素。 

 E floor(E e) 

 //返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回   //null。 

 E higher(E e) 

//返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回  //null。 

 boolean isEmpty() 

 //如果此 set 不包含任何元素，则返回 true。 

 Iterator<E> iterator() 

 //返回在此 set 中的元素上按升序进行迭代的迭代器。 

 E last() 

         //返回此 set 中当前最后一个（最高）元素。 

 E lower(E e) 

 //返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回        //null。 

 E pollFirst() 

 //获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。 

 E pollLast() 

 //获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。 

 boolean remove(Object o) 

 //将指定的元素从 set 中移除（如果该元素存在于此 set 中）。 

 int size() 

 //返回 set 中的元素数（set 的容量）。 

 

e) HashMap

 void clear() 

 //从此映射中移除所有映射关系。 

 boolean containsKey(Object key) 

 //如果此映射包含对于指定键的映射关系，则返回 true。 

 boolean containsValue(Object value) 

 //如果此映射将一个或多个键映射到指定值，则返回 true。 

 Set<Map.Entry<K,V>> entrySet() 

 //返回此映射所包含的映射关系的 Set 视图。 

 V get(Object key) 

 //返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则       //返回 null。 

 boolean isEmpty() 

 //如果此映射不包含键-值映射关系，则返回 true。 

 Set<K> keySet() 

 //返回此映射中所包含的键的 Set 视图。 

 V put(K key, V value) 

 //在此映射中关联指定值与指定键。 

 void putAll(Map<? extends K,? extends V> m) 

 //将指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前   //针对指定映射中所有键的所有映射关系。 

 V remove(Object key) 

 //从此映射中移除指定键的映射关系（如果存在）。 

 int size() 

 //返回此映射中的键-值映射关系数。 

 Collection<V> values() 

 //返回此映射所包含的值的 Collection 视图。 

f) TreeMap

 Map.Entry<K,V> ceilingEntry(K key) 

 //返回一个键-值映射关系，它与大于等于给定键的最小键关联；如果不存在这样  //的键，则返回 null。 

 K ceilingKey(K key) 

 //返回大于等于给定键的最小键；如果不存在这样的键，则返回 null。 

 void clear() 

 //从此映射中移除所有映射关系。 

 Object clone() 

 //返回此 TreeMap 实例的浅表副本。 

 Comparator<? super K> comparator() 

 //返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返 //回 null。 

 boolean containsKey(Object key) 

 //如果此映射包含指定键的映射关系，则返回 true。 

 boolean containsValue(Object value) 

 //如果此映射为指定值映射一个或多个键，则返回 true。 

 NavigableSet<K> descendingKeySet() 

 //返回此映射中所包含键的逆序 NavigableSet 视图。 

 NavigableMap<K,V> descendingMap() 

 //返回此映射中所包含映射关系的逆序视图。 

 Set<Map.Entry<K,V>> entrySet() 

 //返回此映射中包含的映射关系的 Set 视图。 

 Map.Entry<K,V> firstEntry() 

 //返回一个与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回  //null。 

 K firstKey() 

 //返回此映射中当前第一个（最低）键。 

 Map.Entry<K,V> floorEntry(K key) 

 //返回一个键-值映射关系，它与小于等于给定键的最大键关联；如果不存在这样  //的键，则返回 null。 

 K floorKey(K key) 

 //返回小于等于给定键的最大键；如果不存在这样的键，则返回 null。 

 V get(Object key) 

 //返回指定键所映射的值，如果对于该键而言，此映射不包含任何映射关系，则     //返回 null。 

 SortedMap<K,V> headMap(K toKey) 

  //返回此映射的部分视图，其键值严格小于 toKey。 

 NavigableMap<K,V> headMap(K toKey, boolean inclusive) 

 //返回此映射的部分视图，其键小于（或等于，如果 inclusive 为 true）toKey。 

 Map.Entry<K,V> higherEntry(K key) 

  //返回一个键-值映射关系，它与严格大于给定键的最小键关联；如果不存在这样 //的键，则返回 null。 

 K higherKey(K key) 

 //返回严格大于给定键的最小键；如果不存在这样的键，则返回 null。 

 Set<K> keySet() 

 //返回此映射包含的键的 Set 视图。 

 Map.Entry<K,V> lastEntry() 

//返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。 

 K lastKey() 

 // 返回映射中当前最后一个（最高）键。 

 Map.Entry<K,V> lowerEntry(K key) 

//返回一个键-值映射关系，它与严格小于给定键的最大键关联；如果不存在这样的 //键，则返回 null。 

 K lowerKey(K key) 

 //返回严格小于给定键的最大键；如果不存在这样的键，则返回 null。 

 NavigableSet<K> navigableKeySet() 

 //返回此映射中所包含键的 NavigableSet 视图。 

 Map.Entry<K,V> pollFirstEntry() 

 //移除并返回与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回      //null。 

 Map.Entry<K,V> pollLastEntry() 

 //移除并返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回  //null。 

 V put(K key, V value) 

 //将指定值与此映射中的指定键进行关联。 

 void putAll(Map<? extends K,? extends V> map) 

 //将指定映射中的所有映射关系复制到此映射中。 

 V remove(Object key) 

 //如果此 TreeMap 中存在该键的映射关系，则将其删除。 

 int size() 

 //返回此映射中的键-值映射关系数。 

 NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean   toInclusive) 

 //返回此映射的部分视图，其键的范围从 fromKey 到 toKey。 

 SortedMap<K,V> subMap(K fromKey, K toKey) 

 //返回此映射的部分视图，其键值的范围从 fromKey（包括）到 toKey（不包括）。 

 SortedMap<K,V> tailMap(K fromKey) 

 //返回此映射的部分视图，其键大于等于 fromKey。 

 NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) 

 //返回此映射的部分视图，其键大于（或等于，如果 inclusive 为 true）fromKey。 

 Collection<V> values() 

 //返回此映射包含的值的 Collection 视图。 

g) Collections

 

static <T> boolean  addAll(Collection<? super T> c, T... elements) 

 //将所有指定元素添加到指定 collection 中。 

static <T> Queue<T>  asLifoQueue(Deque<T> deque) 

//以后进先出 (Lifo) Queue 的形式返回某个 Deque 的视图。 

static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) 

//使用二分搜索法搜索指定列表，以获得指定对象。 

static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 

//使用二分搜索法搜索指定列表，以获得指定对象。 

static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s, Class<E> type) 

//返回指定有序 set 的一个动态类型安全视图。 

static <T> void copy(List<? super T> dest, List<? extends T> src) 

//将所有元素从一个列表复制到另一个列表。 

static boolean disjoint(Collection<?> c1, Collection<?> c2) 

//如果两个指定 collection 中没有相同的元素，则返回 true。 

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) 

//返回一个指定 collection 上的枚举。 

static <T> void fill(List<? super T> list, T obj) 

//使用指定元素替换指定列表中的所有元素。 

static int frequency(Collection<?> c, Object o) 

//返回指定 collection 中等于指定对象的元素数。 

static int indexOfSubList(List<?> source, List<?> target) 

//返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列 //表，则返回 -1。 

static int lastIndexOfSubList(List<?> source, List<?> target) 

//返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的 //列表，则返回 -1。 

static <T> ArrayList<T> list(Enumeration<T> e) 

//返回一个数组列表，它按返回顺序包含指定枚举返回的元素。 

static <T extends Object & Comparable<? super T>> 

T max(Collection<? extends T> coll) 

//根据元素的自然顺序，返回给定 collection 的最大元素。 

static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp) 

//根据指定比较器产生的顺序，返回给定 collection 的最大元素。 

static <T extends Object & Comparable<? super T>> 

T min(Collection<? extends T> coll) 

//根据元素的自然顺序 返回给定 collection 的最小元素。 

static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp) 

//根据指定比较器产生的顺序，返回给定 collection 的最小元素。 

static <T> List<T> nCopies(int n, T o) 

//返回由指定对象的 n 个副本组成的不可变列表。 

static <E> Set<E> newSetFromMap(Map<E,Boolean> map) 

//返回指定映射支持的 set。 

static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 

//使用另一个值替换列表中出现的所有某一指定值。 

static void reverse(List<?> list) 

//反转指定列表中元素的顺序。 

static <T> Comparator<T> reverseOrder() 

//返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然 //顺序。 

static <T> Comparator<T> reverseOrder(Comparator<T> cmp) 

//返回一个比较器，它强行逆转指定比较器的顺序。 

static void rotate(List<?> list, int distance) 

//根据指定的距离轮换指定列表中的元素。 

static void shuffle(List<?> list) 

//使用默认随机源对指定列表进行置换。 

static void shuffle(List<?> list, Random rnd) 

//使用指定的随机源对指定列表进行置换。 

static <T> Set<T> singleton(T o) 

//返回一个只包含指定对象的不可变 set。 

static <T> List<T> singletonList(T o) 

//返回一个只包含指定对象的不可变列表。 

static <K,V> Map<K,V> singletonMap(K key, V 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) 

//在指定列表的指定位置处交换元素。 

static <T> Collection<T> synchronizedCollection(Collection<T> c) 

//返回指定 collection 支持的同步（线程安全的）collection。 

static <T> List<T> synchronizedList(List<T> list) 

//返回指定列表支持的同步（线程安全的）列表。 

static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) 

//返回由指定映射支持的同步（线程安全的）映射。 

static <T> Set<T> synchronizedSet(Set<T> s) 

//返回指定 set 支持的同步（线程安全的）set。 

static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m) 

//返回指定有序映射支持的同步（线程安全的）有序映射。 

static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s) 

//返回指定有序 set 支持的同步（线程安全的）有序 set。 

static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c) 

//返回指定 collection 的不可修改视图。 

static <T> List<T> unmodifiableList(List<? extends T> list) 

//返回指定列表的不可修改视图。 

static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m) 

//返回指定映射的不可修改视图。 

static <T> Set<T> unmodifiableSet(Set<? extends T> s) 

//返回指定 set 的不可修改视图。