Java基础(十一)——集合框架与泛型

1，集合概述

        为了保存数量不确定的数据，以及保存具有映射关系的数据，Java提供了集合类，集合类主要保存、盛装其它数据（集合里只能保存对象，实际上保存的是对象的引用变量），因此集合类也被称为容器类。Java的集合类主要由两个接口派生而出：Collection和Map，Collection和Map是Java集合框架的根接口，这两个接口又包含了一些子接口或实现类，所有的集合类都位于java.util包下。

2，Collection
      Collection接口是List、Set和Queue接口的父接口，该接口里定义了List、Set和Queue的共性方法，必须要掌握。
2.1， boolean add(Object o):用于向集合中添加元素，如果集合对象被添加操作改变了，则返回true。
2.2， boolean addAll(Collection c)：将集合c里的所有元素添加到指定的集合里，如果集合被添加操作改变了，返回true。
2.3， void clear()：清除集合里的所有元素。
2.4， bolean contains(Object o)：返回集合里是否包含指定元素。
2.5， boolean containsAll(Collection c)：返回集合里是否含集合c里的所有元素。
2.6， boolean isEmpty()：返回集合是否为空。当集合长度为0时，返回true；否则返回false。
2.7， Iterator iterator()：返回一个Iterator对象，用于遍历集合里的元素。
2.8， boolean remove(Object o)：删除集合中指定元素o，当集合中包含了一个或多个元素o时，全部删除，返回true。
2.9， boolean removeAll(Collection c)：从该集合中删除集合c里包含的元素，删除一个或一个以上元素，返回true。
2.10， boolean retainAll(Collection c)：从该集合中删除集合c里不包含的元素，取交集，操作改变了该集合，返回true。
2.11， int size()：返回集合里元素的个数，即集合的长度。
2.12， Object[] toArray()：该方法把集合转换成一个数组，所有集合元素变成对应的数组。

3，遍历集合中的元素
3.1，迭代器，使用Iterator接口遍历集合元素
        集合中的对象如何取出，只有集合自己最清楚，每一集合类，都具备一个方法 iterator()这个方法，将返回一个迭代器对象，用迭代器对象，取出集合中的对象,迭代器具有如下三个方法：
boolean hasNext()：如果被迭代的集合元素还没有被遍历，则返回true。
Object next()：返回集合里下一个元素。
 void remove()：删除集合里上一次next方法返回的元素。
演示代码：

import java.util.*;
public class IteratorDemo {
    public static void main(String[] args) {
        ArrayList al = new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        /*
         * Iterator it = al.iterator(); //获取迭代器，用于取出集合中的元素
         * while(it.hasNext()) {
         * System.out.println(it.next());
         *  }
         */
        for (Iterator it = al.iterator(); it.hasNext();) {
            System.out.println(it.next());
        }
        //一般情况下认为for循环方式比while方式要优越一点，因为for循环中，Iterator变量it在局部变量中，
        //for结束，it就不存在了，内存稍稍优化一点，而while那种方式，it一直存在到方法结束，不好
    }
}

4，List集合（ArrayList、LinkedList、Vector）
4.1，特点：List集合里存储的元素都是有索引的，并且是有序的，元素之间可以重复
4.2，List的特有方法：凡是可以操作索引的方法都是该体系的特有方法。
     boolean add(index,element):向指定的位置添加指定的元素
     boolean addAll(index,Collection)：向指定的位置开始，添加多个元素
     boolean remove()：移除元素（还有各种重载版本）
     E set(index,element):将指定位置的元素修改为element
     E get(index)：由索引获取该位置上的元素
     List subList(from,to)：截取子List，从from开始到to结束，包含头，不含尾
     ListIterator listIterator()：List集合特有的迭代器

4.3，List集合特有迭代器，ListIterator是Iterator的子接口。
    在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生不安全的异常。 所以用Iterator迭代时，只能对元素进行判断、取出、删除的操作，如果想要对其操作如添加、修改等，就需要ListIterator。

常用方法：
     void add(E e)：将指定的元素插入列表（可选操作）。
     boolean hasNext()：以正向遍历列表时，如果列表迭代器有多个元素，则返回 true。
     boolean hasPrevious()：如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
     E next()：返回列表中的下一个元素。
     int nextIndex()：返回对 next 的后续调用所返回元素的索引。
     E previous()：返回列表中的前一个元素。
     int previousIndex()：返回对 previous 的后续调用所返回元素的索引。
     void remove()：从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。
     void set(E e)：用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。

4.4,ArrayList:底层的数据结构使用的是数组结构。 特点：查询速度很快，增删稍慢。线程不同步。

4.5,LinkedList:底层数据结构使用的是链表结构。 特点：增删速度很快，查询很慢。

部分常用特有方法：

                       void addFirst(E e)：将指定元素插入此列表的开头。
                       void addLast(E e)：将指定元素添加到此列表的结尾。
                获取元素，如果集合中没有元素，会出现NoSuchElementException：
                      E getFirst()：返回此列表的第一个元素。获取元素，不删除元素。
                      E getLast()：返回此列表的最后一个元素。
                      E removeFirst()：移除并返回此列表的第一个元素。获取元素，但是删除元素。
                      E removeLast()：移除并返回此列表的最后一个元素。
                获取元素，如果集合中没有元素，返回null。JDK1.6新特性，替代以上旧的方法。
                      E peekFirst()：获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
                      E peekLast()：获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
                      E pollFirst()：获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
                      E pollLast()：获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
                      boolean offerFirst(E e)：在此列表的开头插入指定的元素。
                      boolean offerLast(E e)：在此列表末尾插入指定的元素。

4.6,Vector:底层数据结构使用的是数组结构。线程同步。JDK1.0出现，线程同步，后来被ArrayList替代了。
       Vector有个特有的枚举类型的方法：Enumeration<E> elements()：返回此向量的组件的枚举。
       注：Enumration<E>接口的功能与 Iterator 接口的功能是重复的。此外，Iterator 接口添加了一个可选的移除操作，并使用较短的方法名。
       新的实现应该优先考虑使用 Iterator 接口而不是 Enumeration 接口。

5，Set集合（常用HashSet、TreeSet）
5.1，特点：元素是无序的（存入与取出的顺序不一定一致），元素不可以重复，没有索引。Set集合的功能和Collection是一致的。

5.2，HashSet：（1）可以存储null这个元素（2）底层数据结构是哈希表(桶子结构)（3）线程不安全的
                （4）HashSet是如何保证元素的唯一性的呢？是通过元素的两个方法，hashCode()和equals()来完成的。
                如果HashCode值不同，则不会调用equals方法。内存开辟两个空间，存储这两个对象。
                如果元素的HashCode值相同，才会去判断equals是否为true。当equals返回假，挂靠在桶子里。当equals返回真，判断同一对象，不存储。
                所以，在使用HashSet的时候，不关注这个集合，关注的是集合中存储的对象，这个对象必须覆盖hashCode()equals()方法，才能保证集合中的对象是唯一的。

5.3，TreeSet：对Set集合中的元素的进行指定顺序的排序。线程不同步。TreeSet底层的数据结构就是二叉树。
       （1）用于对TreeSet集合进行元素的指定顺序排序，排序需要依据元素自身具备的比较性。如果元素不具备比较性，在运行时会发生ClassCastException异常。
所以需要元素实现Comparable接口，强制让元素具备比较性，复写compareTo方法。依据compareTo方法的返回值，确定元素在TreeSet数据结构中的位置。
TreeSet方法保证元素唯一性的方式：就是参考比较方法的结果是否为0，如果return 0，视为两个对象重复，不存。
       注意：在进行比较时，如果判断元素不唯一，比如，同姓名，同年龄，才视为同一个人。
       在判断时，需要分主要条件和次要条件，当主要条件相同时，再判断次要条件，按照次要条件排序。
      （2）TreeSet集合排序有两种方式，Comparable和Comparator区别：
      1：让元素自身具备比较性，需要元素对象实现Comparable接口，覆盖compareTo方法。
      2：让集合自身具备比较性，需要定义一个实现了Comparator接口的比较器，并覆盖compare方法，并将该类对象作为实际参数传递给TreeSet集合的构造函数。
      第二种方式较为灵活。
第一种：实现Comparable接口，覆盖compareTo()方法，使元素自身具有比较性：

/*
需求：
往TreeSet集合中存储自定义对象学生。想按照学生的年龄进行排序。
记住，排序时，当主要条件相同时，一定要判断一下次要条件。
*/
import java.util.*;
class TreeSetDemo
{
    public static void main(String[] args)
    {
        TreeSet ts = new TreeSet();
        ts.add(new Student("lisi02",22));
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi09",19));
        ts.add(new Student("lisi01",19));
        
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            Student stu = (Student)it.next();
            System.out.println(stu.getName()+"..."+stu.getAge());
        }
    }
}
class Student implements Comparable //该接口强制让学生具备比较性
{
    private String name;
    private int age;

    Student(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public int compareTo(Object obj)
    {
        if(!(obj instanceof Student))
            throw new RuntimeException("不是学生对象");
        Student s = (Student)obj;
        System.out.println(this.name+"...compareTo..."+s.name);

        if(this.age > s.age)
            return 1;
        if(this.age == s.age)
            return this.name.compareTo(s.name);   //当age值相同时，要按照name值进行排序
        return -1;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}

第二种：实现Comparator接口，覆盖compare()方法，使得集合自身具有比较性：

/*
当元素自身不具备比较性，或者具备的比较性不是所需要的。
这时就让容器自身具备比较性，定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
当两种排序都存在时，以比较器为主。
定义一个类，实现Comparator接口，覆盖compare方法。
*/
import java.util.*;
class Student implements Comparable //该接口强制让学生具备比较性
{
    private String name;
    private int age;

    Student(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public int compareTo(Object obj)
    {
        if(!(obj instanceof Student))
            throw new RuntimeException("不是学生对象");
        Student s = (Student)obj;

        if(this.age > s.age)
            return 1;
        if(this.age == s.age)
            return this.name.compareTo(s.name);   //当age值相同时，要按照name值进行排序
        return -1;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}
class MyCompare implements Comparator
{
    public int compare(Object o1,Object o2)
    {
        Student s1 = (Student)o1;
        Student s2 = (Student)o2;
        int num = s1.getName().compareTo(s2.getName());
        if(num==0)
        {
            return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
        }
        return num;
    }
}
class TreeSetDemo2
{
    public static void main(String[] args)
    {
        TreeSet ts = new TreeSet(new MyCompare());
        ts.add(new Student("lisi02",22));
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi09",19));
        ts.add(new Student("lisi01",18));
        ts.add(new Student("lisi007",17));
        
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            Student stu = (Student)it.next();
            System.out.println(stu.getName()+"..."+stu.getAge());
        }
    }
}

6，泛型：JDK1.5版本以后出现的新特性，用于解决安全问题，是一个类型安全机制。表现格式：<>
6.1，好处：
1：将运行时期的问题ClassCastException问题转换成了编译失败，体现在编译时期，程序员就可以解决问题。
2：避免了强制转换的麻烦。
6.2,泛型技术：其实应用在编译时期，是给编译器使用的技术，到了运行时期，泛型就不存在了。为什么?
           因为泛型的擦除：也就是说，编辑器检查了泛型的类型正确后，在生成的类文件中是没有泛型的。
           在运行时，如何知道获取的元素类型而不用强转呢？
           泛型的补偿：因为存储的时候，类型已经确定了是同一个类型的元素，所以在运行时，只要获取到该元素的类型，在内部进行一次转换即可，所以使用者不用再做转换动作了。
          什么时候用泛型类呢？
          当类中的操作的引用数据类型不确定的时候，以前用的Object来进行扩展的，现在可以用泛型来表示。这样可以避免强转的麻烦，
          而且将运行问题转移到的编译时期。

6.3,泛型类：
什么时候定义泛型类？当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，现在来定义泛型来完成扩展。

class Utils<QQ>{
    private QQ q;
    public void setObject(QQ q){
        this.q = q;
    }
    public QQ getObject(){
        return q;
    }
}

6.4，泛型方法
（1）当方法操作的引用数据类型不确定的时候，可以将泛型定义在方法上。

public <W> void method(W w) {
System.out.println("method:"+w);
}

（2）静态方法上的泛型：静态方法无法访问类上定义的泛型。如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

public static <Q> void function(Q t) {
System.out.println("function:"+t);
}

6.5，泛型接口

interface Inter<T> {
void show(T t);
}
class InterImpl<R> implements Inter<R> {
public void show(R r) {
System.out.println("show:"+r);
}
}

6.6，泛型限定
（1）泛型中的通配符：可以解决当具体类型不确定的时候，这个通配符就是 ?  ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。
（2）泛型限定：
    上限：？extends E：可以接收E类型或者E的子类型对象。
    下限：？super E：可以接收E类型或者E的父类型对象。
上限什么时候用：往集合中添加元素时，既可以添加E类型对象，又可以添加E的子类型对象。为什么？因为取的时候，E类型既可以接收E类对象，又可以接收E的子类型对象。
下限什么时候用：当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。

7，Map集合（常用HashMap、TreeMap）
特点：该集合存储键值对，一对一对往里存，而且要保证键的唯一性，不允许出现重复。
7.1，Map的常用方法：
（1）添加。
       put(K key, V value)：将键值存储到集合，put方法的返回值，一般情况下是null，但是如果存储了重复的键，替换原来老键的值，put方法的返回值就是被替换后的值
       putAll(Map<? extends K,? extends V> m)：存储一批键值
（2）删除。
       void clear()：删除所有键值
       V remove(Object key)：根据键删除键值，若键存在，删除该键且返回值，若键不存在，返回null
（3）判断。
       boolean containsKey(Object key)：判断该集合中是否有这个键
       boolean containsValue(Object value)：判断该集合中是否有这个值
       boolean isEmpty()：判断集中中是否有键值
（4）获取。
       V get(Object key)：通过键获取值，若键存在，删除该键且返回值，若键不存在，返回null
       int size()：获取集合中键值对的数量
       Collection<V> values()：以集合的方式返回集合中包含的值
       Set<Map.Entry<K,V>> entrySet()：这个方法返回的是键值映射关系对，存储到Set集合中
       Set<K> keySet()：返回此映射中包含的键的 Set 视图

7.2，Hashtable:底层是哈希表数据结构，不可以存入null键和null值。该集合是线程同步的。jdk1.0。效率低。
7.3，HashMap：底层是哈希表数据结构，可以存入null键和null值。该集合是线程不同步的。jdk1.2。效率高。
7.4，TreeMap：底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。

7.5，Map集合元素的取出方式
7.5.1，Set<K> keySet：将Map中所有的键存入到Set集合，是因为Set具备迭代器。所以可以迭代方式取出所有的键，再根据get方法获取每一个键对应的值。
       Map集合取出的原理：将Map集合转成Set集合，再通过迭代器取出。

7.5.2，Set<Map.Entry<K,V>> entrySet:将Map集合中的映射关系存入到Set集合中，而这个关系的数据类型就是：Map.Entry

class MapDemo
{
    public static void main(String[] args)
    {
        Map<String,String> map = new HashMap<String,String>();
        map.put("02","zhangsan02");
        map.put("03","zhangsan03");
        map.put("01","zhangsan01");
        map.put("04","zhangsan04");    
        //将Map集合的映射关系取出，存入到Set集合中。
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        Iterator<Map.Entry<String,String>> it = entrySet.iterator();
        while(it.hasNext())
        {
            Map.Entry<String,String> me = it.next();
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key+"::"+value);
        }

        /*
        //先获取map集合的所有键的Set集合，keySet()
        Set<String> keySet = map.keySet();
        //有了Set集合，就可以获取其迭代器
        Iterator<String> it = keySet.iterator();
        while(it.hasNext())
        {
            String key = it.next();
            //有了键就可以通过map集合的get方法获取对应的值
            String value = map.get(key);
            System.out.println("key："+key+", value: "+value);
        }
        */
    }
}

运行结果：

8，Collections工具类
操作Collection集合的工具类，方法全部是静态的
常用方法：
     void Collections.sort(List<T> list)：对list集合升序排序
     void Collections.sort(List<T> list, Comparator<? super T> c)：对list集合按照指定比较器升序排序
     void Collections.swap(List<?> list, int i, int j)：对List集合的指定索引位置进行位置的互换
     void Collections.shuffle(List<?> list)：对List集合中的对象，进行随机排列
     void Collections.reverse(List<?> list)：对List集合进行反转
     void Collections.fill(list,Object obj)：替换list集合中的所有元素
     int Collections.binarySearch(list,Object obj)：对list集合进行二分搜索法，返回索引，找不到指定的元素，返回 -(插入点-1)
     Comparator<T> Collections.reverseOrder()：返回一个比较器，逆转了Compatable中的自然顺序
     Comparator<T> Collections.reverseOrder(Comparator c)：返回一个比较器，逆转了Comparator中的顺序

9，Collection接口的中的方法
     <T> T[] toArray(T[] a)：返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
（1）指定类型的数组到底要定义多长呢？
     当指定类型的数组长度小于集合的size，那么该方法内部会创建一个新的数组，长度为集合的size。
     当指定类型的数组长度大于集合的size，就不会新创建数组，而是使用传递进来的数组。
     所以创建一个长度刚刚好的数组最优。String[] arr = al.toArray(new String[al.size()]);

（2）为什么要将集合变数组？
    为了限定对元素的操作，不需要进行增删了。

10，Arrays工具类
用于操作数组的工具类。里面都是静态方法。
    void Arrays.sort(数组)：对数组进行升序排序
    int Arrays.binarySerach(数组，搜索)：对数组进行折半查找，返回-(插入点-1),保证数组有序
    List<T> Arrays.asList(数组)：将数组转成List集合，不允许改变集合的长度
（1）把数组变成List集合的好处？
可以使用集合的思想和方法来操作数组元素。
注意：将数组变成集合，不可以使用集合的增删方法。因为数组的长度是固定的。如果要增删，就会引发UnsupportedOperationException

（2）如果数组中的元素都是对象，那么转成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

11，高级for循环
格式：
for(数据类型 变量名 ：被遍历的集合(Collection)或者数组)
{

}
对集合进行遍历。只能获取集合元素，但是不能对集合进行操作。
迭代器除了遍历，还可以进行remove集合中的元素动作。
如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。

传统for和高级for有什么区别？
高级for有一个局限性，必须有被遍历的目标。
建议在遍历数组的时候，还是用传统for，因为传统for可以定义角标。

12，可变参数
从JDK1.5之后，Java允许定义形参长度可变的参数从而允许为方法指定数量不确定的形参。如果在定义方法时，
在最后一个形参的类型后增加三点（...），则表明该参数可以接受多个参数值，多个参数值被当成数组传入。
示例代码:

public class Varargs {
    // 定义了形参长度可变的方法
    public static void test(int a, String... books) {
        System.out.println(a);
        for (String temp : books) {
            System.out.println(temp);
        }
    }
    public static void test(int a, String books) {
        System.out.println(a + "::" + books);
    }
    public static void main(String[] args) {
        test(5, "Thinking in Java", "Thinking in C++");
        System.out.println("*****************");
        test(4, "Thinking in Java");
        System.out.println("*****************");
        test(3, new String[] { "Thinking in Java" });
    }
}

从上面运行结果可以看出，当调用test方法时，books参数可以传入多个字符串作为参数值。
参数个数可变的参数其实就是一个数组参数，也就是说下面两种方法签名效果完全一样：
public static void test(int a,String...books)
下面采用数组形参来定义方法：
public static void test(int a,String[] books)
这两种形式都可以把books当做数组来处理，区别在于调用上有所不同，对于形参可变更加简洁：
test(5,"Thinking in Java","Thinking in C++");
对于数组形式的，调用时必须传入一个数组：
test(5,new String[]{"Thinking in Java","Thinking in C++"});
实际上，即使采用形参长度可变形式来定义方法，调用时也可以传入数组，值得注意的是，
数组形式的形参可以处于形参列表的任意位置，但长度可变的形参只能处于形参列表的最后，
也就是说一个方法中最多只能有一个长度可变的形参。
注意：
形参可变的方法遇到重载时的情况，通过上面的程序发现，如果同一个类中定义了test(int a,String...books)
和一个重载的test(int a,String books)，则test(int a,String...books)方法的books不可能通过直接传入
一个字符串参数，如果只传入一个字符串参数，则可采用传入字符串数组的形式，如
test(3,new String[]{"Thinking in Java"});
大部分时候，我们不推荐重载具有形参长度可变的方法，因为这样做没有太大的意义，而且容易引起程序的可读性降低。

13，静态导入
导入了类中的所有静态成员，简化静态成员的书写。
import static java.util.Collections.*;  //导入了Collections类中的所有静态成员

总结：
1，要熟悉Java集合框架的整体性，对集合框架要有细致的分类——Collection接口和Map接口。
2，Collection接口，常用的子接口为List和Set；List集合石有序可重复的，Set集合是无序不可重复的。List常用的集合有ArrayList和LinkedList，JDK1.0中的Vector虽然是同步的，但是效率低，
   已被ArrayList取代了。ArrayList表现线程不同步，底层是数据结构是数组结构，所以特点是查询快，增删慢。而LinkedList底层数据结构是链表，变现是增删快，查询慢。
   此外，ArrayList和LinkedList实现的是Collection接口，基本上沿用了Collection中的方法，并且自身有特有的方法，需要注意。
   Set集合，Set的特点是无序，不可以重复。常用的有HashSet、TreeSet。HashSet：底层数据结构是哈希表，线程是不同步的。无序，高效；TreeSet：对Set集合中的元素的进行指定顺序的排序。不同步。TreeSet底层的数据结构就是二叉树。
3，Map接口，该集合存储键值对，一对一对往里存，而且要保证键的唯一性，不允许出现重复。常用的子类有HashMap和TreeMap。因为其实现了Map接口，所以可以用Map中定义好的接口。
4，哈希表的原理：
   （1）对对象元素中的关键字(对象中的特有数据)，进行哈希算法的运算，并得出一个具体的算法值，这个值 称为哈希值。
   （2）哈希值就是这个元素的位置。
   （3）如果哈希值出现冲突，再次判断这个关键字对应的对象是否相同。如果对象相同，就不存储，因为元素重复。如果对象不同，就存储，在原来对象的哈希值基础 +1顺延。
   （4）存储哈希值的结构，我们称为哈希表。
   （5）既然哈希表是根据哈希值存储的，为了提高效率，最好保证对象的关键字是唯一的。
    这样可以尽量少的判断关键字对应的对象是否相同，提高了哈希表的操作效率。
对于ArrayList集合，判断元素是否存在，或者删元素底层依据都是equals方法。
对于HashSet集合，判断元素是否存在，或者删除元素，底层依据的是hashCode方法和equals方法。

5，TreeSet集合排序有两种方式，Comparable和Comparator区别：
（1）让元素自身具备比较性，需要元素对象实现Comparable接口，覆盖compareTo方法。
（2）让集合自身具备比较性，需要定义一个实现了Comparator接口的比较器，并覆盖compare方法，并将该类对象作为实际参数传递给TreeSet集合的构造函数。
  第二种方式较为灵活。
6，Map集合存储和Collection有着很大不同：
   Collection一次存一个元素；Map一次存一对元素。Collection是单列集合；Map是双列集合。Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。
   特点：要保证map集合中键的唯一性。

7，使用集合的技巧：
   看到Array就是数组结构，有角标，查询速度很快。
   看到Link就是链表结构：增删速度快，而且有特有方法。addFirst； addLast； removeFirst()； removeLast()； getFirst()；getLast()；
   看到hash就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖hashCode，equals方法。
   看到tree就是二叉树，就要想到排序，就想要用到比较。
比较的两种方式：
   一个是Comparable：覆盖compareTo方法；
   一个是Comparator：覆盖compare方法。
   LinkedHashSet，LinkedHashMap:这两个集合可以保证哈希表有存入顺序和取出顺序一致，保证哈希表有序。
集合什么时候用？
   当存储的是一个元素时，就用Collection。当存储对象之间存在着映射关系时，就使用Map集合。
   保证唯一，就用Set。不保证唯一，就用List。

8，Collection 和 Collections的区别：
    Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、
线程安全化（将非同步的集合转换成同步的）等操作。
    Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,

如插入、删除、判断一个元素是否其成员、遍历等。