Lambda&Stream

Lambda&Stream

- 能够掌握Lambda表达式的标准格式与省略格式(重点)
    作用:简化函数式接口的匿名内部类	
	()->{
   }
	(参数)->{
   重写接口中的抽象方法的方法体}
	(int a,int b)->{
   }==>省略数据类型 (a,b)->{
   }
	(int a)->{
   }==>省略数据类型 a->{
   }
	a->{
   只有一行代码}==>a->代码(return ; {
   } 一起省略)
- 能够通过集合、映射或数组方式获取流(重点)
	Collection集合中方法default Stream<E> stream()直接把集合转换为Stream流
		ArrayList<Integer> list = new ArrayList<>();
        Stream<Integer> stream1 = list.stream();
	Stream接口中的静态方法static <T> Stream<T> of(T... values) 把数组转换为Stream流
		Stream<Integer> stream1 = Stream.of(1, 2, 3, 4, 5, 6, 7, 8);
		String[] arr1 = {
   "a", "b", "c"};
        Stream<String> stream3 = Stream.of(arr1);
- 能够掌握常用的流操作(重点)
	forEach:遍历
	count:统计个数
	filter:过滤
	limit:获取前n个
	skip:跳过前n个
	map:映射,把一种数据类型转换为另外一种数据类型
	concat:组合 把两个流组合为一个流
- 能够将流中的内容收集到集合和数组中(重点)
	List<String> list = stream.collect(Collectors.toList());
	Set<String> set = stream.collect(Collectors.toSet());
	Object[] arr = stream.toArray();

第一章 Lambda表达式

1.函数式编程思想概述

面向对象思想:

​ 做一件事情,找一个能够解决这个事情的对象,调用对象的方法来完成这件事情

函数式编程思想:

​ 重视的是结果,怎么做事情,不重视完成的过程,找谁来做

2.使用Lambda表达式简化多线程匿名内部类(重点)

package com.itheima.demo01Lambda;

/*
    使用Lambda表达式简化多线程匿名内部类(重点)
 */
public class Demo01Lambda {
   
    public static void main(String[] args) {
   
        //使用匿名内部类的方式创建一个线程
        new Thread(new Runnable() {
   
            @Override
            public void run() {
   
                System.out.println(Thread.currentThread().getName()+"线程,正在执行线程任务!");
            }
        }).start();

        //使用Lambda表达式,简化匿名内部类
        new Thread(()->{
   
            System.out.println(Thread.currentThread().getName()+"线程,正在执行线程任务!");
        }).start();
    }
}

3.Lambda表达式的语法(重点)

Lambda表达式的语法:

​ 由一些参数,一个箭头,一些代码组成

格式:

​ (参数列表)->{重写抽象方法的方法体}

Lambda表达式作用:简化函数式接口的匿名内部类

lambda表达式使用前提:必须有接口,接口中有且只能有一个抽象方法(函数式接口)

Lambda表达式是可推导,可省略:能推导出来,Lambda表达式重写的就是接口中唯一的抽象方法

• (参数列表):重写抽象方法的参数
• ->:传递(固定写法):可以把参数传递到方法体中使用
• {}:重写抽象方法的方法体

Lambda表达式的基本格式
	( )->{
    }   Runnable接口-->public abstract void run();
	一些参数,一个箭头,一些代码
	():重写接口中唯一抽象方法的参数列表,没有参数就空着,有多个参数使用逗号隔开
	->:传递,可以把参数传递给{
    }方法体使用
	{
    }:重写接口中唯一抽象方法的方法体
Lambda表达式的使用前提:
	1.必须有接口
	2.接口中只能有且仅有一个抽象方法(函数式接口)     
注意:
	Lambda表达式是可推导可省略
	Lambda表达式的目的就是重写接口中唯一的抽象方法
	接口的方法只有一个,可以推导出重写的就是接口中唯一的抽象方法,所以可以简化代码   

4.使用Lambda表达式重写有参数有返回值的方法(重点)

需求:
创建一个数组,数组的类型使用Person
创建3个Person对象,存储到数组中
使用Arrays数组工具类中的方法sort,根据比较器产生的规则对Person对象进行排序(年龄升序)

package com.itheima.demo01Lambda;

import java.util.Arrays;
import java.util.Comparator;

/*
    使用Lambda表达式重写有参数有返回值的方法(重点)
    需求:
        创建一个数组,数组的类型使用Person
        创建3个Person对象,存储到数组中
        使用Arrays数组工具类中的方法sort,根据比较器产生的规则对Person对象进行排序(年龄升序)
    java.util.Arrays:数组工具类
        static <T> void  sort(T[] a, Comparator<? super T> c)
            根据指定比较器产生的顺序对指定对象数组进行排序。
 */
public class Demo02Lambda {
   
    public static void main(String[] args) {
   
        //创建一个数组,数组的类型使用Person
        Person[] arr = new Person[3];
        //创建3个Person对象,存储到数组中
        arr[0] = new Person("关羽",28);
        arr[1] = new Person("刘备",38);
        arr[2] = new Person("张飞",18);
        //使用Arrays数组工具类中的方法sort,根据比较器产生的规则对Person对象进行排序(年龄升序)
        Arrays.sort(arr, new Comparator<Person>() {
   
            @Override
            public int compare(Person o1, Person o2) {
   
                //排序的规则 o1-o2:升序  o2-o1:降序
                return o1.getAge()-o2.getAge();
            }
        });
        //遍历数组
        for (Person p : arr) {
   
            System.out.println(p);
        }
        //使用Lambda表达式,简化Comparator接口的匿名内部类
        Arrays.sort(arr,(Person o1,Person o2)->{
   
            //根据年龄降序排序
            return o2.getAge()-o1.getAge();
        });
        System.out.println("---------------------------------------");
        //遍历数组
        for (Person p : arr) {
   
            System.out.println(p);
        }
    }
}

package com.itheima.demo01Lambda;

public class Person {
   
    private String name;
    private int age;

    public Person() {
   
    }

    public Person(String name, int age) {
   
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
   
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
   
        return name;
    }

    public void setName(String name) {
   
        this.name = name;
    }

    public int getAge() {
   
        return age;
    }

    public void setAge(int age) {
   
        this.age = age;
    }
}

5.Lambda表达式简化格式

Lambda表达式使用前提:有接口,接口中有且仅有一个抽象方法(函数式接口)
Lambda表达式是可推导,可以省略的
可以推导出,Lambda表达式重写的就是接口中唯一的抽象方法
也可以推导出方法的参数和方法有没有返回值,可以可以对参数和返回值在进行简化
格式:
	(参数列表)->{
   重写抽象方法的方法体}
简化:
	1.(参数列表):参数列表的数据类型是可以推导出来的,可以省略
		(int a)-->(a)
		(int a,String s)-->(a,s)
	2.(参数列表):参数列表中只有一个参数,()小括号也可以省略,但是参数列表没有参数,()小括号不能省略
		(int a)-->(a)-->a
		(int a,String s)-->a,s 错误,两个或者两个以上的参数不能省略()
		()-->不能省略-->(