一、Lambda

1.1需求分析

创建一个线程，指定线程要执行的任务：

package jdk8.jdk8;

public class lambdaText01 {
    public static void main(String[] args) {
        //开启一个新线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("新线程中执行的代码:" + Thread.currentThread().getName());
            }
        }).start();

        System.out.println("主线程的代码：" + Thread.currentThread().getName());
    }
}

代码分析：

1、Thread类需要一个Runnable接口作为参数，其中的抽象方法run方法是用来指定线程任务内容的核心；

2、为了指定run方法体，不得不需要Runnable的实现类；

3、为了省去定义一个Runnable的实现类，不得不使用匿名内部类；

4、必须覆盖写抽象的run方法，所有的方法名称，方法参数，方法返回值不得不重写一遍，而且不能出错；

5、而实际上，我们只在乎方法体中的代码（也就是Runnable中的run方法）

2.Lambda表达式的初级体验

针对上面的代码我们进行一个lambda的实现，

Lambda表达式是一个匿名函数，可以理解为一段可以传递的代码

package jdk8.jdk8;

public class lambdaText01 {
    public static void main(String[] args) {
        //开启一个新线程
        //这里用lambda实现的
        new Thread(()->{
            System.out.println("Lambda新线程表达式..." + Thread.currentThread().getName());
        }).start();

        System.out.println("主线程的代码：" + Thread.currentThread().getName());
    }
}

Lambda表达式的优点：

简化了匿名内部类的使用

，语法更加简单。

匿名内部类语法冗余，体验了lambda表达式后，发现lambda表达式是简化匿名内部类的一种方式。

3.Lambda表达式的语法规则

Lambda省去了面向对象的一些条条框框（如：访问类型，函数类型…等），Lambda的标准格式由三部分组成：

（参数类型 参数名称）-> {
	代码体；
}

格式说明：

• （参数类型 参数名称）：参数列表
• {代码体}：方法体
• ->:箭头，分割参数列表和方法体

3.1.Lambda练习1

练习无参无返回值的Lambda

首先定义了一个接口：

package jdk8.jdk8.service;

@FunctionalInterface
public interface Userservice {
    void show();
}

随后创建一主方法运用：

package jdk8.jdk8;

import jdk8.jdk8.service.Userservice;

public class lambdaText02 {
    public static void main(String[] args) {
        //匿名内部类的实现
        goShow(new Userservice() {
            @Override
            public void show() {
                System.out.println("show 方法执行成功");
            }
        });
        System.out.println("-------------------------------");
        //lambda的实现
        goShow(()->{
            System.out.println("Lambda show 方法执行成功");
        });
    }

    public static void goShow(Userservice userservice){
        userservice.show();
    }
}

输出结果：

show 方法执行成功
-------------------------------
Lambda show 方法执行成功

3.2.Lambda表达式练习2

完成一个含有参数的Lambda表达式

首先创建一个Person类：

package jdk8.jdk8;

public class Person {
    private String name;

    private Integer age;

    private Integer height;

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

    public Integer getAge() {
        return age;
    }

    public Integer getHeight() {
        return height;
    }

    public String getName() {
        return name;
    }

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

用Lambda对list集合进行排序

package jdk8.jdk8;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class lambdaText03 {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("徐美琪",19,160));
        list.add(new Person("zs",20,170));
        list.add(new Person("lisi",30,165));
        list.add(new Person("mazi",51,180));


        //匿名内部类的实现
        /*Collections.sort(list,new Comparator<Person>(){
            public int compare(Person o1,Person o2){
                return o1.getAge() - o2.getAge();
            }
        });
        for(Person person:list){
            System.out.println(person);
        }*/
        System.out.println("----------------------------");


        //Lambda表达式实现
        Collections.sort(list,(o1,o2)->{
            return o1.getAge() - o2.getAge();
        });
        for(Person person:list){
            System.out.println(person.toString());
        }

    }

}

输出结果：

Person{name='徐美琪', age=19, height=160}
Person{name='zs', age=20, height=170}
Person{name='lisi', age=30, height=165}
Person{name='mazi', age=51, height=180}

4.FunctionalInterfa注解说明

@FunctionalInterface

这是一个标志注解，被该注解修饰的接口，只能声明一个抽象方法

（如果被它修饰的接口，存在的不是一个抽象方法，会报错）

5.Lambda表达式的原理

匿名内部类的本质是在编译时生成一个Class文件（.class)
Lambda表达式在程序运行时候会形成一个类：
	1、在类中新增一个方法，这个方法的方法体就是Lambda表达式中的代码
	2、还会形成一个匿名内部类，实现接口，重写抽象方法
	3、在接口中重写方法会调用新生成的方法

6.Lambda表达式的省略写法

在lambda表达式的标准写法基础上，可以省略写法的规则为：

1、小括号内从参数类型可以省略

2、如果有且只有一个参数，则小括号可以省略

3、如果大括号内有且只有一个语句，可以同时省略大括号，return关键字以及语句分号。

创建两个接口：

package jdk8.jdk8.service;

public interface StudentService {
    String show(String name,Integer Age);
}

package jdk8.jdk8.service;

public interface OrderService {
    void show(String name);
}

测试：

package jdk8.jdk8;

import jdk8.jdk8.service.OrderService;
import jdk8.jdk8.service.StudentService;

public class lambdaText04 {

    public static void main(String[] args) {
        //lambda表达式的完整写法(goStudent)
        goStudent((String name,Integer age)->{
            return name + age + " 666";
        });
        System.out.println("-------------------");
        //省略写法
        goStudent((name,age)->name+age+" 666");
        System.out.println("----------------");

        //lambda表达式完整写法（OrderService)
        goOrder((String name)->{
            System.out.println(name);
        });
        System.out.println("--------------------------");
        //省略写法
        goOrder(name-> System.out.println(name));

    }

    public static void goStudent(StudentService studentService){
        studentService.show("zhangsan",19);
    }

    public static void goOrder(OrderService orderService){
        orderService.show("lisi");
    }

}

输出：

-------------------
----------------
lisi
--------------------------
lisi

7.lambda表达式的使用前提

Lambda表达式的语法是非常简洁的，但是lambda表达式不说随便使用的，使用有几个条件要特别注意：

1、方法的参数或者局部变量必须为接口中才能使用lambda

2、接口中有且仅有一个抽象方法（@FunctionalInterface）


（这里的一个不包括从Object类里继承的方法，由于Object类是所有类的父类，也就是如果一个接口中有Object方法的话，那么这个接口的实现类也实现它就相当于对Object中的方法进行了重写，这里的指的一个抽象方法是这个意思。

比如：Comparator接口中除了有compare方法还有个，equals方法，但仍然可以对Comparator接口进行lambda表达式的使用）





可以我往上面测试案例中加入了equals方法和hashcode方法都没有报错，说明在此没有把它算做接口的“抽象方法”.

8.lambda和匿名内部类的对比

	lambda和匿名内部类的对比
		1、所需类型不一样
			a、匿名内部类的类型可以是类，抽象类或者接口
			b、lambda表达式需要的类型只能是接口
		2、抽象方法的数量不一样
			a、匿名内部类所需的接口中的抽象方法的数量是随意的
			b、lambda表达式所需的接口中只能有一个抽象方法
		3、实现原理不一样
			a、匿名内部类是在编译后形成一个class
			b、lambda表达式是在程序运行的时候动态生成class

二、接口中新增的方法

1、JDK8中接口的新增

在JDK8中接口的新增，之前：

Interface 接口名{


静态常量；

抽象方法；

}

之后对接口做了新增，接口中可以有了默认方法和静态方法

Interface 接口名{


静态常量；

抽象方法；

默认方法；

静态方法；

}

2、默认方法

2.1、为什么增加默认方法

在JDK8以前接口中只能由抽象方法和静态常量，会存在以下问题：

如果接口中新增抽象方法，那么实现类都必须要实现这个抽象方法，非常不利于接口的扩展的。

2.2、接口默认方法的格式

接口中默认方法的语法格式：

interface 接口名{


修饰符 default 返回值类型 方法名{


方法体；

} }

package jdk8.jdk8;

public class Demo01Interface {
    public static void main(String[] args) {
        A b = new B();
        A c = new C();

        System.out.println("-----------------");
        //调用接口中的默认方法
        b.text02();
    }
}

interface A{
    void test01();
    
//A中接口的默认方法
    public default String text02(){
        System.out.println("默认方法已被执行");
        return "hello";
    }
}

class B implements A{
    @Override
    public void test01(){
        System.out.println("实现A接口text01方法");
    }
    public String text02(){
        System.out.println("B重写了A中默认方法");
        return "Bhello";
    }
}

class C implements A{
    public void test01(){

    }
}

2.3接口中默认方法的使用

接口中的默认方法有两种使用方式

1、实现类对默认方法进行重写

2、实现类直接调用接口中的默认方法

3.静态方法

JDK8中为接口新增了静态方法，作用也是为了接口的拓展

3.1语法规则

interface 接口名{


修饰符 static 返回类型 方法名{


方法体；

}}

3.2 静态方法的使用

1、接口中的静态方法在实现类中不能被重写

2、调用的话只能用接口名来调用：接口名.静态方法名（）

package jdk8.jdk8;

public class Demo01Interface {
    public static void main(String[] args) {
        A b = new B();
        A c = new C();

        System.out.println("-----------------");
        //调用接口中的默认方法
        b.text02();
        System.out.println("-------------");
        A.text03();

    }
}

interface A{
    void test01();

    /**
     * 默认方法
     * @return
     */
    public default String text02(){
        System.out.println("默认方法已被执行");
        return "hello";
    }

    /**
     * 接口中的静态方法
     * @return
     */
    public static String text03(){
        System.out.println("A中的静态方法执行了");
        return "xmq";
    }
}

class B implements A{
    @Override
    public void test01(){
        System.out.println("实现A接口text01方法");
    }
    public String text02(){
        System.out.println("B重写了A中默认方法");
        return "Bhello";
    }
}

class C implements A{
    public void test01(){

    }
}

4.俩者的区别

1、默认方法通过实例调用，静态方法通过接口名调用

2、默认方法可以被继承，实现类可以直接调用接口默认方法，也可以重写接口默认方法

3、静态方法不能被继承（都叫它类方法了，当然不能被继承了），实现类不能重写接口的静态方法，但继承关系仍然存在，可以使用接口名调用

三、函数式接口

1.函数式接口的由来

lambda表达式的使用前提是需要有函数式接口，而lambda表达式使用时候不关心接口名，抽象方法名，只关心抽象方法的参数列表返回类型。因此为了

让我们使用lambda表达式更加的方便

，在JDK中提供了大量的函数式接口。

package jdk8.jdk8;

public class Demo01Fun {
    public static void main(String[] args) {
        fun1((arr)->{
            int sum = 0;
            for(int x:arr)
                sum += x;
            return sum;
        });
    }
    static void fun1(Operator operator){
        int[] arr = {1,2,3,4};
        int sum = operator.getSum(arr);
        System.out.println("sum = " + sum);
    }
}

/**
 * 函数式接口
 */
@FunctionalInterface
interface Operator{

    int getSum(int[] arr);

}

2.函数式接口介绍

在JDK中帮我们提供的有函数式接口，主要是在java.util.function 包中。

2.1 Supplier

无参有返回值（生产数据）

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

对Supplier进行个测试

package jdk8.jdk8;

import java.util.function.Supplier;

/**
 * 函数式接口的使用
 */
public class supplierText {
    public static void main(String[] args) {
        printSum(()->{
            int[] arr = {1,5,9,4,8,6,4};
            int sum = 0;
            //对数组求和
            for(int num:arr)
                sum += num;
            return sum;
        });
    }

    /**
     * 
     * @param supplier
     */
    private static void printSum(Supplier<Integer> supplier){
        //无参有返回值
        Integer sum = supplier.get();
        System.out.println("sum = " + sum);
    }
}

2.2 Consumer

有参无返回值（消费数据）使用的时候需要指定一个泛型来定义参数类型

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

使用：将输入的数据统一转换成小写

package jdk8.jdk8;

import java.util.function.Consumer;

public class consumerText {
    public static void main(String[] args) {
        test(msg->{
            System.out.println(msg + "--->转换成小写:" + msg.toLowerCase());
        });
    }

    /**
     * 
     * @param consumer
     */
    private static void test(Consumer<String> consumer){
        consumer.accept("Hello World!!!");
    }
}

默认方法：andThen

如果一个方法的参数和返回值全部都是Consumer类型，那么就可以实现效果，消费一个数据的时候，首先做一个操作，然后再做一个操作，实现组合，而这个方法就是Consumer接口中的default方法andThen，andThen方法返回的是一个Consumer对象，然后再调用accept就可以实现先后操作的效果了

。

下面举例：

package jdk8.jdk8;

import java.util.function.Consumer;

public class consumerText {
    public static void main(String[] args) {

        /*test(msg->{
            System.out.println(msg + "--->转换成小写:" + msg.toLowerCase());
        });*/

        test02(msg1->{
            System.out.println(msg1 + "--->转换成小写:" + msg1.toLowerCase());
        },msg2->{
            System.out.println(msg2 + "--->转换成大写:" + msg2.toUpperCase());
        });

    }

    /**
     *
     * @param consumer
     */
    private static void test(Consumer<String> consumer){
        consumer.accept("Hello World!!!");
    }

    private static void test02(Consumer<String> consumer1,Consumer<String> consumer2){
        String str = "Hello World";
        //consumer1.accept(str);//转小写
        //consumer2.accept(str);//转大写
        consumer1.andThen(consumer2).accept(str);
    }
}

2.3 Function

有参有返回值，

Function接口是根据一个类型的数据得到另一个数据类型的数据，前者称为前置条件，后者称为后置条件

。有参数有返回值。

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
    }

使用例子：传递一个字符串返回一个Integer对象

package jdk8.jdk8;

import java.util.function.Function;

public class functionText {
    public static void main(String[] args) {
        test(msg->{
            return Integer.valueOf(msg);
        });
    }

    /**
     * 传递一个字符串，返回该字符串数字
     * @param function
     */
    private static void test(Function<String,Integer> function){
        Integer apply = function.apply("666");
        System.out.println("apply = " + apply);
    }
}

默认方法andThen：

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

操作：

package jdk8.jdk8;

import java.util.function.Function;

public class functionText {
    public static void main(String[] args) {
        test(msg->{
            return Integer.valueOf(msg);
        },msg2->{
            return msg2 * 10;
        });
    }


    /**
     *可以理解先由function1操作，再由function2操作
     * @param function1
     * @param function2
     */
    private static void test(Function<String,Integer> function1,Function<Integer,Integer> function2){
//        Integer res1 = function1.apply("666");
//        Integer res2 = function2.apply(res1);
//        System.out.println("res2 = " + res2);
        Integer res = function1.andThen(function2).apply("666");
        System.out.println("res = " + res);
    }
}

默认的compose方法顺序和andThen相反

，而静态方法identity则是，输入什么参数就返回什么参数。

2.4 Predicate

有参有返回结果（且返回类型为boolean型）

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
    }

操作：对传入的字符串长度进行个判断

package jdk8.jdk8;

import java.util.function.Predicate;

public class predicateText {
    public static void main(String[] args) {

        test(msg->{
            return msg.length()<6?false:true;
        },"Hello World");
    }

    /**
     *
     * @param predicate
     * @param msg
     */
    private static void test(Predicate<String> predicate, String msg){
        boolean flag = predicate.test(msg);
        System.out.println("flag = " + flag);
    }
}

四、方法引用

1.为什么要用方法引用

1.1 lambda表达式冗余

在使用lambda表达式的时候，也会出现代码冗余的情况。

package jdk8.jdk8.function;

import java.util.function.Consumer;

public class methodRef01 {
    public static void main(String[] args) {

        toSum(arr->{
            int sum = 0;
            for(int num:arr)
                sum += num;
            System.out.println("sum = " + sum);
        });

    }

    /**
     * 对数组进行求和
     * @param arr
     */
    private static void totalSum(Integer[] arr){
        int sum = 0;
        for(int num:arr)
            sum += num;
        System.out.println("sum = " + sum);
    }

    /**
     * 对数据进行”消费“
     * @param consumer
     */
    private static void toSum(Consumer<Integer[]> consumer){
        Integer[] arr = {3,6,6,5,9,7,6,2,3,45};
        consumer.accept(arr);
    }
}

1.2 解决方案

因为在lambda表达式中要执行的代码和我们另一个方法中的代码是一样的，这时就没有必要重写一份逻辑了，这时我们就可以“引用”重复代码。

package jdk8.jdk8.function;

import java.util.function.Consumer;

public class methodRef01 {
    public static void main(String[] args) {

        //:: 方法引用 也是JDK8新的语法
        toSum(methodRef01::totalSum);

    }

    /**
     * 对数组进行求和
     * @param arr
     */
    private static void totalSum(Integer[] arr){
        int sum = 0;
        for(int num:arr)
            sum += num;
        System.out.println("sum = " + sum);
    }

    /**
     * 对数据进行”消费“
     * @param consumer
     */
    private static void toSum(Consumer<Integer[]> consumer){
        Integer[] arr = {3,6,6,5,9,7,6,2,3,45};
        consumer.accept(arr);
    }
}

2 方法引用的语法格式

符号表示： ::

符号说明：

双冒号为方法引用运算符，而它所在的表达式被称为方法引用



应用场景：如果lambda表达式所要实现的方案，已经有其他方法存在相同的方案，那么则可以使用方法引用。


常见的引用方式：

方法引用在JDK8中使用相当灵活，有以下几种方式：

1、InstanceName::methodName

对象::方法名


2、ClassName::staticMethodName

类名::静态方法


3、ClassName::methodName

类名::普通方法


4、ClassName::new

类名::new 调用的构造器


5、TypeName[]::new

String[]::new 调用数组的构造器

2.1 对象名::方法名

package jdk8.jdk8.function;

import java.util.Date;
import java.util.function.Supplier;

public class methodRef02 {
    public static void main(String[] args) {

        Date now = new Date();
        Supplier<Long> supplier = ()-> now.getTime();
        System.out.println("时间: " + supplier.get());

        //再试试通过方法引用的方式进行处理
        Supplier<Long> supplier1 = now::getTime;
        System.out.println("时间: " + supplier1.get());
    }
}

输出结果：

时间: 1666766083734
时间: 1666766083734

方法引用注意事项：

1、被引用的方法，参数要和接口中的抽象方法的参数一样

2、当接口抽象方法有返回值时被引用的方法也必须有返回值

2.2 类名::静态方法名

package jdk8.jdk8.function;

import java.util.function.Supplier;

public class methodRef03 {
    public static void main(String[] args) {
        //获取当前时间（毫秒为单位）
        Supplier<Long> supplier = ()->System.currentTimeMillis();
        System.out.println(supplier.get());  //*1

        //用方法引用测试（currentTimeMillis)是System类中的静态方法
        Supplier<Long> supplier1 = System::currentTimeMillis;
        System.out.println(supplier1.get());  //*2

    }
}

输出：

1666766539050
1666766539051
//从那个*1位置运行到*2位置用了一毫秒

2.3 类名::普通方法

Java面向对象中，类名只能调用静态方法，类名引用实例方法是要有前提的，实际上是拿第一个参数作为方法的调用者。

2.4 类名::构造器

package jdk8.jdk8.function;

import jdk8.jdk8.Person;

import java.util.function.Supplier;

public class methodRef04 {
    public static void main(String[] args) {
        Supplier<Person> supplier = ()->new Person();
        System.out.println(supplier.get());
        //通过引用方法实现
        Supplier<Person> supplier1 = Person::new;
        System.out.println(supplier1.get());
    }
}

2.5 数组::构造器

package jdk8.jdk8.function;

import java.util.function.Function;

public class methodRef05 {
    public static void main(String[] args) {
        Function<Integer,String[]> function = (len)->new String[len];
        String[] s = function.apply(3);
        System.out.println("数组的长度为：" + s.length);
        //使用方法引用的方式
        Function<Integer,String[]> function1 = String[]::new;
        String[] ss = function1.apply(5);
        System.out.println("数组的长度为：" + ss.length);
    }
}

总结

方法引用是对lambda表达式符合特定情况下的一种缩写方式，它使得我们的lambda表达式更加的精简，也可以理解为lambda表达式的缩写形式。

不过需要注意的是方法引用只能引用已经存在了的方法，解决lambda表达式的冗余问题。

五、Stream API

1. 集合处理数据的弊端

当我们需要对集合中的元素进行操作的时候，除了必须的添加删除获取之外，最典型的操作就是集合的遍历（

集合的外部迭代

）。

package jdk8.jdk8.stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class StreamText01 {
    public static void main(String[] args) {
        //定义一个List集合
        List<String> list = Arrays.asList("xmq","zhangsan","mazi","zhanghanzi");
        //1.获取所有姓张的信息
        List<String> list1 = new ArrayList<>();
        for(String s:list){
            if(s.startsWith("zhang"))
            list1.add(s);
        }

        //输出
        for(String s: list1)
            System.out.println("s = " + s);
        System.out.println("----------------------");

        //获取长度大于8的
        List<String> list2 = new ArrayList<>();
        for(String s: list1){
            if(s.length()>8)
                list2.add(s);
        }

        //输出
        for(String s:list2)
            System.out.println("s = " + s);

    }
}

上面的代码根据我们不同的需求总是一次次的循环循环。这时我们希望有更加高效的处理方式，这时我们就可以通过JDK8中提供的Stream API来解决这个问题了（

Stream的内部迭代

）。

Stream有更加优雅的解决方案。

package jdk8.jdk8.stream;

import java.util.Arrays;
import java.util.List;

public class StreamText02 {
    public static void main(String[] args) {
        //定义一个List集合
        List<String> list = Arrays.asList("xmq","zhangsan","mazi","zhanghanzi");
        //1.获取所有姓张的信息
        //2.获取长度大于8的
        //3.输出获取的结果
        list.stream()
                .filter(s->s.startsWith("zhang"))
                .filter(s->s.length()>8)
                .forEach(s-> System.out.println(s));
        System.out.println("-----------------------------");
        //这里可以采用方法引用的方式输出
        list.stream()
                .filter(s->s.startsWith("zhang"))
                .filter(s->s.length()>8)
                .forEach(System.out::println);


    }
}

上面的Stream API的含义：获取流，过滤长度，逐一打印。代码相比于上面的案例显得更加的简介直观。

2. Stream流式思想概述

注意：Stream和IO流（InputStream/OutputStream）没有任何关系。

Stream流式思想类似于工厂车间的“生产流水线”，Stream流

不是一种数据结构

，

不保存数据

，

而是对数据进行加工处理

。Stream可以看作是流水线上的一个工序。

在流水线上，通过多个工序让一个原材料加工成一个商品。




Stream API能让我们快速完成许多复杂的操作，如筛选，切片，映射，查找，去除重复，统计，匹配和归约。

3. Stream 流的获取方式

3.1 根据Collection获取

首先，java.util.Collection接口中加入了default默认方法 stream()，也就是说Collection接口下的所有实现都可以通过stream方法来获取Stream流。



如：

List<String> list = new ArrayList<>();
list.stream();
Set<String> set = new HashSet<>();
set.stream();
.......

但是map接口没有实现Colletion，但是我们可以通过map中的keySet，values，entrySet得到集合然后进行操作。

3.2 根据Stream的of方法

在实际开发中我们不可避免的会操作数组中的数据，由于数组对象不可能添加默认方法，所以Stream提供了静态方法of。

of的俩种形式：

一、

可变参数

的形式（可以传多个同类型T，也可以传T数组）

底层也是通过数组创建流的方式：

public static<T> Stream<T> of(T... values) {
        return Arrays.stream(values);
    }

二、传入单个对象，对单个对象进行Stream流



测试：

package jdk8.jdk8.stream;

import java.util.stream.Stream;

public class StreamText03 {
    public static void main(String[] args) {
        Stream<String> a1 = Stream.of("a1","a2","a3");
        String[] arr1 = {"aa","bb","cc"};
        Stream<String> sarr1 = Stream.of(arr1);
        Integer[] arr2 = {1,2,3};
        Stream<Integer> sarr2 = Stream.of(arr2);
        sarr2.forEach(System.out::println);
        //注意：基本数据类型的数组是不行的；如果是基本数据类型的数组，那么就是整个arr3被当成对象传进去，这和of参数中泛型T有关
        int[] arr3 = {1,2,3};
        Stream.of(arr3).forEach(System.out::println);

    }
}

输出：

1
2
3
[I@4dd8dc3

3.3 数组创建流

你可以使用静态方法Arrays.stream从数组创建一个流。它接受一个数组作为参数。例如，你可以将一个原始类型int的数组转换成一个IntStream。

如下所示：

int[] numbers = {2, 3, 5, 7, 11, 13}; int sum =

Arrays.stream(numbers).sum();

4. Stream常用方法介绍

Stream流模型的操作很丰富，这里介绍一些常用的API，这些方法可以被分为两种：

1、终结方法：返回值类型不再是Stream类型的方法，不再支持链式调用。这里介绍了 count 和 forEach 俩大终结方法。

2、非终结方法：返回值类型仍然是Stream 类型的方法，支持链式调用。（除了终结方法外，其余方法都是非终结的方法）


3、终端方法我在后面打了爱心号

终端操作都是返回一个boolean（allMatch之类的）、void

（forEach）或Optional对象（findAny等）…

Stream 注意事项（重要）

1. Stream只能操作一次(就是流一旦被操作了就不能回头了，上面说Stream好比流水线工序，就好比一个被整了的脸不能回到以前一样）
2. Stream方法返回的最新的流
3. Stream不调用终结方法，中间步骤是不执行的

package jdk8.jdk8.stream;

import java.util.stream.Stream;

public class StreamText04 {
    public static void main(String[] args) {
        Stream<String> sarr1 = Stream.of("a1","xmq","a2","aa");
        sarr1.filter(s->{
            System.out.println("------------");
            return s.contains("a");
        });//没有终结方法，最后没有输出任何东西
    }
}

下面添加上终结方法就有输出了：

package jdk8.jdk8.stream;

import java.util.stream.Stream;

public class StreamText04 {
    public static void main(String[] args) {
        Stream<String> sarr1 = Stream.of("a1","xmq","a2","aa");
        sarr1.filter(s->{
            System.out.println("------------");
            return s.contains("a");
        }).forEach(System.out::println);
        System.out.println("------------------");
    }
}

输出结果：

------------
a1
------------//这里我们也可以发现“xmq”被过滤掉了
------------
a2
------------
aa
------------------

4.1 forEach❤️

forEach用来遍历流中的数据的：

void forEach(Consumer<? super T> action);

该方法接受一个Consumer接口，会将每一个流元素交给函数 accept 处理

package jdk8.jdk8.stream;

import java.util.stream.Stream;

public class forEachText {
    public static void main(String[] args) {
        //这里正常写法
        Stream.of("xmq","love","leyang").forEach(s->System.out.print(s + " "));
        System.out.println();
        //这里用了方法引用
        Stream.of("xmq","leyang").forEach(System.out::println);
    }
}

输出：

xmq love leyang 
xmq
leyang

注意：别把这个当成循环用，所以什么continue，什么break别用，这里参数是Consumer ，用匿名类或者lambda实现，根据里面的 void accept方法，我们想结束该遍历可以return。

4.2 count❤️

Stream 流中的count方法用来统计其中元素的个数（返回一个long值，代表元素的个数）

long count();

package jdk8.jdk8.stream;

import java.util.stream.Stream;

public class countText {
    public static void main(String[] args) {
        long count = Stream.of("shabi","is","you").count();
        System.out.println("count = " + count);//count = 3
    }
}

4.3 filter

filter 方法的作用是用来过滤数据的，返回符合条件的数据



可以通过filter方法将一个流转换成另一个子集流。

Stream filter(Predicate<? super T> predicate);

该接口接受一个Predicate 函数式接口参数

package jdk8.jdk8.stream;

import java.util.ArrayList;
import java.util.List;

public class filterText {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("xmq");
        list.add("a1");
        list.add("bb");
        list.add("aa");

        //这里过滤掉开头为字母a的字符串
        list.stream().filter(s->!s.startsWith("a")).forEach(System.out::println);//xmq bb
    }
}

4.4 limit

limit 方法可以对流进行截取处理，支取前 n 个数据

Stream limit(long maxSize);

package jdk8.jdk8.stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class limitText {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("xmq",19,87));
        list.add(new Student("zs",20,90));
        list.add(new Student("mz",21,79));
        list.add(new Student("ly",20,87));
        //这里对学生成绩进行排序，如果成绩相同按年龄，年龄小的在前，如果年龄还相同，那按名字字典排序
        Collections.sort(list,(stu1,stu2)->{
            if(stu1.score!=stu2.score)
                return stu2.score-stu1.score;
            else if(stu1.age!=stu2.age)
                return stu1.age - stu2.age;
            else
                return stu1.name.compareTo(stu2.name);
        });
        //输出前三名
        list.stream().limit(3).forEach(System.out::println);
    }
}

class Student{
    public String name;//姓名
    public int age;//年龄
    public int score;//成绩

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

    public Student() {
    }

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

注意：如果传递的参数为负数，那么就会报错，如果传递的大于集合的本身长度，那么可以理解为不操作（在原集合中含有的元素上进行工作）

4.5 skip

这个方法可以和limit 相对立，跳过前面几个元素，选取后面的元素

Stream skip(long n);

操作：

package jdk8.jdk8.stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class skipText {
    public static void main(String[] args) {
            List<jdk8.jdk8.stream.Student> list = new ArrayList<>();
            list.add(new jdk8.jdk8.stream.Student("xmq",19,87));
            list.add(new jdk8.jdk8.stream.Student("zs",20,90));
            list.add(new jdk8.jdk8.stream.Student("mz",21,79));
            list.add(new jdk8.jdk8.stream.Student("ly",20,87));
            //这里对学生成绩进行排序，如果成绩相同按年龄，年龄小的在前，如果年龄还相同，那按名字字典排序
            Collections.sort(list,(stu1, stu2)->{
                if(stu1.score!=stu2.score)
                    return stu2.score-stu1.score;
                else if(stu1.age!=stu2.age)
                    return stu1.age - stu2.age;
                else
                    return stu1.name.compareTo(stu2.name);
            });
            //输出不是前三名的学生
            list.stream().skip(3).forEach(System.out::println);//输出mz那个学生
        }
    }

4.6 映射 map 和 flatmap

常用的数据处理工具。

4.6.1 map

如果我们需要将流中的元素映射到另一个流中，我们可以使用map方法（看参数是 Function 接口我们也是比较好理解的）：

Stream map(Function<? super T, ? extends R> mapper);

该方法需要一个Function 函数式接口参数，可以将当前流中的T类型数据转换成另一种R类型的数据。

操作：

package jdk8.jdk8.stream;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Stream;

public class mapText {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String date = in.next();//输入的格式是 年-月-日
        String[] dates = date.split("-");

        List<Integer> list = new ArrayList<>();
        Stream.of(dates).map(Integer::valueOf).forEach(num->list.add(num));//这里用了方法引用的方式，Integer::valueOf
        //Stream.of(dates).map(s->Integer.valueOf(s)).forEach(num->list.add(num));
        //Stream.of(dates).map(s->Integer.valueOf(s)).forEach(System.out::println);

        list.stream().forEach(System.out::println);//这样我们就将年月日三个数字得到了，可以进行操作了
    }
}

4.6.2 flatMap

🎈🎈🎈这里先介绍一下 java.util.Arrays 类下的stream 方法。

该方法可以接收一个数组，产生一个流

。比如说一个单词，经过了一个split 后会产生一个一个字母，从一个产品（String）变成了多产品（String[]），这时候如果你想要其中的单个产品处理，就可以使用 Arrays.stream（由于是有参有返回值，所以是寻Function函数式接口，也就是映射里）这里只是介绍，用起来还是很巧妙的。

注意：这里传递给的参数应该是一个数组

public static Stream stream(T[] array) {


return stream(array, 0, array.length);

}

字符串分割去重案例：



那如果在map后加个distinct会有变化吗，答案是不会的。因为字符串数组各个字符串不相等。

如何实现字符串数组各个字母间的去重呢？

这里再了解一下：flatMap（将各个生成流扁平成一个流，就上面说的单词分割开后成了很多新流，flatMap可以使得这些分割的流扁平成一个流进行操作（Arrays.stream不就会产生新流吗，流作为元素流中流？这不行，所以flatMap帮我们把它们变成一个流））

Stream flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

输出：



😊再来个例题：

给定两个数字列表，如何返回所有的数对呢？例如，给定列表[1, 2, 3]和列表[3, 4]，只返回总和能被3整除的数对呢？

我们先从一个列表元素开始，去选择另一个列表元素合并，先判断条件，再返回结果，最后去重得到答案。

package jdk8.jdk8.stream;

import java.util.stream.Stream;

public class flatMapText {
    public static void main(String[] args) {
        Integer[] arr1 = {1,2,3};
        Integer[] arr2 = {3,4};
        Stream.of(arr1)
                .flatMap(i->Stream.of(arr2)
                        .filter(j->(i+j)%3==0)
                        .map(j->new Integer[]{i,j})
                )
                .distinct()
                .forEach(res->System.out.println(res[0] + " " + res[1]));//输出：2 4
                														       //3 3
    }
}

（这不比俩个for循环看着舒服多了吗）😍😍😍

4.7 sorted

如果需要将数据进行排序，可以使用sorted 方法：

Stream sorted();

Stream sorted(Comparator<? super T> comparator);

第一个就默认为升序，我们来模拟一下第二个（其实和Arrays，Collections中的sort用法类似）

操作：

package jdk8.jdk8.stream;

import java.util.stream.Stream;

public class sortedText {
    public static void main(String[] args) {
        Stream.of(50,67,94,67,85,76,95,94,93,66,84,70)
                .filter(num->num>=70)//筛选不低于70分的
                .sorted((num1,num2)->num2-num1)//排序为降序
                .forEach(System.out::println);//输出看看结果咯
/*	95
	94
	94
	93
	85
	84
	76
	70*/
    }
}

4.8 distinct

如果要去掉重复数据，可以使用distinct方法（这里与SQL中的distinct用法类似，都是排除重复数据）：

Stream distinct();

在上面的sorted 操作基础上进行操作一下：

package jdk8.jdk8.stream;

import java.util.stream.Stream;

public class distinctText {
    public static void main(String[] args) {
        Stream.of(50,67,94,67,85,76,95,94,93,66,84,70)
                .filter(num->num>=70)//筛选不低于70分的
                .sorted((num1,num2)->num2-num1)//排序为降序
                .distinct()//去重
                .forEach(System.out::println);//输出看看结果咯
    }
}/*输出：
95
94
93
85
84
76
70*/

注意：对面自定义对象去重我们需要对Object类中的hashcode和equals方法进行重写。

4.9 match❤️

对数据处理，怎么离得开匹配数据呢？

4.9.1 anyMatch

这个方法可以用来查看流中

是否存在

与之匹配的元素。（返回结果是个boolean型）

这是一个终端条件

boolean anyMatch(Predicate<? super T> predicate);

package jdk8.jdk8.stream;

import java.util.stream.Stream;

public class anyMatchText {
    public static void main(String[] args) {
        String[] name = {"zs","lisi","mary","jack"};
        //查查是否存在首字母是z的姓名
        if(Stream.of(name).anyMatch(s->s.startsWith("z")||s.startsWith("Z")))
            System.out.println("这些人中存在首字母为z/Z的人");
        else
            System.out.println("没找到");
    }
}

4.9.2 allMatch

这和上面差不多，就是检验是否全部元素满足条件。

4.9.3 noneMatch

这与上面相反，就不举例了。就是检验是否没有任何元素满足条件。

4.10 find

4.10.1 findAny

用法比较简单

Optional< T > findAny();

public static void main(String[] args) {
        String[] name = {"ly","zs","mz","mary","xmq","jack","zz","zx","zp"};
        Arrays.stream(name)
                .filter(s->s.startsWith("z"))
                .findAny()
                .ifPresent(System.out::println);//zs
    }

4.10.2 findFirst

与findAny用法类似

4.11 reduce 方法❤️

该方法对数据进行操作也被称为折叠，一段折一段

T reduce(T identity, BinaryOperator< T > accumulator);


这里BinaryOperator是一个函数式接口，继承了BiFunction的抽象方法



R apply(T t, U u)

;

由于就给了一个参数类型T（泛型）

，

那BinaryOperator接口真正继承的方法应该是 T apply(T t,T u);这样的形式。

这个apply 方法第一个参数是上次的结果，第二个参数 u 是新传进去的元素。而reduce 中第一个参数identity 是对 apply方法的第一个参数的一个初始化。

举例：

package jdk8.jdk8.stream;

import java.util.stream.Stream;

public class reduceText {
    public static void main(String[] args) {
        Integer[] arr = new Integer[]{4,5,3,9};
        Integer sum = Stream.of(arr)
                .reduce(0,(num1,num2)->num1 + num2);
        System.out.println("sum = " + sum);
    }
}

还有个没有初始化第一个参数identity 的

Optional< T> reduce(BinaryOperator< T> accumulator);



还是比较直观的，开始是为空的，然后出现把result 赋值后，再apply，所以集合流化应该保证里面元素应该最好大于一个，不然null 就出来了。

可以看到该方法返回是一个Optional 对象，Optional是一个容器（final类），它用来代表着一个值存在还是不存在。（这里就不多介绍了）

Optional 类中有一个ifPresent 方法：

public void ifPresent(Consumer<? super T> action) {
        if (value != null) {
            action.accept(value);
        }
    }//这里value开始是默认为null 的，如果不为空就对它操作，Consumer前面提过了

package jdk8.jdk8.stream;

import java.util.stream.Stream;

public class reduceText02 {
    public static void main(String[] args) {
        Integer[] arr = {3,5,7,1,6,9,8,5};
        //现在求这个数组中的最小数
        Stream.of(arr)
                .reduce(Integer::min)
                .ifPresent(num-> System.out.println("num = " + num));//存在这个数才会输出，不存在啥也不会输出，不存在就不会走这步，刚刚源代码说明了
    }
}

求最大值和最小值方法一样没区别，这里就不演示了。

4.12 map和reduce的组合

4.13 mapToInt

该方法用于映射到数值流（IntStream），具体下面说明

4.13.1 数值流

前面用reduce 进行数值求和，它需要着拆箱和装箱的成本：

Integer sum = Stream.of(arr)
                .reduce(0,(num1,num2)->num1 + num2);

这里需要将Integer类型，拆箱成基本类型然后再求和，不仅影响效率，而且也不够方便。

Stream API提供了原始类型流特化（基本数据类型），专门支持处理数值流的方法。

4.13.1.1 IntStream

JDK8 引入了三个原始类型特化流接口：IntStream、DoubleStream、LongStream，分别将流中的元素特化为int，double，long，从而避免了暗含的装箱成本。


将流转换为特化版本的常用方法是mapToInt、mapToDouble和mapToLong。这些方法和前面说的map方法的工作方式一样，只是它们返回的是一个特化流，而不是Stream< T >。

以IntStream 流为例说明一下，其他俩用法一样（下面说说除了正常流都有以外的几个方法）：

1、 终端方法，就将流元素构成一个数组，然后返回

int[] toArray();

操作：

 public static void main(String[] args) {
        String[] arr = {"33","56","98","45","65","78","32"};
        int[] arr1 = Stream.of(arr)
                .mapToInt(Integer::valueOf)
                .toArray();

        for(int x:arr1)
            System.out.println(x);
    }

2、四个常用的数值运算（这些都是终端方法）：

int sum();

OptionalInt min();

OptionalInt max();

OptionalDouble average();

拿一个操作一下：

public static void main(String[] args) {
        String[] arr = {"33","56","98","45","65","78","32"};
        int sum = Stream.of(arr)
                .mapToInt(Integer::valueOf)
                .sum();
        System.out.println("sum = " + sum);
    }

3、将该原始流转换回对象流

Stream boxed();

由于IntStream里面的map，int->int，那我想转换成别的嘞，还得靠对象流来操作。

操作：

public static void main(String[] args) {
        String[] arr = {"33","56","98","45","65","78","32"};
        IntStream x = Stream.of(arr)
                .mapToInt(Integer::valueOf);
        //划分一下等级，当然也可以前面直接划分，这里只是为了演示一下这个boxed方法
        x.boxed()
                .map(num->{return num>=90?"A":"B";})
                .forEach(System.out::println);
    }

4、数值范围（静态方法，返回值是IntStream）

左闭右开

public static IntStream range(int startInclusive, int endExclusive)

左闭右闭

public static IntStream rangeClosed(int startInclusive, int endInclusive)

操作：

public class rangeOrrangeClosedText {
    public static void main(String[] args) {
        //101以内的素数，不包括101
        IntStream.range(1,101)
                .filter(num->isPrim(num))
                .forEach(System.out::println);
        //101以内的素数，包括101
        IntStream.rangeClosed(1,101)
                .filter(num->isPrim(num))
                .forEach(System.out::println);

    }
    //判断数是否为素数
    private static boolean isPrim(int num){
        if(num<2)
            return false;
        for(int i=2;i*i<num;++i){
            if(num%i==0)
                return false;
        }
        return true;
    }
}

4.14 concat

它是Stream中的静态方法；用来合并俩个不为空的流

public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
        Objects.requireNonNull(a);
        Objects.requireNonNull(b);

        @SuppressWarnings("unchecked")
        Spliterator<T> split = new Streams.ConcatSpliterator.OfRef<>(
                (Spliterator<T>) a.spliterator(), (Spliterator<T>) b.spliterator());
        Stream<T> stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());
        return stream.onClose(Streams.composedClose(a, b));
    }

操作：

public static void main(String[] args) {
        Stream<String> stream1 = Stream.of("a","b","c");
        Stream<String> stream2 = Stream.of("d","e","f");

        Stream.concat(stream1,stream2)
                .forEach(System.out::println);
    }

六、总结

1. 了解了什么是lambda 表达式，lambda 表达式和匿名内部类的区别；
2. 了解了默认方法是个啥，JDK8使得接口里也可以有静态方法了；
3. 介绍了四个函数式接口，Supplier，Consumer，Function，Predicate；
4. 方法引用的概念以及其中的语法格式；
5. 引入了Stream流（遍历数据集的高级迭代器）；
6. 介绍了Stream的常用方法，学习了如何更好的处理数据。
   
   

七、学后练习