Java集合类详解

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

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

 

（一）Collection接口：

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

 

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

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

package collection;

/**
 * Created by : Zhong
 * DATE : 2017/3/2
 * Time : 23:06
 * Funtion :
 */
public class Person {
    public String name;
    public int age;


    public Person() {

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Person person = (Person) o;

        if (age != person.age) return false;
        return name != null ? name.equals(person.name) : person.name == null;

    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

 

 

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

package collection;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * Created by :Infaraway
 * DATE : 2017/3/26
 * Time : 12:35
 * Funtion :
 */
public class CollectionTest {



    @Test
    public void testTool(){
        Collection collection = new ArrayList();
        Collection collection2 = new ArrayList();
        Person person = new Person("Tom", 22);
        collection.add(person);
        collection.add(new Person("Jerry", 25));
        collection.add(new Person("Mike", 32));
        collection.add("infaraway");

        //1. contains(Object obj)：利用equals方法比较，查看集合中有没有指定元素
        boolean flag = collection.contains(new Person("Mike", 32));
        System.out.println(flag);
        flag = collection.contains(person);
        System.out.println(flag);

        //2. containsAll(Collection coll)利用equals方法比较，查看集合中有没有指定元素的集合
        collection2.add(person);
        collection2.add("infaraway");
        flag = collection.containsAll(collection2);
        System.out.println(flag);

        //3. isEmpty()：检查集合是否为空
        flag = collection.isEmpty();
        System.out.println(flag);

        //4. toArray()转化集合为数组
        Object [] object = collection.toArray();
        System.out.println(object.length);

        //toArray(T[] a)
    }


    /**
     * 1. clear() 清空集合
     * 2. remove() ：移除指定的元素，通过equals() 方法在集合中查找指定的元素
     * 如果元素存在，则移除
     * 3. removeAll(Collection coll) 移除coll中有的元素
     * 4. retainAll(Collection coll) 保存coll中有的元素
     */
    @Test
    public void testRemove(){

        Collection collection = new ArrayList();
        Collection collection2 = new ArrayList();
        Person person = new Person("Tom", 22);
        collection.add(person);
        collection.add(new Person("Jerry", 25));
        collection.add(new Person("Mike", 32));
        collection.add("infaraway");

       /* System.out.println(collection.size());
        collection.remove(person);*/

        System.out.println(collection.size());

        collection2.add(person);
        collection2.add("infaraway");

        collection.removeAll(collection2);
        System.out.println(collection.size());
    }

    /**
     * 在Collection中无法获取指定的元素，但是可以遍历所有的元素
     * 1. 使用增强for循环遍历
     * 2. 使用Iterator迭代器遍历
     *  2.1 获取迭代器对象，调用Collection的iterator方法，获取Iterator接口的实现
     *  2.2 调用Iterator接口方法进行迭代
     */
    @Test
    public void testIterator(){

        Collection collection = new ArrayList();
        Collection collection2 = new ArrayList();
        collection.add("infaraway");

        Person person = new Person("Tom", 22);
        collection.add(person);
        collection.add(new Person("Jerry", 25));
        collection.add(new Person("Mike", 32));

        //使用addAll方法
        collection2.addAll(collection);

       /* System.out.println(collection.size());
        for (Object  o : collection) {
            System.out.println(o);
        }*/

        Iterator it = collection2.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }


    }

    /**
     * add()方法
     */
    @Test
    public void testCollection(){
        Collection collection = new ArrayList();
        collection.add("infaraway");
        collection.add(new Person("Tom", 22));
        collection.add(new Person("Jerry", 25));
        collection.add(new Person("Mike", 32));
    }

}

 

 

（二）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接口代码示例：

package collection;

/**
 * Created by : Zhong
 * DATE : 2017/3/2
 * Time : 23:06
 * Funtion :
 */
public class PersonCompare implements Comparable{
    public String name;
    public int age;
    public PersonCompare() {
    }
    public PersonCompare(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        PersonCompare person = (PersonCompare) o;

        if (age != person.age) return false;
        return name != null ? name.equals(person.name) : person.name == null;

    }
    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

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     }
}

 

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

 

 /**
     * 自然排序情况
     *
     * 默认情况下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 对的插入顺序一致

@Test
    public void testLinkedHashMap(){
        Map map = new LinkedHashMap<>();

        map.put("CC", new Person("CC", 18));
        map.put("AA", new Person("AA", 10));
        map.put("DD", new Person("DD", 12));
        map.put("BB", new Person("BB", 16));

        /*Iterator it = map.keySet().iterator();
        while (it.hasNext()){
            Object key = it.next();
            Object value = map.get(key);
            System.out.println(key+":"+value);
        }
        System.out.println();*/

        for (Object key : map.keySet()){
            Object value = map.get(key);
            System.out.println(key+":"+value);
        }
    }

 

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值也需要具有可比性

   @Test
    public void testTreeMap(){
        Map map = new TreeMap<>();

        //这里使用加入Compareable接口的Person类，这样才可以进行排序
        map.put(new PersonCompare("CC", 18),"CC");
        map.put(new PersonCompare("AA", 10),"AA");
        map.put(new PersonCompare("DD", 12),"DD");
        map.put(new PersonCompare("BB", 16),"BB");

        for (Object key : map.keySet()){
            Object value = map.get(key);
            System.out.println(key+":"+value);
        }
    }

 

 

（五）操作集合的工具类：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()方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题

 代码示例：

 

package collection;

import org.junit.Test;

import java.util.*;

/**
 * Created by :Infaraway
 * DATE : 2017/3/26
 * Time : 16:39
 * Funtion :
 */
public class CollectionsTest {

    @Test
    public void testList(){
        List list = new ArrayList<>();
        list.add(new Person("AAA",16));
        list.add(new Person("BBB",13));
        list.add(new Person("CCC",11));
        list.add(new Person("DDD",15));

        for (Object o : list) {
            System.out.println(o.toString());
        }
        //按年龄升序排列
        //实现Comparator类进行排序操作
        Collections.sort(list, 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("类型转换异常");
            }
        });

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


        //获取list中最小的元素
        //要求集合中的元素都实现Compareable接口
        Set set = new HashSet();

        set.add(new PersonCompare("AAA",20));
        set.add(new PersonCompare("BBB",34));
        set.add(new PersonCompare("CCC",27));
        set.add(new PersonCompare("DDD",29));

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

        Object object = Collections.min(set);
        System.out.println(object.toString());
    }

}

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