Java学习（Stream流,使用Stream流的方式,获取Stream流的方式,Stream流中的常用方法,方法引用）

2022/2/18   2/22
一、Stream流
I/O流主要用来读写
Stream流用来对集合和数组进行简化操作，将集合和数组转换为Stream流，用Stream流中的方法对集合和数组进行操作，用于解决集合和数组的弊端。
1.遍历筛选集合的两种方法对比：

package ln.javatest.day17.demo02;
/*
使用传统的方法，遍历集合，对集合中的数据进行过滤
*/

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集合中的元素进行过滤，只要以开王头的元素，存储到一个新的集合中
        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);
            }
        }
        //遍历listB集合
        for (String s : listB) {
            System.out.println(s);
        }
    }
}

package ln.javatest.day17.demo02;
/*
使用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集合中的元素进行过滤，只要以开王头的元素，存储到一个新的集合中
        //对listA集合进行过滤，只要姓名长度为3的人，存储到一个新集合中
        //遍历listB集合
        /*
        集合中有stream流方法，stream流方法中有一个filter方法（过滤），这个方法中的参数是Predicate接口
        */
        list.stream().filter(name->name.startsWith("王")).filter(name->name.length()==3).forEach(name->System.out.println(name));
    }
}

2.Stream概念
"Stream流"其实是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身你并不存储任何元素（或地址值）。
Stream（流）是一个来自数据源的元素队列
元素是特定类型的对象，形成一个队列。
数据源（流的来源），可以是集合，数组等。

和以前的Collection操作不同，Stream操作还有两个基础的特征：
        Pipolining：中间操作都会返回流对象本身。这样多个操作可以串联成一个管道，如果流式风格。这样做可以对操作进行优化，比如延迟执行和短路。
        内部迭代：以前对集合遍历都是通过Iterator局欧哲增强for的方式，显式的在集合外部进行迭代，这叫做外部迭代。Stream提供了内部迭代的方法，流可以直接调用遍历方法。

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

3.获取流

package ln.javatest.day17.demo02;
/*
java.util.stream.Stream<T>是Java 8新加入的最常用的流接口（这并不是一个函数式接口)
获取一个流非常简单，有一下几种常用的方式：
    所有的Collection集合都可以通过stream默认方法获取流
    Stream接口的静态方法of可以获取数组对应的流
        of方法的参数是一个可变参数，所以我们可以传递一个数组
*/

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

public class Demo02FetStream {
    public static void main(String[] args) {
        //把集合转换为Stream
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();
        //单列集合set
        Set<String> set = new HashSet<>();
        Stream<String> stream2 = set.stream();
        //双列集合Map
        Map<String,String> map = new HashMap<>();
        //获取键，存储到一个set集合中
        Set<String> keySet = map.keySet();
        Stream<String> stream3 = keySet.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,6};
        Stream<Integer> stream7 = Stream.of(arr);
    }
}

4.Stream流中的方法
Stream中的这些方法可以被分成两种：
延迟方法：返回值类型仍然是Stream接口自身类型。因此支持链式调用。（除了终结方法外，其余方法均为延迟方法。）
终结方法：返回值类型不再是Stream接口自身类型的方法，因此不再支持类似StringBuilder 那样的链式调用。终结方法包括count和forEach方法。

1.遍历方法forEach

package ln.javatest.day17.demo02;
/*
Stream流中的常用方法_forEach
void forEach(Consumer<? super T> action);
该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。
Consumer接口是一个消费型的函数式接口，可以传递Lambda表达式，消费数据

简单记：
    forEach方法，用来遍历流中的数据
    是一个终结方法，遍历之后就不能继续调用Stream流中的方法
*/

import java.util.stream.Stream;

public class Demo02Stream_forEach {
    public static void main(String[] args) {
        //获取一个Stream流
        Stream<String> stream = Stream.of("张三", "李四", "王五");
        //使用Stream流中的方法forEach对Stream流中数据进行遍历
        stream.forEach(name-> System.out.println(name));
    }
}

2.过滤方法filter

package ln.javatest.day17.demo02;
/*
Stream流中的常用方法_filter：用于对Stream流中的数据进行过滤
Stream<T> filter(Predicate<? super T> predicate);
filter方法的参数Predicate是一个函数式接口，所以可以传递Lambda表达式，对数据进行过滤
Predicate中的抽象方法:
    boolean test(T t)
*/

import java.util.stream.Stream;

public class Demo03Stream_filter {
    public static void main(String[] args) {
        //创建一个Stream流
        Stream<String> stream = Stream.of("张三", "李四", "王五");
        //对Stream流中的元素进行过滤，只要姓张的人
        //因为filter流是一个延迟流所以可以把筛选过后的数据给到另一个流接着使用
        /*
        Stream流属于管道流，只能被消费（使用）一次
        第一个Stream流调用完毕方法，数据就会流转到下一个Stream上
        而这时第一个Stream流已经使用完毕，就会关闭了
        所以第一个Stream流就不能再调用方法了
        所以要把第一个流使用的结果返回给另一个流再对另一个流进行调用
        */
        Stream<String> stream1 = stream.filter(name -> name.startsWith("张"));
        //遍历stream1流
        stream1.forEach(name-> System.out.println(name));
    }
}

3.映射方法map

package ln.javatest.day17.demo02;
/*
如果需要将流中的元素映射到另一个流中，可以使用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 Demo04Stream_map {
    public static void main(String[] args) {
        //获取一个String类型的Stream流
        Stream<String> stream = Stream.of("1", "2", "3");
        //使用map方法，把字符串类型的整数，转换（映射）为Integer类型的整数
        Stream<Integer> stream1 = stream.map(s -> Integer.parseInt(s));
        //遍历stream1
        stream1.forEach(s-> System.out.println(s));
    }
}

4.统计个数方法count
正如旧集合Collection当中的size方法一样，流提供count方法来数一数其中的元素个数：

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

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

public class Demo05Stream_count {
    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);
        Stream<Integer> stream = list.stream();
        long count = stream.count();
        System.out.println(count);
    }
}

5.截取流中元素的方法limit

package ln.javatest.day17.demo02;
/*
Stream流中的常用方法_limit：用于截取流中的元素
limit方法可以对流进行截取，只取用前几个。方法签名：
Stream<T> limit(long maxSize);
    参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作
limit方法是一个延迟方法（支持链式调用），只是对流中的元素进行截取，返回的是一个新的流，所以可以继续调用Stream流中的其他方法.
*/

import java.util.stream.Stream;

public class Demo06Stream_limit {
    public static void main(String[] args) {
        //获取一个Stream流
        String[] arr = {"王嘉尔","易烊千玺","熊丰"};
        Stream<String> stream = Stream.of(arr);
        //使用limit对Stream流中的元素进行截取，只要前1个元素
        Stream<String> stream2 = stream.limit(1);
        //遍历stream2流
        stream2.forEach(s-> System.out.println(s));

    }

}

6.跳过流中元素的方法skip

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

import java.util.stream.Stream;

public class Demo07Stream_skip {
    public static void main(String[] args) {
        //获取一个Stream流
        String[] arr = {"王嘉尔","易烊千玺","熊丰"};
        Stream<String> stream = Stream.of(arr);
        //使用skip方法跳过前1一个元素
        Stream<String> stream1 = stream.skip(1);
        //遍历stream1流
        stream1.forEach(s-> System.out.println(s));
    }
}

7.合并两个流的方法concat

package ln.javatest.day17.demo02;
/*
Stream流中的常用方法_concat：用于把流组合到一起
如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat
因为是静态方法，所以可以直接接口.方法
*/

import java.util.stream.Stream;

public class Demo08Stream_concat {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1,2,3);
        Stream<Integer> stream1 = Stream.of(4,5,6);
        //把以上两个流组合为一个流
        Stream<Integer> concat = Stream.concat(stream, stream1);
        //遍历concat流
        concat.forEach(s-> System.out.println(s));
    }
}

8.Stream流中的方法练习

package ln.javatest.day17.demo02;
/*
练习：集合元素处理（Stream方式）
用Stream流的方式处理
*/
//1.第一只队伍只要名字为3个字的成员姓名，存储到一个新集合中
//2.第一只队伍筛选后只要前3人，存储到一个新集合中
//3.第二只队伍只要姓张的成员姓名，存储到一个新集合中
//4.第二只队伍筛选之后不要前2个人，存储到一个新集合中
//5.将两个队伍合并为一个队伍，存储到一个新集合中
//6.根据姓名创建一个Person对象，存储到一个新集合中
//7.打印整个队伍的Person对象信息

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

public class Demo02StreamTest {
    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("洪七公");
        //1.第一只队伍只要名字为3个字的成员姓名，存储到一个新集合中
        //2.第一只队伍筛选后只要前3人，存储到一个新集合中
        Stream<String> oneStream = one.stream().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("张二狗");
        //3.第二只队伍只要姓张的成员姓名，存储到一个新集合中
        //4.第二只队伍筛选之后不要前2个人，存储到一个新集合中
        Stream<String> twoStream = two.stream().filter(name -> name.startsWith("张")).skip(2);

        //5.将两个队伍合并为一个队伍，存储到一个新集合中
        //6.根据姓名创建一个Person对象，存储到一个新集合中
        //7.打印整个队伍的Person对象信息
        Stream.concat(oneStream,twoStream).map(name->new Person(name)).forEach(Person-> System.out.println(Person));
    }
}

package ln.javatest.day17.demo02;

public class Person {
    private String name;

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

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

    public Person() {
    }

    public String getName() {
        return name;
    }

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

二、方法引用
1.概念：
在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿什么参数做什么操作。
如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑？

package ln.javatest.day17.demo03;
/*
定义一个打印的函数式接口
*/
@FunctionalInterface
public interface Printable {
    //定义字符串的抽象方法
    void print(String s);
}

package ln.javatest.day17.demo03;

public class Demo01Printable {
    //定义一个方法，参数传递Printable接口，对字符串进行打印
    public static void printString(Printable p){
        p.print("Hello");
    }

    public static void main(String[] args) {
        //调用printString方法，方法的参数Printable是一个函数时接口，所以可以传递Lambda
        printString(s-> System.out.println(s));
        /*
    分析：
        Lambda表达式的目的，打印参数传递的字符串
        把参数s，传递给了System.out对象，调用out对象中的方法println对字符串进行了输出
        注意：
            1.System.out对象是已经存在的
            2.println方法也是已经存在的
        所以我们可以使用方法引用来优化Lambda表达式
        可以使用System.out方法直接引用（调用）println方法
    */
        printString(System.out::println);
    }
    /*
    方法引用符：
    双冒号：：为引用运算符，它所在的表达式被称作方法引用。
    如果Lambda要表达的函数方法已经存在与某个方法的实现中，
    那么则可以通过双冒号来引用该方法作为Lambda的替代者。

    Lambda表达式的语义是：拿到参数之后经Lambda之手，继而传递给System.out.println方法去处理。
    方法引用的语义：直接让System.out中的println方法来取代Lambda。
    注意：
        Lambda中传递的参数一定是方法引用中的那个方法可以接收的类型，否则会抛出异常
    */


}

2.方法引用_通过对象名引用成员方法

package ln.javatest.day17.demo03;
/*
定义一个打印的函数式接口
*/
@FunctionalInterface
public interface Printable {
    //定义字符串的抽象方法
    void print(String s);
}

package ln.javatest.day17.demo03;

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

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

public class Demo01ObjectMethodRerence {
    //定义一个方法，方法的参数传递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对象中的成员方法，把字符串按照大写输出
            obj.printUpperCaseString(s);
        });
        /*
        使用方法引用优化Lambda
        对象是已经存在的MethodRerObject
        成员方法也是已经存在的printUpperCaseString
        所以我们可以使用对象名引用成员方法
        */
        //创建MethodRerObject对象
        MethodRerObject obj1 = new MethodRerObject();
        printString(obj1::printUpperCaseString);
    }

}

3.方法引用_通过类名引用静态成员方法

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

package ln.javatest.day17.demo03;
/*
通过类名引用静态成员方法
类已经存在，静态成员方法也已经存在
就可以通过类名直接引用静态成员方法
*/

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 number = method(-10, n ->
            //对参数进行绝对值计算并返回结果
            Math.abs(n)
        );
        System.out.println(number);
        /*
        使用方法引用优化Lambda表达式
        Math类是存在的
        abs计算绝对值的静态方法也是存在的
        所以我们可以直接通过类名引用静态方法
        */
        int num = method(-10,Math::abs);
        System.out.println(num);
    }
}

4.方法引用_通过super引用父类成员方法

package ln.javatest.day17.demo03;
/*
定义见面的函数式接口
*/
@FunctionalInterface
public interface Greetable {
    //定义一个见面的方法
    void greet();
}

package ln.javatest.day17.demo03;
/*
定义父类
*/

public class FU {
    //定义一个sayHello的方法
    public void sayHello(){
        System.out.println("我是父类");
    }
}

package ln.javatest.day17.demo03;
//定义子类
public class Zi extends FU{
    @Override
    public void sayHello() {
        System.out.println("我是重写的父类方法");
    }
    //定义一个方法参数传递Greetable接口
    public void method(Greetable g){
        g.greet();
    }

    public void show(){
        //调用method方法，方法的参数Greetable是一个函数式接口，所以可以传递Lambda
        /*method(()->{
            //创建父类FU对象
            FU h = new FU();
            //调用父类的sayHello方法
            h.sayHello();
        });*/

        /*//因为有子父类关系，所以存在一个关键字super，代表父类，所以我们可以直接使用super调用父类的成员方法
        method(()->super.sayHello());*/

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

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

5.方法引用_通过this引用本类成员方法

package ln.javatest.day17.demo03;
//定义一个富有的函数式接口
@FunctionalInterface
public interface Richable {
    //定义一个想买什么就买什么的方法
    void buy();
}

package ln.javatest.day17.demo03;
//通过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::buyHouse);
    }

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

6.方法引用_类的构造器（构造方法）引用
由于构造器的名称与类名完全一样，并不固定，所以狗在其引用使用类名称：：new的格式表示

package ln.javatest.day17.demo03;

public class Person {
    private String name;

    public String getName() {
        return name;
    }

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

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

    public Person() {
    }
}

package ln.javatest.day17.demo03;
//定义一个创建Person对象的函数式接口
@FunctionalInterface
public interface PersonBuilder {
    //定义一个方法，根据传递的姓名，创建Person对象返回
    Person builderPerson(String name);
}

package ln.javatest.day17.demo03;
//类的构造器（构造方法）
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)->new Person(name));
        /*
        使用方法引用优化Lambda表达式
        构造方法new Person(String name) 已知
        创建对象已知 new
        就可以使用Person引用new创建对象
        */
        //使用Person类的带参构造方法通过传递的姓名创建对象
        printName("王嘉尔",Person::new);
    }
}

7.方法引用_数组的构造器引用
数组也是Object的子类对象，所以同样具有构造器，只是语法稍有不同。

package ln.javatest.day17.demo03;
//定义一个创建数组的函数式接口
@FunctionalInterface
public interface ArrayBuilder {
    //定义一个创建int类型数组的方法，参数传递数组的长度，返回创建好的int类型数组
    int[] builderArray(int length);
}

package ln.javatest.day17.demo03;
//数组的构造器引用
public class Demo02 {
    /*
    定义一个方法
    方法的参数传递创建数组的长度和ArayLBuilder接口
    方法内部根据传递的长度使用ArrayBuilder中的方法创建数组并返回
    */
    public static int[] creatArray(int length,ArrayBuilder ab){
        return ab.builderArray(length);
    }

    public static void main(String[] args) {
        //调用creatArray方法，传递数组的长度和Lambda表达式
        int[] arr1 = creatArray(10, len -> new int[len]);
        System.out.println(arr1.length);
        /*
        使用方法引用优化Lambda表达式
        已经创建的就是int[]数组
        数组的长度也是已知的
        就可以使用方法引用
        int[]引用new，根据参数传递的长度来创建数组
        */
        int[] arr2 = creatArray(10, int[]::new);
        System.out.println(arr2);
    }
}