java lambda&stream

一、lambda

• Lambda 表达式是一个匿名函数
• 本质只是一个"语法糖"
• 通常使用 (argument) -> {body}
• 可以具有零个
• 一个或多个参数

在之前想要把某些功能传递给某个方法，总要去写匿名类

语法糖：指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。通常来说使用语法糖能够增加程序的可读性，从而减少程序代码出错的机会

1. 无参数，无返回值，lambda 体中只有一行代码时，{}可以忽略
   () -> System.out.println(“Hello World”);
2. 无参数，有返回值 () -> { return 3.1415 };
3. 有参数，无返回值 (String s) -> { System.out.println(s); }
4. 有一个参数，无返回值 s -> { System.out.println(s); }
5. 有多个参数，有返回值 (int a, int b) -> { return a + b; }
6. 有多个参数，表达式参数类型可以不写，jvm 可以根据上下文进行类型推断 (a, b) -> { return a - b; }

list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        }) ;


        /*
           lambda 将一个匿名函数作为参数传递
        */
        list.sort((o1, o2) -> {
            return o1.compareTo(o2);
        });

        System.out.println(list);

当有且仅有一个参数时，如果不显式指明类型，则不必使用小括号。

• 例如 a -> return a*a。
• Lambda 表达式的正文可以包含零条，一条或多条语句。
• 如果 Lambda 表达式的正文只有一条语句，则大括号可不用写，且表达式 的返回值类型要与匿名函数的返回类型相同。

new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello world");
            }
        }).start();

// lambda 表达式方式
        new Thread(
                () -> System.out.println("Hello world")
        ).start();

list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
// lambda 表达式方式
list.forEach((e)->{ System.out.println(e); });

JButton bt = new JButton();
           bt.addActionListener(new ActionListener() {
               @Override
               public void actionPerformed(ActionEvent e) {
                   System.out.println("hello world");
               }
           });
        //lambda  表达式方式
        bt.addActionListener((e)->{
            System.out.println("Hello world");
        });

List<Integer> list = Arrays.asList(1,2,3,4,5,6,7) ;

        for (Integer n :list){
            System.out.println(n);
        }
        //使用Lambda表达式
        list.forEach((n)-> System.out.println(n));

功能接口（Functional interface）

即@FunctionalInterface，当你注释的接口违反了 Functional Interface 的契约时，它可以用于编译器级错误。

• 在底层找@FunctionalInterface

二、stream

• 从支持数据处理操作的源,生成的元素序列
• 流（Stream） 可以提供了许多对集合，数组进行遍历操作的方法 获取流 流操作

//集合中获取流  集合是数据源（不对数据源操作）  
//将集合中的数据存放到Stream对象中，对Stream中的数据操作
        ArrayList<String> list = new ArrayList<>();
        Stream<String> stream = list.stream();

        //数组获取流
        Integer [] a = new Integer[10];
        Stream<Integer> stream1 = Arrays.stream(a);
                                   //使用 Arrays 中的 stream() 方法，将数组转成流

        Stream<Integer> stream2 = Stream.of(1,2,3,4,5,6,7);// Stream 中的静态方法：of()
        stream2    //直接对流进行操作
                .filter((e)->{return e>3;})
                .forEach((e1->{
                    System.out.println(e1);
                }));

        List<Integer> alist = stream2
                .filter((e)->{return e>3;})
                .collect(Collectors.toList());
        System.out.println(alist);

流操作

• 数据源 => 中间操作 => 终端操作 => 结果

中间操作

        Stream<Integer> list1 = list.stream()       //将集合转化为流
                .sorted()                           //自然排序，流中元素需实现 Comparable 接口
                .filter((e)->{return e>3;})         //过滤流中的某些元素
                .distinct()                         //去除重复元素
                .limit(2)                           //获取 n 个元素
                .skip(2) ;                          //跳过 n 元素，配合 limit (n) 可实现分页

终端操作

Integer list1 = list.stream()
                         .forEach()           //遍历流中的元素
                         .toArray             //将流中的元素倒入一个数组
                         .Min                 //返回流中元素最小值
                         .Max                 //返回流中元素最大值
                         .count()             //返回流中元素的总个数
                         .Reduce              //所有元素求和
                         .anyMatch()          //接收一个 Predicate 函数，只要流中有一个元素满足条件则返 回 true，否则返回 false
                         .get();

举例

构造一个苹果类，包含苹果价格，颜色，大小

public class StreamDome4 {

    public static void main(String[] args) {

        ArrayList<Apple> list = new ArrayList<>();
        Apple apple1 = new Apple(100,"红","200");
        Apple apple2 = new Apple(101,"蓝","500");
        Apple apple3 = new Apple(103,"红","200");
        Apple apple4 = new Apple(102,"红","600");
        Apple apple5 = new Apple(105,"黄","200");
        Apple apple6 = new Apple(106,"红","800");

                 list.add(apple1);
                 list.add(apple2);
                 list.add(apple3);
                 list.add(apple4);
                 list.add(apple5);
                 list.add(apple6);
        /*list.stream()//输出颜色为红色的苹果
                 .filter((a)->{return a.getColor().equals("红");})
                 .forEach((e)-> System.out.println(e));
                 
         */


        //map(); 将其映射成一个新元素    将映射的那一列传出
        /*list.stream()   
                .map(Apple::getColor) //遍历苹果的颜色
                .forEach((e)-> System.out.println(e));*/

        List<String> apples = list.stream()
                .filter((e)->{return e.getNum()>102;})
                .map(Apple::getColor)
                .collect(Collectors.toList());   //将流转化为集合


      /*  Set<Apple> apples = list.stream()
                .filter((e)->{return e.getNum()>102;})
                .collect(Collectors.toSet());
                //将流转化为集合，最后用集合的方式输出
        */


     /*   Map<Integer,String> apples = list.stream()
                .collect(Collectors.toMap(Apple::getNum,Apple::getColor));
                */

        System.out.println(apples);
//        System.out.println(list);

    }

}

class Apple{
    @Override
    public String toString() {
        return "Apple{" +
                "num=" + num +
                ", color='" + color + '\'' +      //toString()   重写输出的格式
                ", size='" + size + '\'' +
                '}';
    }
    Integer num;
    String color;
    String size;
    public Apple(int num, String color, String size){

        this.num = num;
        this.color = color;
        this.size = size;

    }



    public void setNum(Integer num) {
        this.num = num;
    }

    public Integer getNum() {
        return num;
    }

    public String getColor() {
        return color;
    }

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

    public void setSize(String size) {
        this.size = size;
    }

    public String getSize() {
        return size;
    }


}