集合Collection，List，Set的使用

Collection是单例集合的顶层接口，表示一组对象。
JDK不提供此接口的实现，一般是子类（List，Set）实现。

创建Collection对象
使用多态进行创建
具体实现类ArrayList

        Collection<String> col = new ArrayList<String>();

        //添加元素
        col.add("Hello");
        col.add("world");
        System.out.println(col);//[Hello, world]重写了toString方法

public boolean add(Object ):添加元素
public boolean remove(Object):删除元素
public void clean():清空集合
public boolean contains():判断是否存在这个元素
public boolean isempty():判断集合是否为空
public int size():集合的长度

        Collection<String> col = new ArrayList<String>();

        //添加元素
        col.add("Hello");
        col.add("world");
        col.add("Java");
        System.out.println(col);//[Hello, world, Java]重写了toString方法

        //删除元素
        col.remove("world");
        System.out.println(col);//[Hello, Java]

        //判断元素是否在集合中
        boolean b = col.contains("Hello");
        System.out.println(b);//true
        b = col.contains("hello");
        System.out.println(b);//false

        //判断集合是否为空
        b = col.isEmpty();
        System.out.println(b);//false

        //获取集合的长度
        int num = col.size();
        System.out.println(num);//2

        //清空集合
        col.clear();
        System.out.println(col);//[]
        num = col.size();
        System.out.println(num);//0

Collection遍历:

       Collection<String> col = new ArrayList<String>();

        //添加元素
        col.add("Hello");
        col.add("world");
        col.add("Java");

        //通过iterator方法，返回迭代器
        Iterator<String> it = col.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

List的用法

List集合的概述
有序集合（序列），可以精确的控制每个列表中的位置，可以通过整数索引进行访问，并搜索列表中的元素。
与set不同，列表允许相同的元素。

list集合特点：
有序：存储与取出的顺序一致
可重复：存储的元素可以重复

	        //创建实例对象
        List<String> list = new ArrayList<String>();

        //添加元素
        list.add("join");
        list.add("Java");
        list.add("family");
        list.add("Java");

        //迭代器方式遍历
        Iterator<String> it = list.iterator();

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

list的特有方法：
public void add(int index,E element):在指定位置添加元素
public E remove(int index):移除指定位置的元素
public E set(intindex,E element)：修改指定位置的元素，返回被修改的元素
public E get(int index):返回指定位置的元素

ListIterator
列表迭代器
通过list集合的listIterator()方法获取到，所以踏实list集合特有的迭代器
允许沿任意方向遍历列表

常用方法
Next：返回迭代中的下一个元素
hasNext：如果迭代具有更多元素，返回true
previous：返回上一个元素
hasprevious：如果反向迭代还有更多元素，返回true
add：将指定的元素插入列表

        List<String> list = new ArrayList<String>();
        list.add("Hello");
        list.add("list");
        list.add("iterator");

        //ListIterator实例化
        ListIterator<String> lt = list.listIterator();

        while (lt.hasNext()){
            String s = lt.next();
            System.out.print(s + "   ");//Hello   list   iterator
        }

        System.out.println();

        while (lt.hasPrevious()){
            String s = lt.previous();
            System.out.print(s + "   ");//iterator   list   Hello
        }

LinkedList特有方法
public void addFirst(E element):在列表头加入指定元素
public void addLast(E element):在列表末尾加入指定元素
public E getFirst():获取列表中第一个元素
public E getLast():获取列表中最后一个元素
public E removeFirst():删除并返回列表第一个元素
public E removeLat():删除并返回列表最后一个元素

Set：
不存在重复的元素

• 没有带索引的方法，不能用for来遍历

//创建集合对象
        Set<String> set = new HashSet<String>();

        //添加元素
        set.add("Hello");
        set.add("world");
        set.add("Java");

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

HashSet：
对集合迭代顺序不做任何保证
底层数据结构是哈希表
没有带索引的方法，所以不能用普通for循环遍历
由于是set集合，不能有重复数据

//创建对象
        HashSet<String> hs = new HashSet<String>();
        //添加元素
        hs.add("Hello");
        hs.add("world");
        hs.add("java");
        //遍历
        for(String s:hs){
            System.out.println(s);
        }

LinkedHashSet：
链表哈希Set，具有可预测的迭代顺序
由链表保证元素有序
由哈希表来保证元素唯一

				LinkedHashSet<String> lhs = new LinkedHashSet<String>();
        lhs.add("hello");
        lhs.add("world");
        lhs.add("java");

        for(String s :lhs){
            System.out.println(s);
        }

TreeSet
集合特点：
元素有序，这里的顺序不是指存储和取出顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法
TreeSet() 根据其元素的自然排序进行排序
TreeSet(Comparator comparator)：根据指定的比较器进行排序
没有带索引的方法，不能用普通for进行遍历
由于是Set集合，所以不包含重复的元素

				TreeSet<Integer> ts = new TreeSet<Integer>();

        ts.add(20);
        ts.add(10);
        ts.add(40);
        ts.add(50);
        ts.add(30);

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

TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getEnglish() + s1.getMath() - s2.getMath() - s2.getEnglish();
                int num2 = num != 0 ? num : s1.getName().compareTo(s2.getName());
                return num2;
            }
        });

        Student s1 = new Student("zhangsan", 90, 91);
        Student s2 = new Student("lisi", 88, 89);
        Student s3 = new Student("wangwu", 92, 93);
        Student s4 = new Student("xiaobai", 91, 90);

        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);

        for (Student s : ts) {
            System.out.println(s.getName() + "," + s.getMath() + "," + s.getEnglish());
        }