Lambda＆Stream

一、lambda
Lambda 表达式是一个匿名函数
本质只是一个"语法糖"
通常使用 (argument) -> {body}
可以具有零个
一个或多个参数
在之前想要把某些功能传递给某个方法，总要去写匿名类

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

无参数，无返回值，lambda 体中只有一行代码时，{}可以忽略
() -> System.out.println(“Hello World”);
无参数，有返回值 () -> { return 3.1415 };
有参数，无返回值 (String s) -> { System.out.println(s); }
有一个参数，无返回值 s -> { System.out.println(s); }
有多个参数，有返回值 (int a, int b) -> { return a + b; }
有多个参数，表达式参数类型可以不写，jvm 可以根据上下文进行类型推断 (a, b) -> { return a - b; }
list.sort(new Comparator() {
@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() {
@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 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 list = new ArrayList<>();
Stream 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 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;
}

}