Java集合框架

集合框架类图

 

     

 

Collection 接口

 

      Collection 接口是层次结构中的跟接口，并实现 Iterable 接口。Collection 表示一个独立元素的序列。这些元素都服从一条或多条规则。List 必须按照插入的顺序保存元素，而 Set 不能有重复元素。因为 Collection 都实现了 Iterable 所有的 Collection 都可与用 foreach 遍历。并且所有 Collection 在构造时，都可以接受另一个 Collection 来初始化本身。

 

       Collection 常用子接口：List、Set、SortedSet。

 

       Collection 常用实现类：ArrayList、LinkedList、HashSet、LinkedHashSet、TreeSet

 

       Collection所有功能和方法：

 

             

boolean	add (E  e)           确保此 collection 包含指定的元素（可选操作）。
boolean	addAll (Collection <? extends E > c)           将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
void	clear ()           移除此 collection 中的所有元素（可选操作）。
boolean	contains (Object  o)           如果此 collection 包含指定的元素，则返回 true 。
boolean	containsAll (Collection <?> c)           如果此 collection 包含指定 collection 中的所有元素，则返回 true 。
boolean	equals (Object  o)           比较此 collection 与指定对象是否相等。
int	hashCode ()           返回此 collection 的哈希码值。
boolean	isEmpty ()           如果此 collection 不包含元素，则返回 true 。
Iterator <E >	iterator ()           返回在此 collection 的元素上进行迭代的迭代器。
boolean	remove (Object  o)           从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
boolean	removeAll (Collection <?> c)           移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
boolean	retainAll (Collection <?> c)           仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
int	size ()           返回此 collection 中的元素数。
Object []	toArray ()           返回包含此 collection 中所有元素的数组。
<T> T[]	toArray (T[] a)           返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

 

 

List 接口

 

    List 接口继承自 Collection ，是有序的 Collection ,此接口的用户可以对列表中每个元素的插入位置进行精确控制。用户可以根据元素的整数索引访问元素。List 接口在 Collection 的基础上添加了大量的方法，使得可以在 List 的中间插入和移除元素。

 

     两种类型的 List 实现

• ArrayList   它擅长于随机访问元素，但是在 List 中间插入和移除元素时较慢。
• LinkedList  它通过代价较低的在 List 中间进行插入和删除元素的操作，提供了优化的顺序访问。LinkedList 在随机访问方面相对较慢，但是它的特性集较大。

          LinkedList 还添加了可以使其用做栈、队列或者双端队列的方法。例如：

      一、 getFirst() 和 element() 完全一样，它们都返回列表头（第一个元素），而并不移除它们，如果 List 为空，则抛出 NoSuchElement-Exception。peek() 方法与这两个方法稍有差异，它在列表头为空的时候返回 null。

      二、 removeFirst() 与 remove() 也是完全一样，他们移除并返回列表头，而在列表为空的时候抛出 NoSuchElement-Exception，poll() 稍有差异，它在列表头为空的时候返回 null。

      三、 addFirst() 与 add() 和 addLast() 相同，它们都将某个元素插入到列表尾部，removeLast() 移除并返回列表的最后一个元素。

 

 

Set 接口

 

    Set 具有与 Collection 完全一样的接口，因此没有任何额外功能，不像 List 有两个不同的实现。实际上 Set 就是 Collection ,只是行为不同。Set 中不能保存重复的元素，正因如此，查找就成为了 Set 中最重要的操作，因此通常会选择一个 HashSet 的实现，它专门对快速查找进行了优化。

 

     三种类型的 Set 实现

• HashSet   它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。它维护元素的顺序是依据散列函数。（一般使用 HashSet，存入的元素必须定义 hashCode()）
• TreeSet     它将元素存储于红-黑树的数据结构中。（元素必须实现 Comparable 接口）
• LinkedHashSet    因为查询速度的原因，它也使用了散列，但是看起来它使用了链表来维护元素的插入顺序。（存入的元素必须定义 hashCode()）

 

Map 接口

 

    Map 接口不是 Collection 接口的继承。Map 接口用于维护 键-值 对，该接口描述了从不重复的键到值的映射。

    

     六种类型的 Map 实现

• HashMap   Map 基于散列表的实现取代了 HashTable。插入和查询“键值对”的开销是固定的，可以通过构造器设置容量，以调整容器的性能。（一般使用 HashMap）
• LinkedHashMap   类似于 HashMap ，但是迭代遍历时，取得“键值对”的顺序是其插入次序。只比 HashMap 慢一点，但是在迭代访问时反而更快，因为它使用链表维护内部次序。
• TreeMap   基于红黑树的实现。查看“键”或“键值对”时，它们会被排序（次序由 Comparable 或 Comparator 决定）。TreeMap 的特点在于，所得到的结果 是经过排序的，它的 subMap() 方法可以返回一个子树。
• WeakHashMap   弱键映射。允许释放映射所指向的对象，如果映射之外没有引用指向某个键，则键可以被垃圾回收器回收。
• ConcurrentHashMap   一种线程安全的 Map ，它不涉及同步加锁。
• IdentityHashMap   使用==代替 equals() 对键进行比较的散列映射。

     作为 Map 集合中的 key 类，必须重写 hashCode() 方法和 equals() 方法。例：

 

     public class Demo { public static void main(String[] args) { Map<MyKey, Integer> map = new HashMap<MyKey, Integer>(); map.put(new MyKey("zhangsan", 10), 1); map.put(new MyKey("lisi", 12), 2); map.put(new MyKey("wangwu", 5), 3); Iterator<MyKey> iterator = (Iterator<MyKey>) map.keySet().iterator(); while (iterator.hasNext()) { MyKey key = iterator.next(); System.out.println(key + "=" + map.get(key)); } System.out.println(map.get(new MyKey("lisi", 12))); } } class MyKey { public MyKey(String name, int age) { this.name = name; this.age = age; } private String name; private int age; public boolean equals(Object o) { if (o instanceof MyKey) { MyKey key = (MyKey) o; if (this.name.equals(key.name) && this.age == key.age) return true; } return false; } public int hashCode() { return this.name.hashCode() + this.age; } public String toString() { return this.name + ":" + this.age; } }

 

 

迭代器

 

    迭代器是一个对象，它的工作是遍历并选择序列中的对象，而外部不必知道或关心该序列的底层结构，因此迭代器经常被称作是轻量级的对象：它的创建代价小。Java 的 Iterator 只能单向移动，这个 Iterator 只能用来：

• 使用方法 iterator() 要求容器返回一个 Iterator。Iterator 将准备好返回序列的第一个元素。
• 使用方法 next() 获取序列中的下一个元素。
• 使用方法 hasNext() 检查序列中是否还有元素。
• 使用方法 remove() 将迭代器新近返回的元素删除。

 

ListIterator

 

    ListIterator 是一个更加强大的 Iterator 的子类型。它只能用于各种 List 类的访问。尽管 Iterator 只能单向移动，但是 ListIterator 可以双向移动，它还可以产生相对于迭代器在列表中指向的当前位置的前一个和后一个索引，并且可以使用 set() 方法替换它访问过的最后一个元素。你可以通过调用 listIterator() 方法产生一个指向 List 开始出的 ListIterator，并且还可以通过调用 listIterator(index) 方法创建一个一开始就指向列表索引为 index 的元素。

 

     List<String> list = new ArrayList<String>(); list.add("一"); list.add("二"); list.add("三"); list.add("四"); list.add("五"); ListIterator<String> iterator = list.listIterator(5); while (iterator.hasPrevious()) { iterator.previous(); iterator.set("六"); } System.out.println(list);//输出 六六六六六

 

 

（附）Java.util.Collections类包的学习

 

      排序(Sort)

 

      使用sort方法可以根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此列表内的所有元素都必须是使用指定比较器可相互比较的

 

      double array[] = {112, 111, 23, 456, 231 }; 　　for (int i = 0; i < array.length; i++) { 　　list.add(new Double(array[i])); 　　} 　　Collections.sort(list); 　　for (int i = 0; i < array.length; i++) { 　　System.out.println(li.get(i)); 　　} 　　//结果：112,111,23,456,231

 

      混排(Shuffling)

 

      混排算法所做的正好与 sort 相反： 它打乱在一个 List 中可能有的任何排列的踪迹。也就是说，基于随机源的输入重排该 List， 这样的排列具有相同的可能性(假设随机源是公正的)。这个算法在实现一个碰运气的游戏中是非常有用的。例如，它可被用来混排代表一副牌的 Card 对象的一个 List .另外，在生成测试案例时，它也是十分有用的。

 

      Collections.Shuffling(list) 　　double array[] = {112, 111, 23, 456, 231 }; 　　for (int i = 0; i < array.length; i++) { 　　list.add(new Double(array[i])); 　　} 　　Collections.shuffle(list); 　　for (int i = 0; i < array.length; i++) { 　　System.out.println(li.get(i)); 　　} 　　//结果：112,111,23,456,231

 

      反转(Reverse)

 

      使用Reverse方法可以根据元素的自然顺序 对指定列表按降序进行排序。

 

      Collections.reverse(list) 　　double array[] = {112, 111, 23, 456, 231 }; 　　for (int i = 0; i < array.length; i++) { 　　list.add(new Double(array[i])); 　　} 　　Collections. reverse (list); 　　for (int i = 0; i < array.length; i++) { 　　System.out.println(li.get(i)); 　　} 　　//结果：231,456,23,111,112

 

      替换所有的元素(Fill)

 

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

 

      String str[] = {"dd","aa","bb","cc","ee"}; 　　for(int j=0;j 　　li.add(new String(str[j])); 　　} 　　Collections.fill(li,"aaa"); 　　for (int i = 0; i < li.size(); i++) { 　　System.out.println("list[" + i + "]=" + li.get(i)); 　　} 　　//结果：aaa,aaa,aaa,aaa,aaa

 

      拷贝(Copy)

 

      用两个参数，一个目标 List 和一个源 List， 将源的元素拷贝到目标，并覆盖它的内容。目标 List 至少与源一样长。如果它更长，则在目标 List 中的剩余元素不受影响。

　　Collections.copy(list，li)： 后面一个参数是目标列表 ，前一个是源列表

 

      double array[] = {112, 111, 23, 456, 231 }; 　　List list = new ArrayList(); 　　List li = new ArrayList(); 　　for (int i = 0; i < array.length; i++) { 　　list.add(new Double(array[i])); 　　} 　　double arr[] = {1131,333}; 　　String str[] = {"dd","aa","bb","cc","ee"}; 　　for(int j=0;j 　　li.add(new Double(arr[j])); 　　} 　　Collections.copy(list,li); 　　for (int i = 0; i 　　System.out.println("list[" + i + "]=" + list.get(i)); 　　} 　　//结果：1131,333,23,456,231

 

      返回Collections中最小元素(min)

 

      根据指定比较器产生的顺序，返回给定 collection 的最小元素。collection 中的所有元素都必须是通过指定比较器可相互比较的

 

      Collections.min(list) 　　double array[] = {112, 111, 23, 456, 231 }; 　　List list = new ArrayList(); 　　for (int i = 0; i < array.length; i++) { 　　list.add(new Double(array[i])); 　　} 　　Collections.min(list); 　　for (int i = 0; i 　　System.out.println("list[" + i + "]=" + list.get(i)); 　　} 　　//结果：23

 

      返回Collections中最大元素(max)

 

      根据指定比较器产生的顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须是通过指定比较器可相互比较的

 

      Collections.max(list) 　　double array[] = {112, 111, 23, 456, 231 }; 　　List list = new ArrayList(); 　　for (int i = 0; i < array.length; i++) { 　　list.add(new Double(array[i])); 　　} 　　Collections.max(list); 　　for (int i = 0; i 　　System.out.println("list[" + i + "]=" + list.get(i)); 　　} 　　//结果：456

 

      lastIndexOfSubList 返回指定源列表中最后一次出现指定目标列表的起始位置

 

      int count = Collections.lastIndexOfSubList(list,li); 　　double array[] = {112, 111, 23, 456, 231 }; 　　List list = new ArrayList(); 　　List li = new ArrayList(); 　　for (int i = 0; i < array.length; i++) { 　　list.add(new Double(array[i])); 　　} 　　double arr[] = {111}; 　　String str[] = {"dd","aa","bb","cc","ee"}; 　　for(int j=0;j 　　li.add(new Double(arr[j])); 　　} 　　Int locations = Collections. lastIndexOfSubList (list,li); 　　System.out.println(“===”+ locations); 

      结果 3

 

      IndexOfSubList 返回指定源列表中第一次出现指定目标列表的起始位置

 

      int count = Collections.indexOfSubList(list,li); 　　double array[] = {112, 111, 23, 456, 231 }; 　　List list = new ArrayList(); 　　List li = new ArrayList(); 　　for (int i = 0; i < array.length; i++) { 　　list.add(new Double(array[i])); 　　} 　　double arr[] = {111}; 　　String str[] = {"dd","aa","bb","cc","ee"}; 　　for(int j=0;j 　　li.add(new Double(arr[j])); 　　} 　　Int locations = Collections.indexOfSubList(list,li); 　　System.out.println(“===”+ locations); 　　//结果 1

      Rotate 根据指定的距离循环移动指定列表中的元素

 

      double array[] = {112, 111, 23, 456, 231 }; 　　List list = new ArrayList(); 　　for (int i = 0; i < array.length; i++) { 　　list.add(new Double(array[i])); 　　} 　　Collections.rotate(list,-1); 　　for (int i = 0; i 　　System.out.println("list[" + i + "]=" + list.get(i)); 　　} 　　//结果：111,23,456,231,112