十四，Collection

• Consumer : 消费型接口 : 有来无回 void accept(T t);

• Supplier : 供给型接口 : T get();

• Function : 函数型接口 : 有来有往 R apply(T t);

• Predicate : 断言型接口 : 条件 boolean test(T t);

• 内部迭代 : 循环在底层.外部迭代 : 自己写循环

  • // collection.stream()  串行流
    // collection.parallelStream() 并行流
    // default Stream<E>    parallelStream()
    // default Stream<E>    stream()
    collection.stream().forEach(new Consumer<Integer>(){
            public void accept(Integer element){
                System.out.println("element = " + element);
            }
        });
    //boolean   removeIf•(Predicate<? super E> filter)
    //      如果存在就删除
            collection.removeIf(new Predicate<Integer>() {
                @Override
                public boolean test(Integer integer) {
                    return integer > 500;
                }
            });

• Collections : 集合的工具类

  List

  • List<User> list = new ArrayList<>();
    list.add(new User("lisi0", 20));
    //  void add(int index, E element)
    //在列表的指定位置插入指定元素（可选操作）。
    list.add(2, new User("xiaoming", 18));
    //E get(int index)
    //返回列表中指定位置的元素。
    User user = list.get(2);
    //int indexOf(Object o)
    //返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
    int index = list.indexOf(new User("xiaoming", 18));
    //int lastIndexOf(Object o)
    //返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
    //E remove(int index) 获取并移除
    //移除列表中指定位置的元素（可选操作）。
    User remove = list.remove(2);
    //E set(int index, E element)
    //用指定元素替换列表中指定位置的元素（可选操作）。
    User setUser = list.set(2, new User("laowang", 22));
    //List<E> subList(int fromIndex, int toIndex)
    //返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
    List<User> list1 = list.subList(1, 5);
    list.forEach(System.out::println);

迭代器listIterator

// ListIterator<E> listIterator()
//返回此列表元素的列表迭代器（按适当顺序）。
//ListIterator<E> listIterator(int index)
//返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
        for (ListIterator<String> listIterator = list.listIterator(); listIterator.hasNext(); ) {
            String s = listIterator.next();
            if ("bbb".equals(s)) {
                listIterator.add("eee");
            }
        }

ArrayList

    // void trimToSize()
    //将此 ArrayList 实例的容量调整为列表的当前大小。
    // Vector :
    Vector<String> vector = new Vector<>();
    //  int capacity()  理论容量
    //返回此向量的当前容量。
    // int size()  实际容量
    //返回此向量中的组件数
    System.out.println("vector.capacity() = " + vector.capacity());
    System.out.println("vector.size() = " + vector.size());

LinkedList

    LinkedList<String> linkedList = new LinkedList<>();
    //void addFirst(E e)
    //将指定元素插入此列表的开头。
    //void addLast(E e)
    //将指定元素添加到此列表的结尾。
    linkedList.addFirst("000");
    linkedList.addLast("666");
//E element()
//获取但不移除此列表的头（第一个元素）。
System.out.println("linkedList.element() = " +linkedList.element());
//E getFirst()
//返回此列表的第一个元素。
System.out.println("linkedList.getFirst() = " +linkedList.getFirst());
//E getLast()
//返回此列表的最后一个元素。
System.out.println("linkedList.getLast() = " +linkedList.getLast());
//  boolean offer(E e)
//  将指定元素添加到此列表的末尾（最后一个元素）。
//  boolean offerFirst(E e)
//  在此列表的开头插入指定的元素。
//  boolean offerLast(E e)
//  在此列表末尾插入指定的元素。
//  E peek()
//  获取但不移除此列表的头（第一个元素）。
//  E peekFirst()
//  获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
//  E peekLast()
//  获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
//  E poll()
//  获取并移除此列表的头（第一个元素）
//  E pollFirst()
//  获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
//  E pollLast()
//  获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
//  E removeFirst()
//  移除并返回此列表的第一个元素。
//  E removeLast()
//  移除并返回此列表的最后一个元素。
//  void push(E e)
//  将元素推入此列表所表示的堆栈。
linkedList.push("aaa");
//  E pop()
//  从此列表所表示的堆栈处弹出一个元素。
System.out.println("linkedList.pop() = " + linkedList.pop());

• @FunctionalInterface// 函数式接口的注解,函数式接口 : 抽象函数的个数 有且只有一个;

Set:元素唯一，不保证插入和取出数据一致

• HashSet:哈希表结构，线程不安全

  • 唯一原则：先使用 元素 的 hashCode函数进行比较 , 如果不同,直接存储;如果相同,则调用元素的 equals() 函数进行判断,如果不同直接存储,相同舍弃

  • LinkedHashSet : 哈希表 + 链表,保证插入顺序和取出顺序一致

• TreeSet：二叉树结构，线程不安全,会对元素进行排序

  • 自然排序 : 要求 元素类型实现 Comparable<T> 接口

  • 定制排序/自定义排序 : 创建TreeSet对象时需要提供 比较器对象

  • 注意 : 两种排序同时存在,优先按 定制排序进行排序

lambda表达式

TreeSet<Student> treeSet3 = new TreeSet<>(
// lambda表达式中,形参的类型是可以省略的
            (o1, o2) -> {
                // 年龄升序名字降序
                int num = o1.getAge().compareTo(o2.getAge());
                if (num == 0) {
                    return -o1.getName().compareTo(o2.getName());
                }
                return num;
            }
    );
​

reeSet3.forEach(    (student) -> {  
    System.out.println(student);    
                                 });
treeSet3.forEach(        
// 当形参只有一个参数时 , 小括号可以省略不写        
student -> {            System.out.println(student);        });   
// 当方法体只有一条语句时 , 大括号可以省略不写 , 同时去掉末尾分号 , 如果是return语句,return也要省略
treeSet3.forEach(student ->System.out.println(student));
// 当 lambda 表达式的 函数体已经有函数实现时,可以使用 函数引用
// 对象::函数名
//参刚好是被调用函数的参数
PrintStream out = System.out;
treeSet3.forEach(out::println);
treeSet3.forEach(System.out::println);