Day14 集合（一）

集合总体介绍

Java集合是java提供的工具包，包含了常用的数据结构：集合、链表、队列、栈、数组、映射等。Java集合工具包位置是java.util.*
Java集合主要可以划分为4个部分：List列表、Set集合、Map映射、工具类(Iterator迭代器、Enumeration枚举类、Arrays和Collections)、。
Java集合工具包框架图(如下)：

大致说明

看上面的框架图，先抓住它的主干，即Collection和Map。

1 Collection是一个接口，是高度抽象出来的集合，它包含了集合的基本操作和属性。

Collection包含了List和Set两大分支。
  (01) List是一个有序的队列，每一个元素都有它的索引。第一个元素的索引值是0。
          List的实现类有LinkedList, ArrayList, Vector, Stack。

(02) Set是一个不允许有重复元素的集合。
          Set的实现类有HastSet和TreeSet。HashSet依赖于HashMap，它实际上是通过HashMap实现的；TreeSet依赖于TreeMap，它实际上是通过TreeMap实现的。

2 Map是一个映射接口，即key-value键值对。Map中的每一个元素包含“一个key”和“key对应的value”。

AbstractMap是个抽象类，它实现了Map接口中的大部分API。而HashMap，TreeMap，WeakHashMap都是继承于AbstractMap。
   Hashtable虽然继承于Dictionary，但它实现了Map接口。

接下来，再看Iterator。它是遍历集合的工具，即我们通常通过Iterator迭代器来遍历集合。我们说Collection依赖于Iterator，是因为Collection的实现类都要实现iterator()函数，返回一个Iterator对象。
ListIterator是专门为遍历List而存在的。

再看Enumeration，它是JDK 1.0引入的抽象类。作用和Iterator一样，也是遍历集合；但是Enumeration的功能要比Iterator少。在上面的框图中，Enumeration只能在Hashtable, Vector, Stack中使用。

最后，看Arrays和Collections。它们是操作数组、集合的两个工具类。

有了上面的整体框架之后，我们接下来对每个类分别进行分析。

Collection简介

定义

public interface Collection<E> extends Iterable<E> {}

Collection是一个接口，是高度抽象出来的集合，它包含了集合的基本操作：添加、删除、清空、遍历(读取)、是否为空、获取大小、是否保护某元素等等。

public static void main(String[] args) {
        /*Collection接口常用方法*/
        Collection<String> c = new ArrayList<>();
        //判断 集合 是否为 空 ，是空的 （元素个数是0）true
        System.out.println(c.isEmpty());
        //元素的个数
        System.out.println(c.size());
        //元素添加成功 返回 true
        c.add("aa");
        c.add("cccccc");
        c.add("bbb");
        System.out.println(c);
        System.out.println(c.isEmpty());//false
        System.out.println(c.size());//

        Collection<String> cnew = new ArrayList<>();
        cnew.add("ffff");
        cnew.add("eee");
        //把参数 集合的数据 添加到现有 集合中，如果 现有集合发生了改变 true
        //只要有 一个元素添加成功，也算当前集合改变
        c.addAll(cnew);
        System.out.println(c);
        //-----------------------------------
        //删除 集合 中的一个对象 ，当前集合 发生改变 true
        c.remove("aa");
        System.out.println(c);
        //把参数 集合 中的元素 从 当前集合 中 删除 ，当前集合 发生改变 true
        c.removeAll(cnew);
        System.out.println(c);
/*        c.removeIf(new Predicate<String>() {
            @Override
            public boolean test(String t) {

                return t.length() > 3;
            }
        });*/
        //按指定的条件删除
        c.removeIf(t -> t.length()>);
        System.out.println(c);
        //-----------------------------------------
        //判断 参数元素 在 现有 集合中是否存在，存在 true
        System.out.println(c.contains("bbb"));
        //判断 参数集合中的元素 在现有集合中是否存在 ，存在true
        System.out.println(c.containsAll(cnew));//false
        //Arrays.asList() 把 数组 转换 成集合
        //返回的 这个集合 不是List下的实现类ArrayList的对象
        //是 Arrays的内部类 Arrays$ArrayList
        //这个对象只能遍历，不能修改
        List<String> list = Arrays.asList(new String[] {"bbb"});
        list.forEach(System.out::println);
//        list.add("hello");//不允许
//        System.out.println(c.containsAll(list));//true
        //-----------------------------------------------
        //集合 转 数组
        Object[] o = c.toArray();
        //把 集合中的元素 存到 Object数组中，并且返回这个数组。大小不够自动扩容，多了用null填充。
        Object[] os = c.toArray(new Object[]);
        System.out.println(Arrays.toString(os));

        //转换数组 ，并且保留类型
        String [] s = c.toArray(new String[]);

        //--------------------------------------------------------
        //清空集合
        c.clear();
        System.out.println(c.isEmpty());//true
        System.out.println(c.size());//

    }

}

List简介

定义

public interface List<E> extends Collection<E> {}

List是一个继承于Collection的接口，即List是集合中的一种。List是有序的队列，List中的每一个元素都有一个索引；第一个元素的索引值是0，往后的元素的索引值依次+1。和Set不同，List中允许有重复的元素。

List是继承于Collection接口，它自然就包含了Collection中的全部函数接口；由于List是有序队列，它也额外的有自己的API接口。主要有“添加、删除、获取、修改指定位置的元素”、“获取List中的子队列”等。

public class TestList {

    public static void main(String[] args) {
        /*List接口的方法*/
        List<String> list = new ArrayList<>();
        list.add("aa");//
        list.add("bb");//
        list.add("cc");//
        list.add("cc");
        //向 索引位置 添加一个元素
        list.add(, "xx");//[xx, aa, bb, cc]
        System.out.println(list);
        //获得 元素
        System.out.println(list.get());//"aa"
        //修改 ，就是 把某个 索引处的元素 替换掉
        list.set(, "hello");
        System.out.println(list);
        //
        System.out.println(list.indexOf("cc"));//
        System.out.println(list.lastIndexOf("cc"));//4
        //获取 子集合[起始，终止)
        List<String> ls = list.subList(, );//"aa","bb"
        System.out.println(ls);
        //对集合中元素升序排序
        list.sort(null);//自然排序
        System.out.println(list);
        list.sort((s1,s2)-> s2.compareTo(s1));//用Comparator比较器
        System.out.println(list);
    }

}

集合比较

ArrayList和Vector

底层都是数组，遍历和随机访问速度快，插入，删除元素慢。

ArrayList:线程是非安全的，非同步的，速度快

Vector:线程安全的，同步的，速度慢。多线程环境很少用Vector，因为出现的比较早，性能比较低。通常用Collection的方法封装一个非同步的线程。

Vector的子类Stack:通常不用。会用ArrayDeque

ArrayList和LinkedList

LinkedList底层是链表，遍历、随机访问速度慢，但是插入和删除快。

ArrayList 优于> Vector和LinkedList

集合的遍历

使用迭代的方式进行遍历

public static void main(String[] args) {
//        Collection
        List<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        //1.普通for ,只对 List接口有效
        for(int i = ; i < list.size(); i ++) {
            System.out.println(list.get(i));
        }
        //2.增强for
        for(String s:list) {
            System.out.println(s);
        }
        //3.forEach 集合的方法 ;简单
        list.forEach(System.out::println);
        //4 Iterator 迭代器接口 对Collection迭代
        System.out.println("------------------------------");
        Iterator<String> i = list.iterator();
/*        System.out.println(i.next());
        i.remove();//调用 最近的next()返回的元素

        System.out.println(i.next());
        i.remove();
        System.out.println(i.next());
        //
        System.out.println(list);//

*/        //判断 是否 存在下一个元素 ，存在 true
        while(i.hasNext()) {
            System.out.println(i.next());
//            list.add("hello");//引发并行 异常
        }
        //5. ListIterator 是 Iterator的子接口
        //提供 对 List集合遍历
        ListIterator<String> lr = list.listIterator();
        System.out.println("-----ListIterator----------");
        while(lr.hasNext()) {
            System.out.println(lr.next());
            lr.add("--hello--");
        }
        //6.迭代器 的 方法 遍历
        ListIterator<String> lr1 = list.listIterator();
        lr1.forEachRemaining(System.out::println);
        //7.向上迭代
        System.out.println("----向上-----");
        while(lr1.hasPrevious()) {
            System.out.println(lr1.previous());
        }
        //8.Stream流的聚合 方法
        list.stream().forEach(System.out::println);

    }