java学习笔记 --- 集合

1、定义：集合是一种容器，专门用来存储对象

　　数组和集合的区别?
　　　　  A:长度区别
　　　　　　 数组的长度固定
　　　　　　集合长度可变
　　　　 B:内容不同
　　　　　　 数组存储的是同一种类型的元素
　　　　　　 而集合可以存储不同类型的元素
　　　　 C:元素的数据类型问题 
　　　　　　数组可以存储基本数据类型，也可以存储引用数据类型
　　　　　　集合只能存储引用类型

2、集合的继承体系结构　　
　　　　由于需求不同，Java就提供了不同的集合类。这多个集合类的数据结构不同，但是它们都是要提供存储和遍历功能的，
  　　　　我们把它们的共性不断的向上提取，最终就形成了集合的继承体系结构图。
  
  　　　　　　Collection
   　　　　　　　　|--List
   　　　　　　　　　　　|--ArrayList
   　　　　　　　　　　   |--Vector
   　　　　　　　　　　   |--LinkedList
  　　　　　　　　 |--Set
   　　　　　　　　　　   |--HashSet
   　　　　　　　　　　   |--TreeSet

3、Collection集合：集合体系的顶层接口

　　　　3.1 Collection的功能概述：
　　　　　　1：添加功能
　　　　　　　　boolean add(Object obj):添加一个元素
　　　　　　　　boolean addAll(Collection c):添加一个集合的元素
　　　　　　2:删除功能
　　　　　　　　void clear():移除所有元素
　　　　　　　　boolean remove(Object o):移除一个元素
　　　　　　　　 boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)
　　　　　　3:判断功能
　　　　　　　　  boolean contains(Object o)：判断集合中是否包含指定的元素
　　　　　　　　  boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有)
　　　　　　　　  boolean isEmpty()：判断集合是否为空
　　　　　
　　　　　　4:长度功能
　　　　　　　　 int size():元素的个数
 
　　　　　　5:交集功能
　　　　　　　　 boolean retainAll(Collection c):两个集合都有的元素

　　　　　　6：把集合转换为数组，可以实现集合的遍历
　　　　　　　　 Object[] toArray()

public class CollectionDemo {
    public static void main(String[] args) {
        // 测试不带All的方法

        // 创建集合对象
        // Collection c = new Collection(); //错误，因为接口不能实例化
        Collection c = new ArrayList();

        // boolean add(Object obj):添加一个元素
        // System.out.println("add:"+c.add("hello"));
        c.add("hello");
        c.add("world");
        c.add("java");

        // void clear():移除所有元素
        // c.clear();

        // boolean remove(Object o):移除一个元素
        // System.out.println("remove:" + c.remove("hello"));
        // System.out.println("remove:" + c.remove("javaee"));

        // boolean contains(Object o)：判断集合中是否包含指定的元素
        // System.out.println("contains:"+c.contains("hello"));
        // System.out.println("contains:"+c.contains("android"));

        // boolean isEmpty()：判断集合是否为空
        // System.out.println("isEmpty:"+c.isEmpty());

        //int size():元素的个数
        System.out.println("size:"+c.size());

        System.out.println("c:" + c);
    }
}

public class CollectionDemo2 {
    public static void main(String[] args) {
        // 创建集合1
        Collection c1 = new ArrayList();
        c1.add("abc1");
        c1.add("abc2");
        c1.add("abc3");
        c1.add("abc4");

        // 创建集合2
        Collection c2 = new ArrayList();
//        c2.add("abc1");
//        c2.add("abc2");
//        c2.add("abc3");
//        c2.add("abc4");
        c2.add("abc5");
        c2.add("abc6");
        c2.add("abc7");

        // boolean addAll(Collection c):添加一个集合的元素
        // System.out.println("addAll:" + c1.addAll(c2));

        //boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)
        //只要有一个元素被移除了，就返回true。
        //System.out.println("removeAll:"+c1.removeAll(c2));

        //boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有)
        //只有包含所有的元素，才叫包含
        // System.out.println("containsAll:"+c1.containsAll(c2));

        //boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了，返回的boolean又是什么意思呢?
        //假设有两个集合A，B。
        //A对B做交集，最终的结果保存在A中，B不变。
        //返回值表示的是A是否发生过改变。
        System.out.println("retainAll:"+c1.retainAll(c2));

        System.out.println("c1:" + c1);
        System.out.println("c2:" + c2);
    }
}

/*
 * 集合的遍历。其实就是依次获取集合中的每一个元素。
 *
 * Object[] toArray():把集合转成数组，可以实现集合的遍历
 */
public class CollectionDemo3 {
    public static void main(String[] args) {
        // 创建集合对象
        Collection c = new ArrayList();

        // 添加元素
        c.add("hello"); // Object obj = "hello"; 向上转型
        c.add("world");
        c.add("java");

        // 遍历
        // Object[] toArray():把集合转成数组，可以实现集合的遍历
        Object[] objs = c.toArray();
        for (int x = 0; x < objs.length; x++) {
            // System.out.println(objs[x]);
            // 我知道元素是字符串，我在获取到元素的的同时，还想知道元素的长度。
            // System.out.println(objs[x] + "---" + objs[x].length());
            // 上面的实现不了，原因是Object中没有length()方法
            // 我们要想使用字符串的方法，就必须把元素还原成字符串
            // 向下转型
            String s = (String) objs[x];
            System.out.println(s + "---" + s.length());
        }
    }
}

　　3.2、Iterator iterator():迭代器，集合的专用遍历方式
 　　　　　　Object next():获取元素,并移动到下一个位置。
　　　　　　　　　　　　NoSuchElementException：没有这样的元素，因为你已经找到最后了。
　　　　　　 boolean hasNext():如果仍有元素可以迭代，则返回 true。

public class IteratorDemo {
    public static void main(String[] args) {
        // 创建集合对象
        Collection c = new ArrayList();

        // 创建并添加元素
        // String s = "hello";
        // c.add(s);
        c.add("hello");
        c.add("world");
        c.add("java");

        // Iterator iterator():迭代器，集合的专用遍历方式
        Iterator it = c.iterator(); // 实际返回的肯定是子类对象，这里是多态

        while (it.hasNext()) {
            // System.out.println(it.next());
            String s = (String) it.next();
            System.out.println(s);
        }
    }
}

　　3.3、在使用集合时需要注意一下几点：

　　　　1、集合中存储其实都是对象的地址。

　　　　2、集合中可以存储基本数值吗？不行，但是jdk1.5以后可以这么写，但是存储的还是对象(基本数据类型包装类对象)。

　　　　3、存储时提升了Object。取出时要使用元素的特有内容，必须向下转型。

4、List集合：存储的元素是有序的（存储和取出的元素一致），带索引的，可重复的。
　　　　4.1、List集合的特有功能：
　　　　　　　　A:添加功能
　　　　　　　　　　 void add(int index,Object element):在指定位置添加元素
　　　　　　　　B:获取功能
　　　　　　　　　　 Object get(int index):获取指定位置的元素
　　　　　　　　C:列表迭代器
　　　　　　　　　　ListIterator listIterator()：List集合特有的迭代器
　　　　　　　　D:删除功能
　　　　　　　　　　Object remove(int index)：根据索引删除元素,返回被删除的元素
　　　　　　　　E:修改功能
　　　　　　　　　　 Object set(int index,Object element):根据索引修改元素，返回被修饰的元素　

public class ListDemo {
    public static void main(String[] args) {
        // 创建集合对象
        List list = new ArrayList();

        // 添加元素
        list.add("hello");
        list.add("world");
        list.add("java");

        // void add(int index,Object element):在指定位置添加元素
        // list.add(1, "android");//没有问题
        // IndexOutOfBoundsException
        // list.add(11, "javaee");//有问题
        // list.add(3, "javaee"); //没有问题
        // list.add(4, "javaee"); //有问题

        // Object get(int index):获取指定位置的元素
        // System.out.println("get:" + list.get(1));
        // IndexOutOfBoundsException
        // System.out.println("get:" + list.get(11));

        // Object remove(int index)：根据索引删除元素,返回被删除的元素
        // System.out.println("remove:" + list.remove(1));
        // IndexOutOfBoundsException
        // System.out.println("remove:" + list.remove(11));

        // Object set(int index,Object element):根据索引修改元素，返回被修饰的元素
        System.out.println("set:" + list.set(1, "javaee"));

        System.out.println("list:" + list);
    }
}

/*
 * List集合的特有遍历功能：
 *         size()和get()方法结合使用
 */
public class ListDemo2 {
    public static void main(String[] args) {
        // 创建集合对象
        List list = new ArrayList();

        // 添加元素
        list.add("hello");
        list.add("world");
        list.add("java");

        // Object get(int index):获取指定位置的元素
        // System.out.println(list.get(0));
        // System.out.println(list.get(1));
        // System.out.println(list.get(2));
        // IndexOutOfBoundsException
        // System.out.println(list.get(3));

        // 用循环改进
        // for (int x = 0; x < 3; x++) {
        // System.out.println(list.get(x));
        // }
        // 如果元素过多，数起来就比较麻烦，所以我们使用集合的一个长度功能：size()
        // 最终的遍历方式就是：size()和get()
        for (int x = 0; x < list.size(); x++) {
            // System.out.println(list.get(x));

            String s = (String) list.get(x);
            System.out.println(s);
        }
    }
}

/*
 * 列表迭代器：
 *         ListIterator listIterator()：List集合特有的迭代器
 *         该迭代器继承了Iterator迭代器，所以，就可以直接使用hasNext()和next()方法。
 *
 * 特有功能：
 *         Object previous():获取上一个元素
 *         boolean hasPrevious():判断是否有元素
 *
 *         注意：ListIterator可以实现逆向遍历，但是必须先正向遍历，才能逆向遍历，所以一般无意义，不使用。
 */
public class ListIteratorDemo {
    public static void main(String[] args) {
        // 创建List集合对象
        List list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");

        // ListIterator listIterator()
        ListIterator lit = list.listIterator(); // 子类对象
        // while (lit.hasNext()) {
        // String s = (String) lit.next();
        // System.out.println(s);
        // }
        // System.out.println("-----------------");

        // System.out.println(lit.previous());
        // System.out.println(lit.previous());
        // System.out.println(lit.previous());
        // NoSuchElementException
        // System.out.println(lit.previous());

        while (lit.hasPrevious()) {
            String s = (String) lit.previous();
            System.out.println(s);
        }
        System.out.println("-----------------");

        // 迭代器
        Iterator it = list.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();
            System.out.println(s);
        }
        System.out.println("-----------------");

    }
}

　　　4.2、List的子类特点
　　　　　　 ArrayList:
  　　　　　　　　底层数据结构是数组，查询快，增删慢。
  　　　　　　　　线程不安全，效率高。
 　　　　　　Vector:
  　　　　　　　　底层数据结构是数组，查询快，增删慢。
 　　　　　　　　 线程安全，效率低。
　　　　　　 LinkedList:
　　　　　　　　  底层数据结构是链表，查询慢，增删快。
  　　　　　　　　线程不安全，效率高。
  
 　　　　　　List有三个儿子，我们到底使用谁呢?
  　　　　　　　　看需求(情况)。
  
　　　　　　 要安全吗?
  　　　　　　　　要：Vector(即使要安全，也不用这个了，后面有替代的)
 　　　　　　　　 不要：ArrayList或者LinkedList
  　　　　　　　　查询多：ArrayList
  　　　　　　　　增删多：LinkedList
   
 　　　　　　如果你什么都不懂，就用ArrayList。

　　　4.3、ArrayList集合

　　　　

public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList array = new ArrayList();

        // 创建元素对象，并添加元素
        array.add("hello");
        array.add("world");
        array.add("java");

        // 遍历
        Iterator it = array.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();
            System.out.println(s);
        }

        System.out.println("-----------");

        for (int x = 0; x < array.size(); x++) {
            String s = (String) array.get(x);
            System.out.println(s);
        }
    }
}

　　4.4、Vector集合

　

/*
 * Vector的特有功能：
 * 1：添加功能
 *         public void addElement(Object obj)        相当于add()
 * 2：获取功能
 *         public Object elementAt(int index)        相当于get()
 *         public Enumeration elements()             相当于Iterator iterator()
 *                 boolean hasMoreElements()               hasNext()
 *                 Object nextElement()                    next()
 *
 * JDK升级的原因：
 *         A:安全
 *         B:效率
 *         C:简化书写
 */
public class VectorDemo {
    public static void main(String[] args) {
        // 创建集合对象
        Vector v = new Vector();

        // 添加功能
        v.addElement("hello");
        v.addElement("world");
        v.addElement("java");

        // 遍历
        for (int x = 0; x < v.size(); x++) {
            String s = (String) v.elementAt(x);
            System.out.println(s);
        }

        System.out.println("------------------");

        Enumeration en = v.elements(); // 返回的是实现类的对象
        while (en.hasMoreElements()) {
            String s = (String) en.nextElement();
            System.out.println(s);
        }
    }
}

　　4.5、LinkedList集合

/*
 * LinkedList的特有功能：
 *         A:添加功能
 *             public void addFirst(Object e)给头部添加元素
 *             public void addLast(Object e)给尾部添加元素
 *         B:获取功能
 *             public Object getFirst()获取头部元素
 *             public Obejct getLast()获取尾部元素
 *         C:删除功能
 *             public Object removeFirst()获取头部元素，并删除头部元素
 *             public Object removeLast()获取尾部元素，并删除尾部元素
 */
public class LinkedListDemo {
    public static void main(String[] args) {
        // 创建集合对象
        LinkedList link = new LinkedList();

        // 添加元素
        link.add("hello");
        link.add("world");
        link.add("java");

        // public void addFirst(Object e)
        // link.addFirst("javaee");
        // public void addLast(Object e)
        // link.addLast("android");

        // public Object getFirst()
        // System.out.println("getFirst:" + link.getFirst());
        // public Obejct getLast()
        // System.out.println("getLast:" + link.getLast());

        // public Object removeFirst()
        System.out.println("removeFirst:" + link.removeFirst());
        // public Object removeLast()
        System.out.println("removeLast:" + link.removeLast());

        // 输出对象名
        System.out.println("link:" + link);
    }
}

5、set集合：存储的元素唯一，无序，方法和Collection一致。

/*
 * Collection
 *         |--List
 *             有序(存储顺序和取出顺序一致),可重复
 *         |--Set
 *             无序(存储顺序和取出顺序不一致),唯一
 *
 * HashSet：它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。
 * 注意：虽然Set集合的元素无序，但是，作为集合来说，它肯定有它自己的存储顺序，
 * 而你的顺序恰好和它的存储顺序一致，这代表不了有序，你可以多存储一些数据，就能看到效果。
 */
public class SetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        Set<String> set = new HashSet<String>();

        // 创建并添加元素
        set.add("hello");
        set.add("java");
        set.add("world");
        set.add("java");
        set.add("world");

        // 增强for
        for (String s : set) {
            System.out.println(s);
        }
    }
}

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

注意：　1、什么是哈希表呢？

哈希表底层使用的也是数组机制，数组中也存放对象，而这些对象往数组中存放时的位置比较特殊，当需要把这些对象给数组中存放时，那么会根据这些对象的特有数据结合相应的算法，算法这个对象在数组中的位置，然后把这个对象存放在数组中。而这样的数组就称为哈希数组，即就是哈希表。

　　　　2、保证元素唯一的原理

当给哈希表中存放元素时，需要根据元素的特有数据结合相应的算法，这个算法其实就是Object中的hashCode方法。由于任何对象都是Object类的子类，所以任何对象有拥有这个方法。即就是在给哈希表中存放对象时，会调用对象的hashCode方法，算出对象在表中的存放位置，这里需要注意，如果两个对象hashCode方法算出结果一样，这样现象称为哈希冲突，这时会调用对象的equals方法，比较这两个对象是不是同一个对象，如果equals方法返回的是true，那么就不会把第二个对象存放在哈希表中，如果返回的是false，就会把这个值存放在哈希表中。

总结：保证元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，就必须复写hashCode和equals方法建立属于当前对象的比较方式。

/*
 * HashSet:保证元素唯一的原理
 *        A:底层数据结构是哈希表(是一个元素为链表的数组)
 *        B:哈希表底层依赖两个方法：hashCode()和equals()

 * 步骤：
 *         首先比较哈希值
 *         如果相同，继续走，比较地址值或者走equals()
 *         如果不同,就直接添加到集合中
 * 按照方法的步骤来说：
 *         先看hashCode()值是否相同
 *             相同:继续走equals()方法
 *                 返回true：说明元素重复，就不添加
 *                 返回false：说明元素不重复，就添加到集合
 *             不同：就直接把元素添加到集合
 * 如果类没有重写这两个方法，默认使用的Object()。一般来说不同相同。
 * 而String类重写了hashCode()和equals()方法，所以，它就可以把内容相同的字符串去掉。只留下一个。
 */
public class HashSetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        HashSet<String> hs = new HashSet<String>();

        // 创建并添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");
        hs.add("world");

        // 遍历集合
        for (String s : hs) {
            System.out.println(s);
        }
    }
}

　　　　5.2、TreeSet集合：保证元素唯一，并能够对元素按照某种规则（自然排序和比较器排序）进行排序。

　　注意： 1、如何保证元素唯一性的呢？

　　　　　　使用的对象比较方法的结果是否为0，是0，视为相同元素不存。

　　　　　2、排序原理

　　　　　　A:自然排序(元素具备比较性)
                      让元素所属的类实现自然排序接口 Comparable
　　　　　　B:比较器排序(集合具备比较性)
   　　　　　　  让集合的构造方法接收一个比较器接口的子类对象 Comparator

自然排序：

/*
 * 如果一个类的元素要想能够进行自然排序，就必须实现自然排序接口
 */
public class Student implements Comparable<Student> {
    private String name;
    private int age;

    public Student() {
        super();
    }

    public Student(String name, int age) {
        super();
        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 int compareTo(Student s) {
        // 主要条件 姓名的长度
        int num = this.name.length() - s.name.length();
        // 姓名的长度相同，不代表姓名的内容相同
        int num2 = num == 0 ? this.name.compareTo(s.name) : num;
        // 姓名的长度和内容相同，不代表年龄相同，所以还得继续判断年龄
        int num3 = num2 == 0 ? this.age - s.age : num2;
        return num3;
    }
}

/*
 * TreeSet：能够对元素按照某种规则进行排序。
 * 排序有两种方式
 * A:自然排序
 * B:比较器排序
 *
 * TreeSet集合的特点：排序和唯一
 *
 * 通过观察TreeSet的add()方法，我们知道最终要看TreeMap的put()方法。
 */
public class TreeSetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        // 自然顺序进行排序
        TreeSet<Integer> ts = new TreeSet<Integer>();

        // 创建元素并添加
        // 20,18,23,22,17,24,19,18,24
        ts.add(20);
        ts.add(18);
        ts.add(23);
        ts.add(22);
        ts.add(17);
        ts.add(24);
        ts.add(19);
        ts.add(18);
        ts.add(24);

        // 遍历
        for (Integer i : ts) {
            System.out.println(i);
        }
    }
}

　比较器排序

public class Student {
    private String name;
    private int age;

    public Student() {
        super();
    }

    public Student(String name, int age) {
        super();
        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;
    }
}
/*
 * 需求：请按照姓名的长度排序
 *
 * TreeSet集合保证元素排序和唯一性的原理
 * 唯一性：是根据比较的返回是否是0来决定。
 * 排序：
 *         A:自然排序(元素具备比较性)
 *             让元素所属的类实现自然排序接口 Comparable
 *         B:比较器排序(集合具备比较性)
 *             让集合的构造方法接收一个比较器接口的子类对象 Comparator
 */
public class TreeSetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        // TreeSet<Student> ts = new TreeSet<Student>(); //自然排序
        // public TreeSet(Comparator comparator) //比较器排序
        // TreeSet<Student> ts = new TreeSet<Student>(new MyComparator());

        // 如果一个方法的参数是接口，那么真正要的是接口的实现类的对象
        // 而匿名内部类就可以实现这个东西，匿名内部类和下面的MyComparator效果一样
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                // 姓名长度
                int num = s1.getName().length() - s2.getName().length();
                // 姓名内容
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName())
                        : num;
                // 年龄
                int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
                return num3;
            }
        });

        // 创建元素
        Student s1 = new Student("linqingxia", 27);
        Student s2 = new Student("zhangguorong", 29);
        Student s3 = new Student("wanglihong", 23);
        Student s4 = new Student("linqingxia", 27);
        Student s5 = new Student("liushishi", 22);
        Student s6 = new Student("wuqilong", 40);
        Student s7 = new Student("fengqingy", 22);
        Student s8 = new Student("linqingxia", 29);

        // 添加元素
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        ts.add(s7);
        ts.add(s8);

        // 遍历
        for (Student s : ts) {
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

//或者去掉匿名内部类。增加一个MyComparator类

public class MyComparator implements Comparator<Student> {

@Override
 public int compare(Student s1, Student s2) {
  // int num = this.name.length() - s.name.length();
  // this -- s1
  // s -- s2
  // 姓名长度
  int num = s1.getName().length() - s2.getName().length();
  // 姓名内容
  int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
  // 年龄
  int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
  return num3;
 }

}

　　5.3、LinkedHashSet:HashSet的一个子类，底层数据结构由哈希表和链表组成保证元素的唯一和有序。
 　　　　　　哈希表保证元素的唯一性。
　　　　　　链表保证元素有序。(存储和取出是一致)

/*
 * LinkedHashSet:底层数据结构由哈希表和链表组成。
 * 哈希表保证元素的唯一性。
 * 链表保证元素有序。(存储和取出是一致)
 */
public class LinkedHashSetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        LinkedHashSet<String> hs = new LinkedHashSet<String>();

        // 创建并添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");
        hs.add("world");
        hs.add("java");

        // 遍历
        for (String s : hs) {
            System.out.println(s);
        }
    }
}

6、集合总结

　　Collection
  　　　　|--List 有序,可重复
   　　　　　　　　|--ArrayList
    　　　　　　　　　　底层数据结构是数组，查询快，增删慢。
    　　　　　　　　　　线程不安全，效率高
  　　　　　　　　 |--Vector
    　　　　　　　　　　底层数据结构是数组，查询快，增删慢。
  　　　　　　　　　　  线程安全，效率低
  　　　　　　　　 |--LinkedList
    　　　　　　　　　　底层数据结构是链表，查询慢，增删快。
   　　　　　　　　　　 线程不安全，效率高
  　　　　|--Set 无序,唯一
   　　　　　　　　|--HashSet
   　　　　　　　　　　 底层数据结构是哈希表。
   　　　　　　　　　　 如何保证元素唯一性的呢?
     　　　　　　　　　　　　依赖两个方法：hashCode()和equals()
     　　　　　　　　　　　　开发中自动生成这两个方法即可
    　　　　　　　　　　|--LinkedHashSet
    　　　　　　　　　　　　 底层数据结构是链表和哈希表
     　　　　　　　　　　　　由链表保证元素有序
    　　　　　　　　　　　　 由哈希表保证元素唯一
  　　　　　　　　 |--TreeSet
   　　　　　　　　　　 底层数据结构是红黑树。
    　　　　　　　　　　如何保证元素排序的呢?
    　　　　　　　　　　　　 自然排序
    　　　　　　　　　　　　 比较器排序
   　　　　　　　　 如何保证元素唯一性的呢?
     　　　　　　　　　　根据比较的返回值是否是0来决定

7、针对Collection集合我们到底使用谁呢
　　唯一吗?
 　　　　　　 是：Set
   　　　排序吗?
    　　　　　是：TreeSet
    　　　　　否：HashSet
  　　如果你知道是Set，但是不知道是哪个Set，就用HashSet。
  　　否：List
  　　 　　要安全吗?
   　　　　　 是：Vector
    　　　　　否：ArrayList或者LinkedList
     　　　　　　　　查询多：ArrayList
    　　　　　　　　 增删多：LinkedList
   如果你知道是List，但是不知道是哪个List，就用ArrayList。
 
   如果你知道是Collection集合，但是不知道使用谁，就用ArrayList。
 
   如果你知道用集合，就用ArrayList。
 
8、在集合中常见的数据结构
 　　ArrayXxx:底层数据结构是数组，查询快，增删慢
 　　LinkedXxx:底层数据结构是链表，查询慢，增删快
 　　HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()
　　 TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序