黑马程序员_Java基础：集合总结

一、集合概念

　　相信大家都知道，java是一门面向对象的编程语言，而对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储进行存储，集合就是存储对象最常用的一种方式，我们可以把集合看成是一个容器。

　　同样，数组也是一种容器，那么集合和它有什么不同？

　　1.数组虽然也可以存储对象，但是长度是固定的，而集合长度是可变的。
　　2.数组中可以存储基本数据类型数据，集合只能存储对象。
　　3.数组中储存的基本数据类型数据或对象要类型相同，而集合可以存储不同类型的对象。

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

 

二、集合的构成与分类

下面是一张网上找到的图片，对于集合中的类和接口有比较清晰的表现：

　　1.Collection接口:

　　Collection是最基本的集合接口，一个Collection代表一组对象，即Collection的元素（Elements）。一些 Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java JDK不提供直接继承自Collection的类，Java JDK提供的类都是继承自Collection的”子接口“如List和Set。

　　所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，另一个 Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。其实后一个构造函数就是复制一个Collection。

　　那么如何取出Collection中的元素？无论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代器，使用该迭代器即可逐一访问Collection中每一个元素。典型的用法如下：

　　　　Iterator it = collection.iterator(); // 获得一个迭代器。
　　　　while(it.hasNext()) {    //通过迭代器判断集合中是否还有元素。
　　　　　　Object obj = it.next(); // 得到下一个元素，类型为Object。
　　　　}

　　Collection定义了集合框架的共性功能（方法）：
　　①添加：add(e);  addAll(collection);
　　②删除：remove(e);  removeAll(collection);  clear();
　　③判断：contains(e);  isEmpty();
　　④获取：iterator();  size();
　　⑤获取交集：retainAll();
　　⑥集合变数组：toArray();

　　Collection接口派生的两个接口是List和Set。

 

　　（1）List接口

　　List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。List允许有相同的元素，List集合判断元素是否相同是通过对象的equals()方法。

　　除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个 ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素， 还能向前或向后遍历。

　　实现List接口的常用类有ArrayList，LinkedList，Vector。

 

　　ArrayList类：

　　ArrayList实现了可变大小的数组。它允许所有元素，包括null。

　　每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组（数组结构）的大小。这个容量可随着不断添加新元素而自动增加。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。

　　注意ArrayListList是非同步的，如果多个线程同时访问一个ArrayList实例，而其中至少一个线程从结构上修改了该列表，则它必须保持外部同步。一种解决方法是在创建ArrayList时构造一个同步的List来包装它：　

    List list = Collections.synchronizedList(new ArrayList(...));  

　　数组结构（每个元素都有角标）：

 

　　LinkedList类：

　　LinkedList实现了List接口，存储数据的方式是双链表，允许null元素。此外LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。

　　注意LinkedList是非同步的，如果多个线程同时访问一个链接列表，而其中至少一个线程从结构上修改了该列表，则它必须保持外部同步。一种解决方法是在创建LinkedList时构造一个同步的List来包装它：

　　List list = Collections.synchronizedList(new LinkedList(...));

　　双链表结构（每个元素只知道前后的元素）：

　　Arraylist和Linkedlist的不同处：
　　①ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
　　②对于随机访问get和set，ArrayList优于LinkedList，因为LinkedList要移动指针。
　　③对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

 

　　Vector类：

　　Vector非常类似ArrayList，也是数组结构存储数据，但是Vector是同步的。由Vector创建的Iterator，虽然和 ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了 Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出 ConcurrentModificationException，因此必须捕获该异常。同样，当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。另外，Vector还有特有的取出元素的方式，通过它的elements()获取Enumeration枚举来得到元素，实际上Enumeration和Iterator功能是一样的。

　　Vector与ArrayList不同之处是：
　　①Vector是线程同步的，所以它也是线程安全的，而Arraylist是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用arraylist效率比较高。
　　②如果集合中的元素的数目大于目前集合数组的长度时，vector增长率为目前数组长度的100%,而arraylist增长率为目前数组长度的50%.如过在集合中使用数据量比较大的数据，用vector有一定的优势。
　　③Vector还有特有的取出元素的方式，Enumeration枚举。

 

　　（2）Set接口　　

　　Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。

　　另外要注意，必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object1.equals(Object2)=true将导致一些问题。

　　实现Set接口的常用类有HashSet和TreeSet。

 

　　HashSet类：

　　Hashset存储数据的结构是哈希表，它不保证 set 的迭代顺序，特别是它不保证该顺序恒久不变。也就是说，HashSet中的元素是无序的。它是通过元素的hashCode()和equals()方法来保证元素的唯一性。如果元素的hashCode值不同，则不需调用equals()进行比较。如果元素的HashCode值相同，才会调用equals()判断两个元素是否相同。基于这种唯一性标准，HashSet中判断元素是否存在，以及删除等操作，依赖的方法也是元素的hashCode()和equals()方法。

　　注意HashSet是非同步的，如果多个线程同时访问一个HashSet，而其中至少一个线程修改了该 set，那么它必须 保持外部同步。一种解决方法是在创建HashSet时构造一个同步的Set来包装它：

    Set s = Collections.synchronizedSet(new HashSet(...));

　　哈希表结构（当元素比较hashCode不同时，元素处于不同区域；当元素比较hashCode相同，equals比较不同时，元素会在同个区域）：

 

　　TreeSet类：

　　TreeSet存储数据的结果是二叉树（红黑树），基于实现NavigableSet接口，它是使用元素的自然顺序对元素进行排序（当元素自身具有比较性时），或者根据创建 set 时提供的 Comparator进行排序（当元素自身不具备比较性，或者比较性不合需求时），具体取决于使用的构造方法。也就是说，TreeSet中的元素是有序的。它是通过元素的compareTo()或者构造时使用的比较器Comparator中的compare()方法来保证元素的唯一性。

　　注意TreeSet是非同步的，如果多个线程同时访问一个TreeSet，而其中至少一个线程修改了该 set，那么它必须 外部同步。一种解决方法是在创建TreeSet时构造一个同步的Set来包装它：

    SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...)); 

　　二叉树结构（比较后，小的元素在左子树，大的元素在右子树）：

　　

 

　　2.Map接口

　　Map没有继承Collection接口，Map提供key（键）到value（值）的映射。一个Map中不能包含相同的key，每个key只能映射一个 value。Map接口提供3种集合的视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容。映射顺序定义为迭代器在映射的 collection 视图上返回其元素的顺序。某些映射实现可明确保证其顺序，如 TreeMap 类；另一些映射实现则不保证顺序，如 HashMap 类。Map集合没有直接取出元素的方法，想获取Map集合中的元素，需要先用entrySet()方法获取键-值映射关系的Set集合，或者使用keySet()方法获取键的Set集合。

　　Map集合的共性功能（方法）：
　　①添加：put(K key, V value);  putAll(Map<? extends K,? extends V> m);
　　②删除: remove(Object key);  clear();
　　③判断:containsValue(Object value);  containsKey(Object key);  isEmpty();
　　④获取：get(Object key);  size();  values();  entrySet();  keySet();

　　实现Map接口的常用类有HashMap，TreeMap。

 

　　HashMap类：

　　基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用null键和null值（替代Hashtable）。其键集上的对象是通过元素的hashCode()和equals()方法来保证元素的唯一性。如果元素的hashCode值不同，则不需调用equals()进行比较。如果元素的HashCode值相同，才会调用equals()判断两个元素是否相同。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

　　注意HashMap是非同步的，如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。一种解决方法是在创建HashMap时构造一个同步的Map来包装它：

   Map m = Collections.synchronizedMap(new HashMap(...));

 

　　TreeMap类：

　　基于二叉树的 Map 接口的实现。它所包含的映射关系是有序的（以键为标准），其键的排序方式和TreeSet中的元素相同。

　　注意TreeMap是非同步的，如果多个线程同时访问一个映射，并且其中至少一个线程从结构上修改了该映射，则其必须外部同步。一种解决方法是在创建TreeMap时构造一个同步的Map来包装它：

    SortedMap m = Collections.synchronizedSortedMap(new TreeMap(...));

 

三、集合的应用

1.例子一（将自定义对象作为元素存到ArrayList集合中，并去除重复元素）：

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

/*
将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。

思路：
1，对人描述，将数据封装进人对象。
2，定义容器，将人存入。
3，取出。

List集合判断元素是否相同，依据是元素的equals方法。
*/
class Person {
    private String name;
    private int age;
    Person(String name,int age) {
        this.name = name;
        this.age = age;
    }
    
    public boolean equals(Object obj) {
        if(!(obj instanceof Person))
            return false;
        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
}

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<Person> al = new ArrayList<Person>();        //使用泛型指定集合元素类型。

        al.add(new Person("lisi01",30));
        al.add(new Person("lisi02",32));
        al.add(new Person("lisi02",32));
        al.add(new Person("lisi04",35));
        al.add(new Person("lisi03",33));
        al.add(new Person("lisi04",35));
        
        al = singleElement(al);
        System.out.println("remove 03 :"+al.remove(new Person("lisi03",33)));//remove方法底层也是依赖于元素的equals方法。

        Iterator<Person> it = al.iterator();
        while(it.hasNext()) {    //判断集合中是否还有元素。
            Person p = it.next();
            System.out.println(p.getName()+"::"+p.getAge());
        }
    }

//    去掉重复元素。
    public static ArrayList<Person> singleElement(ArrayList<Person> al) {
        //定义一个临时容器。
        ArrayList<Person> newAl = new ArrayList<Person>();
        Iterator<Person> it = al.iterator();
        while(it.hasNext()) {
            Person p = it.next();

            if(!newAl.contains(p))
                newAl.add(p);
        }
        return newAl;
    }
}

运行结果为：

remove 03 :true
lisi01::30
lisi02::32
lisi04::35

 

2.例子二（使用LinkList模拟一个堆栈或者队列数据结构）：

import java.util.LinkedList;

/*
使用LinkList模拟一个堆栈或者队列数据结构。

堆栈：先进后出，如同一个杯子。
队列：先进先出，如同一个水管。
 */
class DuiLie {
    private LinkedList link;
    private LinkedList link_2;
    
    DuiLie() {
        link = new LinkedList();
        link_2 = new LinkedList();
    }

    public void myAdd(Object obj) {
        link.addFirst(obj);
        link_2.addFirst(obj);
    }

    public Object myGet() {
        return link.removeFirst();        
    }

    public Object myGet_2() {
        return link.removeLast();
    }

    public boolean isNull() {
        if (link.isEmpty()) {
            try {
                return link.isEmpty();
            }
            finally {
                link.addAll(link_2);
            }
        }
        return link.isEmpty();                
    }
}


public class LinkedListTest {
    public static void main(String[] args) {
        DuiLie dl = new DuiLie();

        dl.myAdd("java01");
        dl.myAdd("java02");
        dl.myAdd("java03");
        dl.myAdd("java04");
        
        //堆栈形式；先进后出
        while (!dl.isNull())
            System.out.println(dl.myGet());
        System.out.println();

        //队列形式：先进先出
        while (!dl.isNull())
            System.out.println(dl.myGet_2());
    }
}

运行结果为：

java04
java03
java02
java01

java01
java02
java03
java04

 

3.例子三（Vector枚举）：

import java.util.Enumeration;
import java.util.Vector;

/*
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的。

因为枚举的名称以及方法的名称都过长。
所以被迭代器取代了。
*/
public class VectorDemo {
    public static void main(String[] args) {
        Vector<String> v = new Vector<String>();

        v.add("java01");
        v.add("java02");
        v.add("java03");
        v.add("java04");

        Enumeration<String> en = v.elements();
        while(en.hasMoreElements()) {    //判断集合中是否还有元素。
            System.out.println(en.nextElement());
        }
    }
}

运行结果为：

java01
java02
java03
java04

4.例子四（往HashSet集合中存入自定义对象）：

import java.util.HashSet;
import java.util.Iterator;

/*
往HashSet集合中存入自定义对象。
以人为例：
姓名和年龄相同视为同一个人，重复元素。
*/
public class HashSetTest {
    public static void main(String[] args) {
        HashSet<Person> hs = new HashSet<Person>();

        hs.add(new Person("a1",11));
        hs.add(new Person("a2",12));
        hs.add(new Person("a3",13));
        hs.add(new Person("a2",12));
//        查看是否包含指定元素。
        System.out.println("a1:"+hs.contains(new Person("a2",12)));
//        删除一个元素。
        System.out.println(hs.remove(new Person("a3",13)));

        Iterator<Person> it = hs.iterator();
        while (it.hasNext()) {
            Person p = it.next();
            System.out.println(p.getName()+"..."+p.getAge());
        }
    }
}


class Person {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public int hashCode() {
        return name.hashCode()+age*39;
    }

    public boolean equals(Object obj) {
        if (!(obj instanceof Person))
            return false;
        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;
    }
}

运行结果为：

a1:true
true
a2...12
a1...11

 

5.例子五（使用TreeSet添加字符串，字符串按长度排序）：

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/*
按照字符串长度排序。

字符串本身具备比较性，但是它的比较方式不是所需要的。
这时只能使用比较器。
 */
public class TreeSetTest {
    public static void main(String[] args) {
//        元素本身的比较性不合需求，构造时加上比较器。
        TreeSet<String> ts = new TreeSet<String>(new StrLenCompare());

        ts.add("abcd");
        ts.add("cc");
        ts.add("cba");
        ts.add("aaa");
        ts.add("z");
        ts.add("hahaha");

        Iterator<String> it = ts.iterator();
        while (it.hasNext())
        {
            String s = (String)it.next();
            System.out.println(s+"...length..."+s.length());
        }
    }
}

//比较器比较内容。
class StrLenCompare implements Comparator<String> {
    public int compare(String s1,String s2) {
        int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
        if (num==0)
            return s1.compareTo(s2);
        return num;
    }
}

运行结果为：

z...length...1
cc...length...2
aaa...length...3
cba...length...3
abcd...length...4
hahaha...length...6

 

6.例子六（使用HashMap添加不重复的元素（映射关系））：

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
每一个学生都与对应的归属地。
学生Student，地址String。
学生属性：姓名，年龄。
注意：姓名和年龄相同的视为同一个学生。
保证学生的唯一性。

思路：
1，描述学生。
2，因为学生和地址存在映射关系。定义Map容器，将学生作为键，地址作为值存入。
3，获取Map集合中的元素。
*/
class Student implements Comparable<Student> {
    private String name;
    private int age;
    Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public int compareTo(Student s) {
        int num = new Integer(this.age).compareTo(new Integer(s.age));
        if (num==0) {
            return this.name.compareTo(s.name);
        }
        return num;
    }

    public int hashCode() {
        return this.name.hashCode()+this.age*34;
    }

    public boolean equals(Object obj) {    //这里重写的是父类Object的equals方法，参数类型必须Object，否则重写失败。
        if(!(obj instanceof Student))
            throw new ClassCastException("类型不匹配");
        Student s = (Student)obj;
        return this.name.equals(s.name) && this.age==s.age;
    }    

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;    
    }

    public String toString() {
        return name+":::"+age;
    }
}


public class HashMapTest {
    public static void main(String[] args) {
        HashMap<Student,String> hm = new HashMap<Student,String>();

        hm.put(new Student("lisi1",21),"beijing");
        hm.put(new Student("lisi1",21),"tianjin");
        hm.put(new Student("lisi2",22),"shanghai");
        hm.put(new Student("lisi3",23),"nanjing");
        hm.put(new Student("lisi4",24),"wuhan");

        //第一种取出方式：keySet
        Set<Student> keySet = hm.keySet();
        Iterator<Student> it = keySet.iterator();

        while (it.hasNext()) {
            Student s = it.next();
            String addr = hm.get(s);
            System.out.println(s+"..."+addr);
        }
        System.out.println();
        
/*        //第二种取出方式：entrySet
        Set<Map.Entry<Student,String>> entrySet = hm.entrySet();
        Iterator<Map.Entry<Student,String>> iter = entrySet.iterator();

        while (iter.hasNext()) {
            Map.Entry<Student,String> me = iter.next();
            Student s = me.getKey();
            String addr = me.getValue();
            System.out.println(s+"....."+addr);
        }*/
    }
}

运行结果为：

lisi3:::23...nanjing
lisi1:::21...tianjin
lisi2:::22...shanghai
lisi4:::24...wuhan

7.例子七（使用TreeMap添加有序的元素（映射关系））：

import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/*
需求：每一个学生都与对应的归属地。
学生Student，地址String。
学生属性：姓名，年龄。
对学生对象的年龄进行升序排序。

因为数据是以键值对形式存在的。
所以要是哟昂可以排序的Map集合，TreeMap。
*/
class StuNameComparator implements Comparator<Student> {
    public int compare(Student s1,Student s2) {
        int num = s1.getName().compareTo(s2.getName());
        if (num==0)
            return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
        return num;
    }
}

public class TreeMapTest {
    public static void main(String[] args) {
        //因为Student本身定义有比较性，可以直接满足需求。如果是按姓名排序，则需要加上StuNameComparator比较器。
        TreeMap<Student,String> tm = new TreeMap<Student,String>(/*new StuNameComparator()*/);

        tm.put(new Student("blisi3",23),"nanjing");
        tm.put(new Student("lisi1",21),"beijing");
        tm.put(new Student("alisi14",24),"wuhan");
        tm.put(new Student("lisi1",21),"tianjin");
        tm.put(new Student("alisi11",21),"tianjin");
        tm.put(new Student("alisi12",22),"shanghai");

        Set<Map.Entry<Student,String>> entrySet = tm.entrySet();
        Iterator<Map.Entry<Student,String>> it = entrySet.iterator();
        while (it.hasNext()) {
            Map.Entry<Student,String> me = it.next();
            Student s = me.getKey();
            String addr = me.getValue();
            System.out.println(s+"..."+addr);
        }
    }
}


class Student implements Comparable<Student> {
    private String name;
    private int age;
    Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public int compareTo(Student s) {
        int num = new Integer(this.age).compareTo(new Integer(s.age));
        if (num == 0) {
            return this.name.compareTo(s.name);
        }
        return num;
    }

    public int hashCode() {
        return this.name.hashCode()+this.age*34;
    }

    public boolean equals(Object obj) {
        if(!(obj instanceof Student))
            throw new ClassCastException("类型错误");
        Student s = (Student)obj;
        return s.name.equals(this.name) && this.age == s.age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String toString() {
        return name+":::"+age;
    }
}

运行结果为：

alisi11:::21...tianjin
lisi1:::21...tianjin
alisi12:::22...shanghai
blisi3:::23...nanjing
alisi14:::24...wuhan

 

四、总结

　　如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。
　　如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类或者在类意外加上同步。
　　要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。
　　尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。