Java 集合类详解

Posted 2023-05-31 echo97

为什么要使用集合

存储多个数据可以使用数组，但由于数组在内存中是连续存储的，所以会有一些限制。比如数组在创建时就要指定长度，即可以容纳的元素个数，且指定后无法更改；数组在创建时需要指定元素的类型，并且所有元素都必须是该类型或其子类；添加或删除数组中的元素需要创建一个新数组再进行元素复制，比较麻烦。下面是 Person 数组扩容的示意代码。

// 给 people1 数组末尾添加一个元素
public class PersonArray 
    public static void main(String[] args) 
        Person[] people1 = new Person[1];
        people1[0] = new Person();

        // 创建新数组
        Person[] people2 = new Person[people1.length + 1];
        // 复制 people1 数组的元素到 people2
        for (int i = 0; i < people1.length; i++) 
            people2[i] = people1[i];
        
        // 添加新元素
        people2[people2.length - 1] = new Person();
    

数组可以通过索引快速访问和操作元素，在许多场景下仍然是非常有用的，但如果需要动态调整大小或保存不同类型的元素，则可以考虑使用集合类来代替数组。集合类还提供了一系列增加、删除、修改和查找元素的方法。集合框架中还提供了多种优化和封装好的实现类，通过使用合适的集合类可以更高效地组织和操作数据。

集合框架体系

Java 的集合类很多，主要有Collection和Map两个接口，层次关系如下图。

Collection接口有List和Set这两个重要的子接口，它们的实现子类都是单列集合。其中List接口表示有序的、可以包含重复元素的集合，常见的实现类有ArrayList、LinkedList和Vector。Set接口表示无序的且不包含重复元素的集合，常见的实现类有HashSet、TreeSet和LinkedHashSet。

Map接口实现子类是双列集合，表示一组键值对的映射，其中每个键都是唯一的。常见的实现类有HashMap、Hashtable和Properties。

public class AddElements() 
  public static void main(String[] args) 
    ArrayList<Object> list = new ArrayList<>();
    list.add("黄蓉");
    list.add("郭靖");

    HashMap hashMap = new HashMap();
    hashMap.put("001", "黄蓉");
    hashMap.put("002", "郭靖");
  

Collection 接口和常用方法

Collection 接口实现类的特点

Collection实现类（通常通过其中一个子接口间接实现Collection）可以存放多个 Object 类型的元素。有些Collection接口的实现类可以存放重复的元素，有些则不可以。有些Collection接口的实现类是有序的（List），有些是无序的（Set）。Collection接口没有直接实现类，提供了更具体的子接口（如Set和List ）的实现。

所有通用的Collection实现类都会提供两个"标准"构造方法：一个无参构造方法，来创建一个空的集合，以及一个带有单个Collection类型参数的构造方法，创建一个与参数集合具有相同元素的新集合。实际上，后一种构造方法可以复制任何集合，生成一个与参数集合元素相同的所需类型的集合。

public class CollectionMethod() 
  public static void main(String[] args) 
    ArrayList list = new ArrayList();
    list.add(1);
    list.add(2);
    list.add(3);
    System.out.println(list);// [1, 2, 3]

    Vector<Object> vector = new Vector<>(list);
    System.out.println(vector);// [1, 2, 3]
  

Collection 接口常用方法

下面的代码以其间接实现类ArrayList演示Collection接口的常用方法。

public class CollectionMethod() 
  public static void main(String[] args) 
    Collection collection = new ArrayList<>();
    
    // boolean add(E e)
    // 给集合中添加指定的元素，添加成功则返回 true。
    // 如果此集合不允许重复元素并且已经包含了指定的元素，则返回 false。
    // 支持此操作的实现类可能会对添加到该集合中的元素进行限制。
    // 如果一个集合拒绝添加某个特定元素的原因不是因为集合已经包含该元素，
    // 会抛出一个异常（而不是返回 false）。
    collection.add("hello");
    collection.add(10);
    collection.add(true);
    // 下面一条语句执行后输出：collection = [hello, 10, true]
    System.out.println("collection = " + collection);
    
    // boolean remove(Object o)
    // 从集合中移除指定元素的一个实例。如果集合包含多个满足
    // (o==null ? e==null : o.equals(e))条件的元素 e，
    // 则移除第一个元素 e。移除完成后返回 true。
    collection.remove("hello");
    // 下面一条语句执行后输出：collection = [10, true]
		System.out.println("collection = " + collection);
    
    // boolean contains(Object o)
    // 如果此集合包含指定元素，则返回 true。更准确地说，当且仅当此集合包含至少
    // 一个满足(o==null ? e==null : o.equals(e))条件的元素 e 时，返回 true。
    System.out.println(collection.contains(10));// true
    
    // int size()
    // 返回此集合中的元素数量。
    System.out.println(collection.size());// 2
    
    // boolean isEmpty()
    // 判断集合是否为空。
    System.out.println(collection.isEmpty());// false
    
    // void clear()
    // 清空集合中的元素。
    collection.clear();
    // 下面一条语句执行后输出：collection = []
    System.out.println("collection = " + collection);
    
    // boolean addAll(Collection<? extends E> c)
    // 将指定集合中的所有元素添加到此集合中。
    Collection collection1 = new ArrayList();
    collection1.add("Mary");
    collection1.add("Luck");
    collection.addAll(collection1);
    // 下面一条语句执行后输出：collection = [Mary, Luck]
    System.out.println("collection = " + collection);
   
    // boolean containsAll(Collection<?> c)
    // 判断此集合是否包含指定集合中的所有元素
    System.out.println(collection.containsAll(collection1));// true

    // boolean removeAll(Collection<?> c)
    // 从此集合中移除与指定集合中相同的所有元素。
    // 在此调用返回后，此集合将不包含与指定集合共有的任何元素。
    collection.add("King");
    collection.removeAll(collection1);
    // 下面一条语句执行后输出：collection = [King]
    System.out.println("collection = " + collection);
  

Collection 接口如何遍历元素

使用 Iterator（迭代器）

Iterator接口是集合的迭代器，主要用于遍历Collection集合中的元素。所有实现了Collection接口的实现类，都有一个iterator()方法，用以返回一个实现了Iterator接口的对象，即可以返回一个迭代器。

Iterator接口的方法：

// 判断是否还有下一个元素
boolean hasNext()
  
// 返回集合中的下一个元素
E next()

// 从底层集合中移除此迭代器返回的最后一个元素。每次调用 next() 只能调用此方法一次。
// 如果在调用此方法之前尚未调用过 next() 方法，或者在最后一次调用 next() 方法之后
// 已经调用了过一次 remove() 方法，则抛出 IllegalStateException 异常。
default void remove() 

// 对剩余的每个元素执行给定的操作，直到所有元素被处理完或操作抛出异常为止。
default void forEachRemaining(Consumer<? super E> action)

迭代器的使用示例代码：

public class CollectionIterateor() 
  public static void main(String[] args) 
    Collection col = new ArrayList();
    col.add("红楼梦");
    col.add("西游记");
    col.add("三国演义");
    col.add("水浒传");

    // 遍历 col 集合
    // 先获得 col 对应的迭代器
    Iterator iterator = col.iterator();
    // 使用 while 循环遍历
    while (iterator.hasNext()) // 判断是否还有元素
      Object obj = iterator.next(); // 返回下一个元素，类型是 Object
      System.out.println("obj = " + obj);
    
    
    // 当退出 while 循环后，iterator 迭代器指向最后一个元素
    // 此时再调用 next() 会抛出 NoSuchElementException 异常
    // iterator.next();
    
    // 如果需要再次遍历，需要重制迭代器
    System.out.println("===第二次遍历===");
    iterator = col.iterator();
    while (iterator.hasNext()) 
      Object obj = iterator.next();
      System.out.println("obj = " + obj);
    
  

由于当迭代器中不存在下一个元素时，直接调用 iterator.next() 方法会抛出 NoSuchElementException 异常，所以调用 iterator.next() 方法之前需要调用 iterator.hasNext() 方法。

增强 for 循环

增强 for 循环是简化版的 iterator，本质一样，只能用来遍历集合或数组。基本语法如下：

for(元素类型 元素名 : 集合名或数组名)
	访问元素;

public class EnhancedFor() 
  public static void main(String[] args) 
    Collection collection = new ArrayList();

    collection.add("mary");
    collection.add(true);
    collection.add(10);

    for (Object o : collection) 
      System.out.println("o = " + o);
    
  

Java集合类详解

转载至：

Java集合类详解

Java的集合就像是一种容器，可以把对个对象的引用放入容器中，其中不断可以存储不等的多个对象，还可以用于保存具有映射关系的关联数组。其中Java的集合可以分为三种体系：

• Set集合：内部元素无序，并且元素不可以重复；
• List集合：内部元素有序，且元素可以重复；
• Map集合：具有映射关系的集合

 

（一）Collection接口：

Collection接口是List，Set和Queue接口的父接口，该接口中定义的方法可以用户操作List，Set和Queue集合；其中主要有以下的一些方法：

 

这里给出测试上述部分方法的举例：

首先给出Person类，用于放入集合中

 1 package collection;
 2 
 3 /**
 4  * Created by : Zhong
 5  * DATE : 2017/3/2
 6  * Time : 23:06
 7  * Funtion :
 8  */
 9 public class Person {
10     public String name;
11     public int age;
12 
13 
14     public Person() {
15 
16     }
17 
18     public Person(String name, int age) {
19         this.name = name;
20         this.age = age;
21     }
22 
23 
24     public String getName() {
25         return name;
26     }
27 
28     public void setName(String name) {
29         this.name = name;
30     }
31 
32 
33     public int getAge() {
34         return age;
35     }
36 
37     public void setAge(int age) {
38         this.age = age;
39     }
40 
41     @Override
42     public String toString() {
43         return "Person{" +
44                 "name=‘" + name + ‘\\‘‘ +
45                 ", age=" + age +
46                 ‘}‘;
47     }
48 
49     @Override
50     public boolean equals(Object o) {
51         if (this == o) return true;
52         if (o == null || getClass() != o.getClass()) return false;
53 
54         Person person = (Person) o;
55 
56         if (age != person.age) return false;
57         return name != null ? name.equals(person.name) : person.name == null;
58 
59     }
60 
61     @Override
62     public int hashCode() {
63         int result = name != null ? name.hashCode() : 0;
64         result = 31 * result + age;
65         return result;
66     }
67 }

 

 

然后举例说明Collection接口的相关方法：

  1 package collection;
  2 
  3 import org.junit.Test;
  4 
  5 import java.util.ArrayList;
  6 import java.util.Collection;
  7 import java.util.Iterator;
  8 
  9 /**
 10  * Created by :Infaraway
 11  * DATE : 2017/3/26
 12  * Time : 12:35
 13  * Funtion :
 14  */
 15 public class CollectionTest {
 16 
 17 
 18 
 19     @Test
 20     public void testTool(){
 21         Collection collection = new ArrayList();
 22         Collection collection2 = new ArrayList();
 23         Person person = new Person("Tom", 22);
 24         collection.add(person);
 25         collection.add(new Person("Jerry", 25));
 26         collection.add(new Person("Mike", 32));
 27         collection.add("infaraway");
 28 
 29         //1. contains(Object obj)：利用equals方法比较，查看集合中有没有指定元素
 30         boolean flag = collection.contains(new Person("Mike", 32));
 31         System.out.println(flag);
 32         flag = collection.contains(person);
 33         System.out.println(flag);
 34 
 35         //2. containsAll(Collection coll)利用equals方法比较，查看集合中有没有指定元素的集合
 36         collection2.add(person);
 37         collection2.add("infaraway");
 38         flag = collection.containsAll(collection2);
 39         System.out.println(flag);
 40 
 41         //3. isEmpty()：检查集合是否为空
 42         flag = collection.isEmpty();
 43         System.out.println(flag);
 44 
 45         //4. toArray()转化集合为数组
 46         Object [] object = collection.toArray();
 47         System.out.println(object.length);
 48 
 49         //toArray(T[] a)
 50     }
 51 
 52 
 53     /**
 54      * 1. clear() 清空集合
 55      * 2. remove() ：移除指定的元素，通过equals() 方法在集合中查找指定的元素
 56      * 如果元素存在，则移除
 57      * 3. removeAll(Collection coll) 移除coll中有的元素
 58      * 4. retainAll(Collection coll) 保存coll中有的元素
 59      */
 60     @Test
 61     public void testRemove(){
 62 
 63         Collection collection = new ArrayList();
 64         Collection collection2 = new ArrayList();
 65         Person person = new Person("Tom", 22);
 66         collection.add(person);
 67         collection.add(new Person("Jerry", 25));
 68         collection.add(new Person("Mike", 32));
 69         collection.add("infaraway");
 70 
 71        /* System.out.println(collection.size());
 72         collection.remove(person);*/
 73 
 74         System.out.println(collection.size());
 75 
 76         collection2.add(person);
 77         collection2.add("infaraway");
 78 
 79         collection.removeAll(collection2);
 80         System.out.println(collection.size());
 81     }
 82 
 83     /**
 84      * 在Collection中无法获取指定的元素，但是可以遍历所有的元素
 85      * 1. 使用增强for循环遍历
 86      * 2. 使用Iterator迭代器遍历
 87      *  2.1 获取迭代器对象，调用Collection的iterator方法，获取Iterator接口的实现
 88      *  2.2 调用Iterator接口方法进行迭代
 89      */
 90     @Test
 91     public void testIterator(){
 92 
 93         Collection collection = new ArrayList();
 94         Collection collection2 = new ArrayList();
 95         collection.add("infaraway");
 96 
 97         Person person = new Person("Tom", 22);
 98         collection.add(person);
 99         collection.add(new Person("Jerry", 25));
100         collection.add(new Person("Mike", 32));
101 
102         //使用addAll方法
103         collection2.addAll(collection);
104 
105        /* System.out.println(collection.size());
106         for (Object  o : collection) {
107             System.out.println(o);
108         }*/
109 
110         Iterator it = collection2.iterator();
111         while(it.hasNext()){
112             System.out.println(it.next());
113         }
114 
115 
116     }
117 
118     /**
119      * add()方法
120      */
121     @Test
122     public void testCollection(){
123         Collection collection = new ArrayList();
124         collection.add("infaraway");
125         collection.add(new Person("Tom", 22));
126         collection.add(new Person("Jerry", 25));
127         collection.add(new Person("Mike", 32));
128     }
129 
130 }

 

 

（二）Set集合

Set集合不允许包含相同的元素，如果把两个相同的元素添加进入Set集合，则添加操作失败。Set集合中判断两个对象是否相同不是使用“==” 而是根据equals()方法的返回值决定；

2.1 HashSet

1）HashSet特点

HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。
HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取和查找性能。
HashSet 具有以下特点：

• 不能保证元素的排列顺序
• HashSet 不是线程安全的
• 集合元素可以使 null

当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据 hashCode 值决定该对象在 HashSet 中的存储位置。如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功。

重写 hashCode() 方法的基本原则

1. 在程序运行时，同一个对象多次调用 hashCode() 方法应该返回相同的值
2. 当两个对象的 equals() 方法比较返回 true 时，这两个对象的 hashCode() 方法的返回值也应相等
3. 对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值

 

package collection;

import org.junit.Test;

import java.util.HashSet;
import java.util.Set;

/**
 * Created by :Infaraway
 * DATE : 2017/3/26
 * Time : 13:18
 * Funtion : 测试HashSet
 *
 * 关于HashSet
 * 1. HashSet是Set的最典型的实现
 * 2. HashSet中不能有重复的元素，判断两个元素相等的标准是equals()方法返回true
 * 3. HashSet根据hashCode()值来存储元素，因此不能保证元素的顺序
 * 4. 如果两个对象通过equals()方法返回true 这两个对象的hashcode值应该是相同的
 * 5. HashSet 是线程不安全的
 */

public class HashSetTest {

    @Test
    public void testAdd(){
        Set set = new HashSet();

        set.add(new Person("AAA",22));
        set.add(new Person("BBB",22));
        set.add(new Person("CCC",27));
        set.add(new Person("DDD",29));
        System.out.println(set.size());

        for (Object person : set) {
            System.out.println(person.toString());
        }

    }

}

2）子类 LinkedHashSet 

LinkedHashSet 集合根据元素的hashCode值来决定元素的存储位置，但它同时使用链表维护元素的次序，这使得元素看起来是以插入顺序保存的。
LinkedHashSet 性能插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。
LinkedHashSet 不允许集合元素重复。

2.2 TreeSet

TreeSet 是 SortedSet 接口的实现类，TreeSet 可以确保集合元素处于排序状态。

其中TreeSet还有以下的一些常用的操作：这里就不一一列举实现了

• Comparator comparator()
• Object first()   获取第一个元素
• Object last()   获取最后一个元素
• Object lower(Object e)    
• Object higher(Object e)
• SortedSet subSet(fromElement, toElement)
• SortedSet headSet(toElement)
• SortedSet tailSet(fromElement)

TreeSet 支持两种排序方法：自然排序和定制排序。默认情况下，TreeSet 采用自然排序。

 1）自然排序

排序：TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序排列，如果试图把一个对象添加到 TreeSet 时，则该对象的类必须实现 Comparable 接口。实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。

实现Compareable接口代码示例：

 1 package collection;
 2 
 3 /**
 4  * Created by : Zhong
 5  * DATE : 2017/3/2
 6  * Time : 23:06
 7  * Funtion :
 8  */
 9 public class PersonCompare implements Comparable{
10     public String name;
11     public int age;
12     public PersonCompare() {
13     }
14     public PersonCompare(String name, int age) {
15         this.name = name;
16         this.age = age;
17     }
18     public String getName() {
19         return name;
20     }
21     public void setName(String name) {
22         this.name = name;
23     }
24     public int getAge() {
25         return age;
26     }
27     public void setAge(int age) {
28         this.age = age;
29     }
30     @Override
31     public String toString() {
32         return "Person{" +
33                 "name=‘" + name + ‘\\‘‘ +
34                 ", age=" + age +
35                 ‘}‘;
36     }
37 
38     @Override
39     public boolean equals(Object o) {
40         if (this == o) return true;
41         if (o == null || getClass() != o.getClass()) return false;
42 
43         PersonCompare person = (PersonCompare) o;
44 
45         if (age != person.age) return false;
46         return name != null ? name.equals(person.name) : person.name == null;
47 
48     }
49     @Override
50     public int hashCode() {
51         int result = name != null ? name.hashCode() : 0;
52         result = 31 * result + age;
53         return result;
54     }
55 
56     @Override
57     public int compareTo(Object o) {
58 
59         if (o instanceof PersonCompare){
60             PersonCompare personCompare = (PersonCompare) o;
61             return this.name.compareTo(personCompare.name);
62         }else{
63             throw new ClassCastException("转换类型失败！");
64         }
65     }
66 }

 

自然排序方法的使用示例：

/**
     * 自然排序情况
     *
     * 默认情况下TreeSet要求集合中的元素必须实现Comparable接口
     * Comparable接口中只有一个方法：
     * public int compareTo(T o)
     *     如果返回0 代表两个元素相等
     *     如果返回正数，代表当前元素大
     *     如果返回负数，代表当前元素小
     * TreeSet 会调用每个元素的compareTo()方法去和集合中的每个已经有的元素比较，进而决定当前元素在集合中的位置
     *
     */
    @Test
    public void testTreeSet(){

        TreeSet treeSet = new TreeSet();
        treeSet.add(new PersonCompare("AAA",16));
        treeSet.add(new PersonCompare("BBB",13));
        treeSet.add(new PersonCompare("CCC",11));
        treeSet.add(new PersonCompare("DDD",15));

        for (Object o : treeSet) {
            System.out.println(o.toString());
        }
    }

Comparable 的典型实现：

• BigDecimal、BigInteger 以及所有的数值型对应的包装类：按它们对应的数值大小进行比较
• Character：按字符的 UNICODE 值来进行比较
• Boolean：true 对应的包装类实例大于 false 对应的包装类实例
• String：按字符串中字符的 UNICODE 值进行比较
• Date、Time：后边的时间、日期比前面的时间、日期大

 因为只有相同类的两个实例才会比较大小，所以向 TreeSet 中添加的应该是同一个类的对象。当需要把一个对象放入 TreeSet 中，重写该对象对应的 equals() 方法时，应保证该方法与 compareTo(Object obj) 方法有一致的结果：如果两个对象通过 equals() 方法比较返回 true，则通过 compareTo(Object obj) 方法比较应返回 0

2）定制排序

如果需要实现定制排序，则需要在创建 TreeSet 集合对象时，提供一个 Comparator 接口的实现类对象。由该 Comparator 对象负责集合元素的排序逻辑。定制排序的优点就是让需要排序的对象不需要实现Compareable接口，减少了耦合性，是程序更加简单。

 定制排序方法代码示例：

/**
     * 定制排序
     *
     */
    @Test
    public void testTreeSet2(){
        //创建comparator接口的实现类对象
        Comparator comparator = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Person && o2 instanceof Person){
                    Person p1 = (Person)o1;
                    Person p2 = (Person)o2;
                    return p1.getAge() - p2.getAge();
                }
                throw new ClassCastException("类型转换异常");
            }
        };

        //创建TreeSet对象，传入Comparator接口的实现类对象
        TreeSet treeSet = new TreeSet(comparator);
        treeSet.add(new Person("AAA",16));
        treeSet.add(new Person("BBB",13));
        treeSet.add(new Person("CCC",11));
        treeSet.add(new Person("DDD",15));

        for (Object person : treeSet) {
            System.out.println(person.toString());
        }
    }

（三）List集合

3.1 概述

• List 代表一个元素有序、且可重复的集合，集合中的每个元素都有其对应的顺序索引
• List 允许使用重复元素，可以通过索引来访问指定位置的集合元素。
• List 默认按元素的添加顺序设置元素的索引。
• List 集合里添加了一些根据索引来操作集合元素的方法
  • void add(int index, Object ele)  把元素添加到指定的位置  原来的元素被后移
  • boolean addAll(int index, Collection eles) 把一组元素添加到指定的位置
  • Object get(int index)       获取指定索引的元素
  • int indexOf(Object obj)  获取指定对象的索引，如果元素不存在，则返回-1
  • int lastIndexOf(Object obj)   获取重复的元素的最后一个索引
  • Object remove(int index)  移除指定索引的元素
  • Object set(int index, Object ele)  设置指定索引的元素，原来的元素被替换
  • List subList(int fromIndex, int toIndex)

3.2 ArrayList 和 Vector

ArrayList 和 Vector 是 List 接口的两个典型实现
区别：

• 是一个古老的集合，通常建议使用 ArrayList
• ArrayList 是线程不安全的，而 Vector 是线程安全的。
• 即使为保证 List 集合线程安全，也不推荐使用 Vector

Arrays.asList(…) 方法返回的 List 集合即不是 ArrayList 实例，也不是 Vector 实例。 Arrays.asList(…) 返回值是一个固定长度的 List 集合。

 

（四）Map集合

4.1 概述

• Map 用于保存具有映射关系的数据，因此 Map 集合里保存着两组值，一组值用于保存 Map 里的 Key，另外一组用于保存 Map 里的 Value
• Map 中的 key 和 value 都可以是任何引用类型的数据
• Map 中的 Key 不允许重复，即同一个 Map 对象的任何两个 Key 通过 equals 方法比较中返回 false
• Key 和 Value 之间存在单向一对一关系，即通过指定的 Key 总能找到唯一的，确定的 Value。

常用方法：

• void clear()   清空map
• boolean containsKey(Object key)   检测是否包含key值
• boolean containsValue(Object value) 检测是否包含value值
• Set<Mao.Entry<K,V>> entrySet()  得到剪枝对对应的Entry 的Set
• V get(Object key)
• Set<K> keySet()
• V put(K key, V value)
• V remove(Object key) 移除指定key 的键值对

4.2 HashMap 和 Hashtable

• HashMap 和 Hashtable 是 Map 接口的两个典型实现类
• 区别：
  • Hashtable 是一个古老的 Map 实现类，不建议使用
  • Hashtable 是一个线程安全的 Map 实现，但 HashMap 是线程不安全的。
  • Hashtable 不允许使用 null 作为 key 和 value，而 HashMap 可以
• 与 HashSet 集合不能保证元素的顺序的顺序一样，Hashtable 、HashMap 也不能保证其中 key-value 对的顺序
• Hashtable 、HashMap 判断两个 Key 相等的标准是：两个 Key 通过 equals 方法返回 true，hashCode 值也相等。
• Hashtable 、HashMap 判断两个 Value相等的标准是：两个 Value 通过 equals 方法返回 true

4.3 LinkedHashMap 

LinkedHashMap 是 HashMap 的子类
LinkedHashMap 可以维护 Map 的迭代顺序：迭代顺序与 Key-Value 对的插入顺序一致

 1 @Test
 2     public void testLinkedHashMap(){
 3         Map map = new LinkedHashMap<>();
 4 
 5         map.put("CC", new Person("CC", 18));
 6         map.put("AA", new Person("AA", 10));
 7         map.put("DD", new Person("DD", 12));
 8         map.put("BB", new Person("BB", 16));
 9 
10         /*Iterator it = map.keySet().iterator();
11         while (it.hasNext()){
12             Object key = it.next();
13             Object value = map.get(key);
14             System.out.println(key+":"+value);
15         }
16         System.out.println();*/
17 
18         for (Object key : map.keySet()){
19             Object value = map.get(key);
20             System.out.println(key+":"+value);
21         }
22     }

 

4.4 TreeMap

TreeMap 存储 Key-Value 对时，需要根据 Key 对 key-value 对进行排序。TreeMap 可以保证所有的 Key-Value 对处于有序状态。
TreeMap 的 Key 的排序：

• 自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException
• 定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对 TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现 Comparable 接口

 同样这里的key值也需要具有可比性

 1    @Test
 2     public void testTreeMap(){
 3         Map map = new TreeMap<>();
 4 
 5         //这里使用加入Compareable接口的Person类，这样才可以进行排序
 6         map.put(new PersonCompare("CC", 18),"CC");
 7         map.put(new PersonCompare("AA", 10),"AA");
 8         map.put(new PersonCompare("DD", 12),"DD");
 9         map.put(new PersonCompare("BB", 16),"BB");
10 
11         for (Object key : map.keySet()){
12             Object value = map.get(key);
13             System.out.println(key+":"+value);
14         }
15     }

 

 

（五）操作集合的工具类：Collections

Collections 是一个操作 Set、List 和 Map 等集合的工具类
Collections 中提供了大量方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

5.1 排序操作：

• reverse(List)：反转 List 中元素的顺序
• shuffle(List)：对 List 集合元素进行随机排序
• sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
• sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
• swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

5.2 查找、替换

• Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
• Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
• Object min(Collection)
• Object min(Collection，Comparator)
• int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
• boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值

5.3 同步控制

Collections 类中提供了多个 synchronizedXxx()方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题

 代码示例：

 

 1 package collection;
 2 
 3 import org.junit.Test;
 4 
 5 import java.util.*;
 6 
 7 /**
 8  * Created by :Infaraway
 9  * DATE : 2017/3/26
10  * Time : 16:39
11  * Funtion :
12  */
13 public class CollectionsTest {
14 
15     @Test
16     public void testList(){
17         List list = new ArrayList<>();
18         list.add(new Person("AAA",16));
19         list.add(new Person("BBB",13));
20         list.add(new Person("CCC",11));
21         list.add(new Person("DDD",15));
22 
23         for (Object o : list) {
24             System.out.println(o.toString());
25         }
26         //按年龄升序排列
27         //实现Comparator类进行排序操作
28         Collections.sort(list, new Comparator() {
29             @Override
30             public int compare(Object o1, Object o2) {
31                 if (o1 instanceof Person && o2 instanceof Person){
32                     Person p1 = (Person)o1;
33                     Person p2 = (Person)o2;
34                     return p1.getAge() - p2.getAge();
35                 }
36                 throw new ClassCastException("类型转换异常");
37             }
38         });
39 
40         System.out.println();
41         for (Object o : list) {
42             System.out.println(o.toString());
43         }
44 
45 
46         //获取list中最小的元素
47         //要求集合中的元素都实现Compareable接口
48         Set set = new HashSet();
49 
50         set.add(new PersonCompare("AAA",20));
51         set.add(new PersonCompare("BBB",34));
52         set.add(new PersonCompare("CCC",27));
53         set.add(new PersonCompare("DDD",29));
54 
55         for (Object person : set) {
56             System.out.println(person.toString());
57         }
58         System.out.println();
59 
60         Object object = Collections.min(set);
61         System.out.println(object.toString());
62     }
63 
64 }

本文所涉及的代码可以在这里找到： https://git.oschina.net/infaraway/basisJava/tree/master/src/collection