lambda表达式与流处理

目录

1.lambda表达式

1.1lambda表达式的简介

1.2lambda表达式实现函数式接口

1.函数式接口

2.lambda表达式实现方法

2.Java8Stream

2.1什么是Stream流

2.2流的详细介绍

2.3获取流 

2.4流操作

中间操作

终端操作

---

1.lambda表达式

1.1lambda表达式的简介

        lambda表达式可以用非常少的代码实现抽象方法，lambda表达式不能独立运行，因此必须实现函数接口，并且会返回一个函数式接口的对象，lambda表达式的语法非常特殊，格式如下

(参数1，参数2.....参数n)->结果表达式

        lambda表达式的语法非常抽象，并且有着非常强大的自动化功能，如自动识别泛型，自动数据类型转换等，这会让初学者很难掌握，如果将lambda表达式的功能归纳总结，可以将lambda语法用如下方式理解：

  （   ）         ->        {  代码块} 

这个方法      按照       这样的代码来实现

简单总结：操作符左边是方法参数，操作符右边的是方法体 

1.2lambda表达式实现函数式接口

        lambda表达式可以实现函数式接口，本节将讲解函数式接口的概念以及用lambda表达式实现不同类型的函数式接口

1.函数式接口

 函数式接口指的是仅包含一个抽象方法的接口，接口中的方法简单明了的说明了接口的用途

interface Myinterface{

               void mymethod();

}

2.lambda表达式实现方法

        很多函数式接口的抽象方法是无参数的，如线程接口Runnable接口只有一个run()方法，这样的无参抽象方法在lambda表达式中使用" ( ) "表示

@FunctionalInterface
public interface Shape {
void area(int a,int b);
}
Shape d = (a, b)->{System.out.println(a+b);};
d.area(1, 2);

2.Java8Stream

2.1什么是Stream流

        Stream 是 Java8 的新特性,它允许你以声明式的方式处理数据集合，可以把 它看作是遍历数据集的高级迭代器。此外与 stream 与 lambada 表达示结合后 编码效率与大大提高，并且可读性更强。 要澄清的是 java8 中的 stream 与 InputStream 和 OutputStream 是完全 不同的概念。

    简单案例：

public static void main(String[] args) {
List<Apple> applestore = new ArrayList();
applestore.add(new Apple(1,"red",500,"河南"));
applestore.add(new Apple(2,"red",400,"陕西"));
applestore.add(new Apple(3,"green",300,"上海"));
applestore.add(new Apple(4,"green",200,"湖北"));
applestore.add(new Apple(5,"green",100,"湖南"));
}

我们的需求是在 applestore 集合中找出红色苹果手机. 使用 Stream 流快速实现操作 

List<Apple> apples = applestore
.stream()
.filter(a -> a.getColor().equals("red"))
.collect(Collectors.toList());

        这里使用的就是 Java8 中的 stream 流，使用的是声明性方式写的：说明想 要完成什么（筛选，排序，取值），而不说明如何实现一个操作（for 循环）。 同时可以将这些操作链接起来，达到一种流水线式的效果 。

2.2流的详细介绍

什么是流呢？

简单的定义，就是“从支持数据处理操作的源,生成的元素序列”。

元素列表:和集合一样，流也提供了一个接口,访问特定元素类型的一组有序值。

数据源 :获取数据的源，比如集合。

数据处理操作 :流更偏向于数据处理和计算，比如 filter、map、find、sort 等。 简单来说，我们通过一个集合的 stream 方法获取一个流，然后对流进行一 系列流操作，最后再构建成我们需要的数据集合 。

语法：

stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|+
List<Integer> list =
widgets.stream()
.filter(b -> b.getColor() == RED)
.sorted((x,y) -> x.getWeight() - y.getWeight())
.sum();

2.3获取流 

1.使用 Collection 接口下的 stream(）

List<String> list = new ArrayList<>();
Stream<String> stream = list.stream();

2.使用 Arrays 中的 stream() 方法，将数组转成流 

Integer[] nums = new Integer[10];
Stream<Integer> stream = Arrays.stream(nums);

3.使用 Stream 中的静态方法：of() 

Stream<Integer> stream = Stream.of(1,2,3,4,5,6)

 4.使用 BufferedReader.lines() 方法，将每行内容转成流

BufferedReader reader=new BufferedReader(new FileReader("stream.txt"));
Stream<String> lineStream = reader.lines();

2.4流操作

流的操作可以分为两种中间操作和终端操作

List<Apple> apples = applestore
.stream()                                  获得流
.filter(a -> a.getColor().equals("red"))   中间操作
.collect(Collectors.toList());             终端操作

简化一下就是：

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

        诸如 filter 或者 sort 等中间操作会返回另一个流，进而进行下一步流操作，而终 端操作则是将流关闭，构建新的数据集合对象（也可以不构建）。

中间操作

流的中间操作

filter	过滤流中的某些元素
sorted():	自然排序，流中元素需实现 Comparable 接口
distinct	去除重复元素
limit(n)	获取n个元素
skip(n)	跳过n个元素，配合limit可以进行分页
map()	将其映射成一个新的元素

举例说明：

public class streamDemo1 {
    public static void main(String[] args) {
        Stream.of(7,4,3,4,5,2,1,9,8,6)
                .distinct()//去重得到7，4，3，5，2，1，9，8，6
                .sorted((a,b)->{//排序得到9，8，7，6，5，4，3，2，1
                    return b-a;
                })
                .filter((e)->{//过滤得到9，8，7，6
                    return e>5;
                })
                .forEach((e)->{
                    System.out.println(e);//遍历
                });
    }
}

实现分页：

public class streamDemo2 {
    public static void main(String[] args) {
        //skip+limit实现分页功能
        for (int i = 0; i < 8; i+=2) {
            Stream.of(1, 2, 3, 4, 5, 6, 7, 8)
                    .skip(i)//跳过n个元素
                    .limit(3)//限制大小
                    .forEach((e) -> {
                        System.out.print(e);
                    });
            System.out.println();
        }
    }
}

终端操作

流的终端操作

forEach	遍历流中的元素
toArray	将流中的元素倒入一个数组
Min	返回流中元素最小值
Max	返回流中元素最大值
count	返回流中元素的总个数
Reduce	所有元素求和
anyMatch	接收一个 Predicate 函数，只要流中有一个元素满足条件则返 回 true，否则返回 false
allMatch	接收一个 Predicate 函数，当流中每个元素都符合条件时才返 回 true，否则返回 false
findFirst	返回流中第一个元素
collect	:将流中的元素倒入一个集合,Collection 或 Map

重点说明collect方法：

        数据分组就是将流中的元素按照指定的条件分开保存，类似与SQL语言中的"GROUP BY"关键字，分组后的数据会按照不同的标签分别保存成一个集合，然后按照"键-值"关系封装在Map对象中。

public class streamDemo4 {
    public static void main(String[] args) {
        Student s1 = new Student(1, "t1", "男");
        Student s2 = new Student(2, "t2", "女");
        Student s3 = new Student(3, "t3", "男");
        Student s4 = new Student(4, "t4", "女");
        List<Student> list = new ArrayList<>();
        list.add(s2);
        list.add(s4);
        list.add(s1);
        list.add(s3);
        Map<Integer, String> map = list.stream()
        .sorted((a, b) -> {
                    return a.getId() - b.getId();
                })
        .collect(Collectors.toMap(Student::getId, Student::getName));
        System.out.println(map);
    }
}

以上代码实现的是按照学号排序，并且转为Map集合按照学号与姓名进行键值对的映射关系 

运行结果为：{1=t1, 2=t2, 3=t3, 4=t4}