Java Day24

第一章 Stream流

1.1 引言

1.1.1 传统的集合的遍历代码

几乎所有的集合都支持直接或者间接的遍历操作。而当我们需要对集合中的元素进行操作的时候，除了必须的添加、删除、获取外，最典型的就是集合的遍历。例如：

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

public class Demo01List {
    public static void main(String[] args) {
        // 创建一个List集合，存储姓名
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        // 对list集合中的元素进行过滤，只要以张开头的元素，存储到一个新的集合中
        List<String> listA = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("张")) {
                listA.add(s);
            }
        }

        // 对listA集合进行过滤，只要姓名长度为3的人，存储到一个新的集合中
        List<String> listB = new ArrayList<>();
        for (String s : listA) {
            if (s.length() == 3) {
                listB.add(s);
            }
        }

        for (String s : listB) {
            System.out.println(s);
        }
    }
}

1.1.2 循环遍历的弊端

Java 8 的lambda让我们可以更加专注于做什么，而不是怎么做，使用Stream流来优化上述代码：

*
* 使用Stream流的方式，遍历集合，对集合中的数据进行过滤
* Stream流是JDK1.8之后出现的
* 关注的是做什么，而不是怎么做
* */

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

public class Demo02Stream {
    public static void main(String[] args) {
        // 创建一个List集合，存储姓名
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        // 对list集合中的元素进行过滤，只要以张开头的元素，存储到一个新的集合中
        // 对listA集合进行过滤，只要姓名长度为3的人，存储到一个新的集合中
        //遍历集合listB
        list.stream().filter(name->name.startsWith("张")).filter(name->name.length()==3).forEach(name-> System.out.println(name));
    }
}

1.2 流水思想概述

• 整体来看，流思想类似于工厂车间的“生产流水线”，当需要对多个元素进行操作的时候，考虑到性能及遍历性，我们应该首先拼好一个模型“步骤”方案，然后再按照方案去执行它。
• Stream流是一个来自数据源的元素队列
  • 元素是特定类型的对象，形成一个队列。Java中的Stream并不会存储元素，而是按需计算。
  • 数据源：流的来源。
• 和以前的Collection操作不同，Stream操作还有两个基础的特征：
  • pipelining：中间操作都会返回流对象本身，这样多个操作可以串联盛一个管道，如同流式风格，这样做可以对操作进行优化，比如延迟执行和短路。
  • 内部迭代：以前对集合遍历都是通过iterator或者增强for循环的方式，显式的在集合外部进行迭代，这叫做外部迭代。Stream提供了内部迭代的方式，流可以直接调用遍历方法。

当我们使用一个流的时候，通常包括三个基本步骤：获取一个数据源（source）------数据转换-------执行操作获取想要的结果，每次转换原有的Stream对象不改变，返回一个新的Stream对象，这就允许对其操作可以像链条一样排列，变成一个管道。

1.3 获取流

• 获取一个流通常有两种方式：
  • 所有的Collection集合都可以通过stream默认方法获取流。
  • Stream接口的静态方法of可以获取数组对应的流。
  • 代码演示如下：

/*
* java.util.stream.Stream<T>是Java 8新加入的最常用的流接口。这并不是一个函数式接口
* 获取一个流非常简单，有以下集中常用的方式：
*   所有的Collection集合都可以通过Stream默认方法获取流
*       default Stream<E> stream()
*   Stream接口的静态方法of可以获取数组对应的流
*       参数是一个可变参数，那么我们就可以传递一个数组
*
* */

import java.util.*;
import java.util.stream.Stream;

public class Demo02GetStream {
    public static void main(String[] args) {
        // 把集合转换为Stream流
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

        Set<String> set = new HashSet<>();
        Stream<String> stream2 = set.stream();

        Map<String, String> map = new HashMap<>();
        // 获取键，存储到一个Set集合中
        Set<String> set1 = map.keySet();
        Stream<String> stream3 = set1.stream();

        // 获取值，存储到一个Collection集合中
        Collection<String> values = map.values();
        Stream<String> stream4 = values.stream();

        // 获取键值对（键与值的映射关系 entrySet）
        Set<Map.Entry<String, String>> entries = map.entrySet();
        Stream<Map.Entry<String, String>> stream5 = entries.stream();

        // 把数组转换为Stream流
        Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
        // 可变参数可以传递数组
        Integer[] arr = {1, 2, 3, 4, 5};
        Stream<Integer> stream7 = Stream.of(arr);
        String[] arr2 = {"a", "bb", "ccc"};
        Stream<String> stream8 = Stream.of(arr2);


    }
}

1.4常用方法

• 流模型的常用方法被分为两类：
  • 延迟方法：返回值类型仍然是Stream接口自身类型的方法，因此支持链式调用。
  • 终结方法：返回值类型不再是Stream接口自身类型的方法，因此不再支持类似StringBuilder那样的链式调用。

1.4.1 forEach

forEach：

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

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

代码演示：

/*
* Stream流中的常用方法 forEach
* void forEach(Consumer<? super T> action);
* 该方法接收一个Consumer接口函数，会将一个流元素交给该函数进行处理
* Consumer接口是一个消费型的函数式接口，可以传递Lambda表达式，消费数据
*
* 简单记：
*   forEach方法，用来遍历流中的数据
*   是一个终结方法，遍历之后就不能继续调用Stream流中的其他方法
*
* */

import java.util.stream.Stream;

public class Demo02StreamForEach {
    public static void main(String[] args) {
        // 获取一个Stream流
        Stream<String> stream = Stream.of("张三", "李四", "赵六", "田七");

        // 使用Stream流中的方法forEach对Stream流中的数据进行遍历
//        stream.forEach((String name)->{
//            System.out.println(name);
//        });

        // 优化lambda表达式
        stream.forEach(name-> System.out.println(name));

    }
}

1.4.2 过滤：filter

通过filter方法将一个流转换成另一子集流：

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

该方法接收一个Predicate函数式接口参数作为筛选条件。

代码演示：

/*
* Stream流中的常用方法filter：用于对Stream流中的数据进行过滤
* Stream<T> filter(Predicate<? super T>) predicate);
* filter方法的参数Predicate是一个函数式接口，所以可以传递Lambda表达式，对数据进行过滤
* Predicate中的抽象方法
*   boolean test(T t)
*
* Stream流属于管道流，只能被消费（使用）一次
* 第一个Stream流调用完毕方法，数据就会流转到下一个Stream上
* 而这时第一个Stream流已经使用完毕，就会关闭了
* 所以第一个Stream流就不能再调用方法了
* */

import java.util.stream.Stream;

public class Demo03StreamFilter {
    public static void main(String[] args) {
        // 穿件一个Stream流
        Stream<String> stream = Stream.of("张三丰", "张翠山", "赵敏", "周芷若", "张无忌");

        // 对Stream流中的元素进行过滤
        stream.filter(name->name.startsWith("张")).forEach(name-> System.out.println(name));
    }
}

1.4.3 映射：map

如果要将一个流中的元素映射到另一流中，可以使用map方法：

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

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

代码演示：

/*
* 如果需要将流中的元素映射到另一个流中，可以使用map方法，
* <R> Stream<R> map(Function<? super T, ? extends R> mapper);
* 该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流
* Function中的抽象方法：
*   R apply(T t);
*
* */

import java.util.stream.Stream;

public class Demo04StreamMap {
    public static void main(String[] args) {
        // 获取一个String类型Stream流
        Stream<String> stream = Stream.of("1", "2", "3", "4");

        // 使用map方法，把字符串类型的整数，转换（映射）为Integer类型的整数
        stream.map((String s)->{return Integer.parseInt(s);}).forEach(i-> System.out.println(i));
    }
}

1.4.4 统计个数：count

和集合Collection中的size方法一样，流提供count方法来数一数其中的元素个数：

long count();

代码演示如下：

/*
* Stream流中的常用方法count：用于统计Stream流中元素的个数
* long count();
* count方法是一个终结方法，返回值是一个long类型的整数
* 所以不能再继续调用Steam流中的其他方法了
*
* */

import java.util.ArrayList;

public class Demo05StreamCount {
    public static void main(String[] args) {
        // 获取一个Stream流
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        long size = list.stream().count();
        System.out.println(size);

    }
}

1.4.5 取用前几个：limit

limit方法可以对流进行截取，只需用前n个：

Stream<T> limit(long maxSize);

代码演示：

/*
* Stream流中的常用方法limit：用于截取流中的元素
* limit方法可以对流进行截取，只取用前n个，方法签名：
* Stream<T> limit(long maxsize);
*   参数是一个long型，如果集合当前长度大于参数则进行截取，否则不进行操作
* limit方法是一个延迟方法，只是对流中的元素进行截取，返回的是一个新的流，所以可以继续调用Stream流中的其他方法
*
* */

import java.util.stream.Stream;

public class Demo06StreamLimit {
    public static void main(String[] args) {
        // 获取一个Stream流
        String[] arr = {"美羊羊", "喜羊羊", "懒羊羊", "灰太狼", "红太狼"};
        Stream<String> stream = Stream.of(arr);

        // 使用limit对Stream流中的元素进行截取，只要前三个元素
        stream.limit(3).forEach(name-> System.out.println(name));

    }
}

1.4.6 跳过前几个：skip

如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流：

Stream<T> skip(long n);

代码演示：

/*
* Stream流中的常用方法，skip：用于跳过元素
* 如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流：
* Stream<T> skip(long n);
*   如果流的当前长度大于n，则跳过前n个，否则将会得到一个长度为0的空流
*
* */

import java.util.stream.Stream;

public class Demo07StreamSkip {
    public static void main(String[] args) {
        // 获取一个Stream流
        String[] arr = {"美羊羊", "喜羊羊", "懒羊羊", "灰太狼", "红太狼"};
        Stream<String> stream = Stream.of(arr);

        // 使用skip方法跳过前三个元素
        stream.skip(3).forEach(name-> System.out.println(name));
    }
}

1.4.7 组合：concat

如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat：

static <T> Stream<T> concat(Stream<? extends T>a, Stream<? extends T> b)

代码演示：

/*
* Stream流中的常用方法concat：用于把流组合到一起
* 如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat
* static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
*
*
* */

import java.util.stream.Stream;

public class Demo08StreamConcat {
    public static void main(String[] args) {
        // 穿件一个Stream流
        Stream<String> stream = Stream.of("张三丰", "张翠山", "赵敏", "周芷若", "张无忌");
        // 获取一个Stream流
        String[] arr = {"美羊羊", "喜羊羊", "懒羊羊", "灰太狼", "红太狼"};
        Stream<String> stream1 = Stream.of(arr);

        // 把上面两个流组合为一个流
        Stream.concat(stream, stream1).forEach(name-> System.out.println(name));

    }
}

1.5 练习：集合元素处理

代码演示：

定义Person类：

public class Person {
    private String name;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

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

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

定义测试类：

//题目
//        现在有两个 ArrayList 集合存储队伍当中的多个成员姓名，要求使用传统的for循环（或增强for循环）依次进行以
//        下若干操作步骤：
//        1. 第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
//        2. 第一个队伍筛选之后只要前3个人；存储到一个新集合中。
//        3. 第二个队伍只要姓张的成员姓名；存储到一个新集合中。
//        4. 第二个队伍筛选之后不要前2个人；存储到一个新集合中。
//        5. 将两个队伍合并为一个队伍；存储到一个新集合中。
//        6. 根据姓名创建 Person 对象；存储到一个新集合中。
//        7. 打印整个队伍的Person对象信息。

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

public class Demo02Stream {
    public static void main(String[] args) {
        //第一支队伍
        ArrayList<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石中玉");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");
        Stream<String> oneStream = one.stream();
        Stream<String> oneStream2 = oneStream.filter(name -> name.length() == 3).limit(3);


        //第二支队伍
        ArrayList<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");
        Stream<String> twoStream = two.stream();
        Stream<String> twoStream1 = twoStream.filter(name -> name.startsWith("张")).skip(2);

        Stream<String> names = Stream.concat(oneStream2, twoStream1);
        names.map(name->new Person(name)).forEach(name-> System.out.println(name));
    }
}

第二章 方法的引用

2.1 方法引用符

双冒号::为引用符，而它所在的表达式被称为方法引用，如果Lambda表达式要表达的函数方案已经存在于某个方法的实现中，那么则可以通过双冒号来引用该方法作为lambda的代替者。

2.2 推导与省略

如果使用lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式——它们都将被自动推导，而如果是方法引用，也是同样可以根据上下文进行推导。

函数式接口是lambda，而方法引用是lambda的孪生兄弟。

2.3 通过对象名引用成员方法

定义一个类：

public class MethodRerObject {
    // 定义一个成员方法，传递字符串，把字符串按照大写输出
    public void printUpperCaseString(String str) {
        System.out.println(str.toUpperCase());
    }
}

定义一个函数式接口：

/*
* 定义一个打印的函数式接口
* */

@FunctionalInterface
public interface Printable {
    // 定义打印字符串的抽象方法
    void print(String s);
}

那么当需要使用这个printUpperCase成员方法来替代Printable接口的lambda的时候，已经具有了MethodRefObject类的对象实例，则可以通过对象名引用成员方法，代码为：

/*
* 通过对象名引用成员方法
* 使用前提是对象名是已经存在的，成员方法也是已经存在
* 就可以使用对象名来引用成员方法
* */

public class Demo01ObjectMethodReference {
    // 定义一个方法，方法的参数传递Printable接口
    public static void printString(Printable p) {
        p.print("Hello");
    }

    public static void main(String[] args) {
        // 调用printString方法，方法的参数Printable是一个函数式接口，所以可以传递lambda表达式
        printString((s)->{
            // 创建MethodRerObject对象
            MethodRerObject obj = new MethodRerObject();

            // 调用MethodRerObject对象中的成员方法printUpperCaseString，把字符串按照大写输出
            obj.printUpperCaseString(s);
        });

        /*
        * 使用方法引用优化lambda
        * 对象是已经存在的MethodRerObject
        * 成员方法也是已经存在的printUpperCaseString
        * 所以我们可以使用对象名引用成员方法
        * */
        // 创建MethodRerObject对象
        MethodRerObject obj = new MethodRerObject();
        printString(obj::printUpperCaseString);
    }

}

2.4 通过类名称引用静态方法

定义一个函数式接口：

@FunctionalInterface
public interface Calcable {
    // 定义一个抽象方法，传递一个整数，对整数进行绝对值计算并返回
    int calsAbs(int number);
}

定义一个测试类：

/*
* 通过类名引用静态成员方法
* 类已经存在，静态成员方法也已经存在
* 就可以通过类名直接引用静态成员方法
*
* */

public class Demo01StaticMethodReference {
    // 定义一个方法，方法的参数传递要计算绝对值整数，和函数式接口Calcable
    public static int method(int number, Calcable c) {
        return c.calsAbs(number);
    }

    public static void main(String[] args) {
        // 调用method方法，传递计算绝对值的整数，和lambda表达式
        int abs = method(-10,(n)->{
            // 对参数进行绝对值的计算并返回结果
            return Math.abs(n);
        });
        System.out.println(abs);

        /*
        * 使用方法引用优化lambda表达式
        * Math类是存在的
        * abs计算绝对值的静态方法也是已经存在的
        * 所以我们可以直接通过类名引用静态方法
        * */
        System.out.println(method(-10,Math::abs));
    }

}

2.5 通过super引用成员方法

如果存在继承关系，当lambda中需要出现super调用时，也可以使用方法引用替代，首先是函数式接口：

/*
* 定义见面的函数式接口
*
* */

@FunctionalInterface
public interface Greetable {
    // 定义一个见面的方法
    void greet();

}

然后是父类Human内容：

/*
* 定义父类
*
* */

public class Human {
    // 定义一个sayHello方法
    public void sayHello() {
        System.out.println("Hello 我是Human!");
    }
}

最后是子类Man的内容：

/*
* 定义子类
*
* */

public class Man extends Human {
    // 子类重写父类sayHello的方法

    @Override
    public void sayHello() {
        System.out.println("Hello 我是Man！");
    }

    // 定义一个方法参数传递Greetable接口
    public void method(Greetable g) {
        g.greet();
    }

    public void show() {
        // 调用method方法，方法的参数Greetable是一个函数式接口，所以可以传递lambda
//        method(()->{
//            // 创建父类Human对象
//            Human h = new Human();
//
//            // 调用父类的sayHello方法
//            h.sayHello();
//        });
        // 因为有子父类关系，所以存在一个关键字super，代表父类，所以我们可以直接使用super调用父类的成员方法
//        method(()->super.sayHello());

        /*
        * 使用super引用类的成员方法
        * super是已经存在的
        * 父类的成员方法sayHello也是已经存在的
        * 所以我们可以直接使用super引用父类的成员方法
        * */
        method(super::sayHello);
    }

    public static void main(String[] args) {
        new Man().show();
    }

}

2.6 通过this引用成员方法

this代表当前对象，如果需要使用引用的方法就是当前类中的成员方法，那么可以使用“this::成员方法”的格式来使用方法引用。首先是简单的函数式接口：

/*
* 定义一个富有的函数式接口
* */

@FunctionalInterface
public interface Richable {
    // 定义一个想买啥买啥的方法
    void buy();
}

下面是一个丈夫类：

/*
* 通过this引用本类的成员方法
* */

public class Husband {

    // 定义一个买房子的方法
    public void buyHouse() {
        System.out.println("北京二环内买一套四合院");
    }

    // 定义一个结婚的方法，参数传递Richable接口
    public void marry(Richable r) {
        r.buy();
    }

    // 定义一个非长高兴的方法
    public void soHappy() {
        // 调用结婚的方法，方法的参数Richable是一个函数式接口，传递lambda表达式
//        marry(()->{
//            // 使用this.成员方法调用本类买房子的方法
//            this.buyHouse();
//        });

        /*
        * 使用方法引用优化lambda表达式
        * this是已经存在的
        * 本类的成员方法buyHouse也是已经存在的
        * 所以我们可以直接使用this引用本类的成员方法buyHouse
        * */
        marry(this::soHappy);
    }

    public static void main(String[] args) {
        new Husband().soHappy();
    }

}

2.7 类的构造器引用

由于构造器的名称与类名完全一样，并不固定，所以构造器引用使用 类名称::new 的格式表示，首先是一个简单的Person类：

public class Person {
    private String name;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

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

然后是用来创建Person对象的函数式接口：

/*
* 定义一个创建Person对象的函数式接口
*
* */


@FunctionalInterface
public interface PersonBuilder {
    // 定义一个方法，根据传递的姓名，创建Person对象返回
    Person builderPerson(String name);
}

使用这个函数式接口：

/*
* 类的构造器（构造方法）引用
*
* */

public class Demo {
    // 定义一个方法，参数传递姓名和PersonBuilder,方法中通过姓名创建Person对象
    public static void printName(String name, PersonBuilder pb) {
        Person person = pb.builderPerson(name);
        System.out.println(person.getName());
    }

    public static void main(String[] args) {
        // 调用printName方法，方法的参数PersonBuilder接口是一个函数式接口，可以传递lambda
        printName("迪丽热巴", (String name)->{
            return new Person(name);
        });

        /*
        * 使用方法引用优化lambda表达式
        * 构造方法new Person(String name) 已知
        * 创建对象已知 new
        * 接口一使用Person引用new创建对象
        * */
        printName("迪丽热巴", Person::new);  // 使用Person类的带参构造方法，通过传递的姓名创建对象
    }
}

2.8 数组的构造器引用

数组也是Object的子类对象，所以同样具有构造器，只是语法有些不同，需要一个函数式接口：

/*
* 定义一个创建数组的函数式接口
*
* */

@FunctionalInterface
public interface ArrayBuilder {
    // 定义一个创建int类型数组的方法，参数传递数组的长度，返回创建好的int类型数组
    int[] builderArray(int length);
}

使用数组的构造器引用：

/*
* 数组的构造器引用
* */

public class Demo {
    /*
    * 定义一个方法
    * 方法的参数传递创建数组的长度和ArrayBuilder接口
    * 方法内部更具传递的长度使用ArrayBuilder中的方法创建数组并返回
    * */
    public static int[] createArray(int length, ArrayBuilder ab) {
        return ab.builderArray(length);
    }

    public static void main(String[] args) {
        // 调用createArray方法，传递数组的长度和lambda表达式
        int[] arr1 = createArray(10, (len)->{
            // 根据数组的长度创建数组并返回
            return new int[len];
        });
        System.out.println(arr1.length);

        /*
        * 使用方法引用优化lambda
        * 已知创建的int[]数组
        * 数组长度也是已知的
        * 就可以使用方法引用
        *
        * int[]引用new，根据参数传递的长度来创建数组
        *
        * */
        int[] arr2 = createArray(20, int[]::new);
        System.out.println(arr2.length);
    }

}