第十节 Java工具包-Collections 流--lambada表达式

 collection为核心的接口，包含了多种不同类型的集合以及多种不同数据结构的实现的类

list  set queue都是在collection接口下的所以都有.add()方法

package cn.nefu.com;
import java.util.List;
import java.util.ArrayList;
import java.util.AbstractMap;
public class S47 {
	public static void main(String[] args)
		{
			List<String> list=new ArrayList();//泛型限制了集合中元素的类型
	        list.add("aaa");//有序
	        list.add("bbb");
	        list.add("ccc");
	        for(int i=0;i<list.size();i++)
	        {
	        	System.out.println(list.get(i));
	        }
            for(String s:list)//for-each循环输出，表示从list列表中拿出元素给s，直到空了为止
	        {
	        	System.out.println(s);
	        }
		}
}
	        

list中的元素是有序的 list集合自己就做好了排序  list还可以包含重复元素，因为它 带有标号（操作系统自带的）

list是接口 所以不能实例化出对象(new) 要去帮助文档中去找基本实现的类  有很多 比较常见的如ArrayList(实现类)

list集合怎么取出元素，完成迭代？

1.利用list.size()方法 

2.利用for each语句 第一节课也讲过哦

其实for each语句就相当于类的封装了，便于使用  表示从list集合中取出元素，直到集合里面没有元素为止

注意：集合list当中可以放任何类型的元素，整型啊 double 字符串都可以 我们为了便于迭代时取出元素还为了让集合中的元素有约束所以引入了泛型的概念

 当试图向集合中添加不匹配的类型对象时 编译错误

因为集合中不关心元素的具体类型，所以引出泛型  <E> ----它里面装的是引用类型

当声明元素类型为基本数据类型而不是引用数据类型时 编译出错

int double 这些是基本数据类型   要对所有基本数据类型进行封装  Integer Double---就是E

为什么要把它进行封装呢？因为它提供了一些好用的方法 提供双精度浮点数的一些方法

int   Integer.parseInt();

字符转成字符串  字符串转字符怎么转要会

集合list怎么去遍历  怎么去找

集合  怎么放怎么取   ？   迭代

迭代器功能   迭代器遍历

map引用对象-------它是接口 要用实现的类去new  put get

map集合遍历    去找这个里面有多少个键值

keyset  获得键值  for each   之后根据每一个键值输出每一个键值所对应的值

public class S47 {
	public static void main(String[] args)
		{
	        Iterator<String> iterater=list.iterator();//迭代器  模拟集合一次往下查询//获取迭代器
	        while(iterator.hasNext())
	        {
	        	System.out.println(iterator.next());
	        }
	        Map<Strint,Integer> map=new HashMap();
	        map.put("200000",233)//自己指定键值   键值区别开value可以重复
		}
}

jdk1.8之后遍历----函数式编程   函数

函数式编程算是java中的另类了 

Lambada表达式-----Lambada允许把函数作为一个方法的参数（函数作为参数传到方法中）

lambada表达式不是单独存在的 它要和函数式接口/函数式编程结合在一起

(arg1, arg2) -> expression（函数体语句）

(arg1, arg2) -> {body}//无函数名  只使用

java.util.stream.Stream<T>接口 鉴于Java对集合操作的复杂性，Java8中引入Stream API，用于操作处理集合中的元素  有了这个流可以快速的对集合进行依次的遍历和操作   例如选择集合中的值，例如给集合中的值排序---------对集合中的元素进行流式的操作，改变了元素，没有改变集合中的元素值（不会回写到集合中）

对流的使用要用到lambada表达式

我们的流中就采用了函数式接口

package com.example21.collectionstream;

public class Apple {
    public enum Color{
        RED, GREEN
    }
    private int id;
    private Color color;
    private int weight;
    public Apple(int id, Color color, int weight) {
        this.id = id;
        this.color = color;
        this.weight = weight;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Color getColor() {
        return color;
    }

    public void setColor(Color color) {
        this.color = color;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }
}

package cn.nefu.com.zn;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamTest {
    private static final List<Apple> APPLES = create();//常量大写，我们定义一个常量，里面是list类型，定义一个apple的筐，要装苹果
//所有的常量要不在构造方法的时候初始化，要不在定义的时候初始化//调用了创建方法，说明筐里要装什么东西
    private static List<Apple> create() {//创建方法返回的集合的引用
        Apple a = new Apple(1, Apple.Color.RED, 200);
        Apple a2 = new Apple(2, Apple.Color.GREEN, 250);
        Apple a3 = new Apple(3, Apple.Color.RED, 260);
        Apple a4 = new Apple(4, Apple.Color.GREEN, 230);
        List<Apple> apples = new ArrayList<>();
        apples.add(a);
        apples.add(a2);
        apples.add(a3);
        apples.add(a4);
        return apples;//苹果放到集合中，筐里装了四个苹果了，两个红的，两个绿的
    }

    public static void main(String[] args) {
        //forEach();
        /*filter(Apple.Color.RED)
                .forEach(a -> System.out.println(a.getId()));*/
        //map();
        sorted();
        // sortedReversed();
        // collect();
        //collectGroupingBy2();
    }

    /**
     * foreach循环
     * forEach()方法，简写//对集合遍历
     */
    private static void forEach() {
        for (Apple a : APPLES) {//for each 去筐里取apple的对象 ，集合中每一个元素都是苹果
            System.out.println(a.getWeight());//对集合进行依次遍历
        }
        APPLES.forEach((Apple apple)-> {System.out.println(apple.getWeight());});//foreach一创建 这里面的形参就是在集合里取走的元素
    }//我们学习了lambada表达式之后  可以使用集合给我们提供的foreach()方法   这个方法里装什么？装的lambada表达式（函数接口）  对集合中的元素进行什么处理

    /**
     * 原实现。返回指定颜色的全部苹果
     */
    private static List<Apple> getRedApples(Apple.Color c) {//要么是红色，要么是绿色，去筐里找指定的颜色，还得把颜色给返回来
        List<Apple> reds = new ArrayList<>();//new 一个list
        for (Apple a : APPLES) {
            if (a.getColor().equals(c)) {//==号是引用空间的比较    
            	reds.add(a);//这个筐去装红色的苹果
            }
        }
        return reds;
    }/*
    /**
     * 基于stream的过滤
     * 修改方法返回值，方法链
     * 比较源/新集合
     *
     * @param c
     */
    private static List<Apple> filter(Apple.Color c) {//所有集合
        return APPLES.stream()//返回集合流
                .filter(a -> a.getColor() == c)//不影响原集合   新的集合流
                .collect(Collectors.toList());//集合流变成集合
    }

    /**
     * 过滤指定颜色，且大于等于指定重量的苹果。2次过滤
     *
     * @param c
     * @param weight
     */
    private static void filter(Apple.Color c, int weight) {
        APPLES.stream()
                .filter(a -> a.getColor() == c)
                .filter(a -> a.getWeight() >= weight)
                .collect(Collectors.toList())//组合  集成一下 把流变成集合   流中的元素聚合成集合
                .forEach(a -> System.out.println(a.getId()));

    }


    /**
     * 将重量映射为新集合，遍历打印
     * 简写
     */
    private static void map() {
        APPLES.stream()//获取集合流
                .map(Apple::getWeight)//从这个流中获得新的集合----新的集合，里面放的苹果的重量
                .collect(Collectors.toList())
                .forEach(System.out::println);//运行某一个类调用方法
                .forEach(apple->System.out.println())

    }

    /**
     * 以重量顺序排序
     */
    private static void sorted() {//升序
        APPLES.stream()
                .sorted(Comparator.comparing(Apple::getWeight))
                .collect(Collectors.toList())
                .forEach(a -> System.out.println(a.getWeight()));
    }

    /**
     * 以ID逆序排序
     */
    private static void sortedReversed() {
        APPLES.stream()//提供了对集合的一大堆操作
                .sorted(Comparator.comparing(Apple::getId).reversed())
                .collect(Collectors.toList())
                .forEach(a -> System.out.println(a.getId()));
    }

    /**
     * 获取颜色，分别按list/set聚合
     */
    private static void collect() {
        APPLES.stream()
                .map(Apple::getColor)
                .collect(Collectors.toSet())
                .forEach(System.out::println);

    }

    /**
     * Map操作。基于颜色分组
     */
    private static void collectGroupingBy() {
        Map<Apple.Color, List<Apple>> map = APPLES.stream()
                .collect(Collectors.groupingBy(Apple::getColor));

    }

    /**
     * 以ID为键，苹果对象为值。自定义键值对
     * forEach遍历
     */
    private static void collectGroupingBy2() {
        APPLES.stream()
                .collect(Collectors.toMap(Apple::getId, a -> a))
                .forEach((k, v) -> {
                    System.out.println(k + "/" + v.getColor());
                });

    }

    /**
     * 函数中，只能操作函数体外的常量
     */
    private static void finalValue() {
       int count = 0;
        APPLES.forEach(a -> {
            System.out.println(count);
        });
    }

    /**
     * 2组过滤相同
     */
    private static void getFilter() {
        Apple a1 = new Apple(1, Apple.Color.RED, 200);
        Apple a2 = new Apple(5, Apple.Color.GREEN, 240);
        List<Apple> newApples = List.of(a1, a2);
        List<Apple> oldApples = APPLES;
        List<Apple> apples = new ArrayList<>();
        for (Apple a : newApples) {
            for (Apple oa : oldApples) {
                if (a.getId() == oa.getId()) {
                    apples.add(a);
                }
            }
        }
        apples.forEach(a -> System.out.println(a.getId()));
        System.out.println("--------------");
        List<Apple> apples2 = newApples.stream()
                .filter(a -> oldApples.stream()
                        .anyMatch(oa -> oa.getId() == a.getId()))
                .collect(Collectors.toList());

        apples2.forEach(a -> System.out.println(a.getId()));
    }
}

利用foreach方法  lambada表达式 配合  形参赋值

函数调用四次  形参名字随便

集合中都有这个方法  取值放函数形参里 形参输出  经常用 触发函数四次

集合流  不管存储  操作集合元素通道  筛选工作和获取流

利用流的方式去选苹果  苹果选颜色   按照函数规则去遍历