jdk8新特性

一、lambda表达式

Lambda表达式相当于是对接口抽象方法的重写

对比匿名内部类与lambda表达式

package com.bz.jdk8.demo01_Lambda;
/**
 * 体验Lambda表达式
 */
public class Demo01LambdaIntro {
    public static void main(String[] args) {
        // 使用匿名内部类存在的问题
        // public Thread(Runnable target)
        // 匿名内部类做了哪些事情
        //  1.定义了一个没有名字的类
        //  2.这个类实现了Runnable接口
        //  3.创建了这个类的对象
        // 使用匿名内部类语法是很冗余的
        // 其实我们最关注的是run方法和里面要执行的代码.
        // Lambda表达式体现的是函数式编程思想,只需要将要执行的代码放到函数中(函数就是类中的方法)
        // Lambda就是一个匿名函数, 我们只需要将要执行的代码放到Lambda表达式中即可
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行一个线程");
            }
        }).start();
        // Lambda表达式的好处: 可以简化匿名内部类,让代码更加精简
        //使用Lambda表达式
        new Thread(()->{
            System.out.println("使用了Lambda表达式");
        }).start();
    }
}

标准格式

()->{}

package com.bz.jdk8.demo01_Lambda;
/**
 * Lambda表达式的标准格式
 * ()->{}
 *
 *  // 小结:Lambda表达式相当于是对接口抽象方法的重写
 */
public class Demo02LambdaUse {
    public static void main(String[] args) {
        goSwimming(new Swimmable() {
            @Override
            public void swimming() {
                System.out.println("练习无参数无返回值的匿名内部类");
            }
        });
        System.out.println("===============");
        goSwimming(()-> System.out.println("练习无参数无返回值的Lambda"));
    }
    // 练习无参数无返回值的Lambda
    public static void goSwimming(Swimmable s) {
        s.swimming();
    }
}

省略写法

在Lambda标准格式的基础上，使用省略写法的规则为：

1. 小括号内参数的类型可以省略。
2. 如果小括号内有且仅有一个参数，则小括号可以省略。
3. 如果大括号内有且仅有一个语句，可以同时省略大括号、return关键字及语句分号。

Lambda表达式的前提条件

Lambda表达式的前提条件:

1. 方法的参数或变量的类型是接口。

2. 这个接口中只能有一个抽象方法。

   package com.bz.jdk8.demo01_Lambda;

   /**

   • Lambda表达式的前提条件:
   • 1. 方法的参数或变量的类型是接口
   • 1. 这个接口中只能有一个抽象方法
        *

   • @FunctionalInterface // 检测这个接口是不是只有一个抽象方法
     */
     public class Demo04LambdaCondition {

     public static void main(String[] args) {

        test(()-> System.out.println("吃饭了吗？"));
        System.out.println("===========");
        Flyable f = ()->{
            System.out.println("飞呀飞。。。");
        };
    }
    public static void test(Flyable flyable){
        System.out.println("使用了lambda表达式");
    }
}
// 只有一个抽象方法的接口称为函数式接口,我们就能使用Lambda
@FunctionalInterface // 检测这个接口是不是只有一个抽象方法
interface Flyable {
    // 接口中有且仅有一个抽象方法
    public abstract void eat();
    // public abstract void eat2();
}

二、接口增加默认方法和静态方法

接口引入默认方法的背景

如果给接口新增抽象方法，所有实现类都必须重写这个抽象方法。
不利于接口的扩展。

package com.bz.jdk8.demo02interfaceupgrade;
/**
 * 接口引入默认方法的背景
 * 在JDK 8以前接口中只能有抽象方法。存在以下问题：
 *  如果给接口新增抽象方法，所有实现类都必须重写这个抽象方法。
 *  不利于接口的扩展。
 */
public class Demo01InterfaceDefaultIntro{
}
interface A {
    public abstract void test01();
    // 接口新增抽象方法,所有实现类都需要去重写这个方法,非常不利于接口的扩展
    // public abstract void test02();
}
class B implements A {
    @Override
    public void test01() {
        System.out.println("B test01");
    }
}
class C implements A {
    @Override
    public void test01() {
        System.out.println("C test01");
    }
}

默认方法

package com.bz.jdk8.demo02interfaceupgrade;
/**
 * 接口默认方法的使用
 * 方式一：实现类直接调用接口默认方法
 * 方式二：实现类重写接口默认方法
 */
public class Demo02UseDefaultFunction {
    public static void main(String[] args) {
        //方式一：实现类直接调用接口默认方法
        AA aa = new BB();
        aa.test1();
        System.out.println("===========");
        //方式二：实现类重写接口默认方法
        AA ac = new CC();
        ac.test1();
    }
}
interface AA{
    default void test1(){
        System.out.println("jdk8新增的默认的方法");
    }
}
class BB implements AA{
    //不重写方法
}
class CC implements AA{
    @Override
    public void test1() {
        System.out.println("重写了方法");
    }
}

静态方法

package com.bz.jdk8.demo02interfaceupgrade;
/**
 * 接口的静态方法
 * 接口静态方法的使用
 * 直接使用接口名调用即可：接口名.静态方法名();
 *
 * 接口默认方法和静态方法的区别
 *  1. 默认方法通过实例调用，静态方法通过接口名调用。
 *  2. 默认方法可以被继承，实现类可以直接使用接口默认方法，也可以重写接口默认方法。
 *  3. 静态方法不能被继承，实现类不能重写接口静态方法，只能使用接口名调用。
 *
 * 如何选择呢？如果这个方法需要被实现类继承或重写，使用默认方法; 如果接口中的方法不需要被继承就使用静态方法
 */
public class Demo03UseStaticFunction {
    public static void main(String[] args) {
        DD dd = new EE();
        //
        //通过接口名调用
        DD.test();
    }
}
interface DD{
    public static void test(){
        System.out.println("jdk8新增的静态方法");
    }
}
//无法重写静态方法
class EE implements DD{
//    @Override
//    test
}

接口默认方法和静态方法的区别

1. 默认方法通过实例调用，静态方法通过接口名调用。
2. 默认方法可以被继承，实现类可以直接使用接口默认方法，也可以重写接口默认方法。
3. 静态方法不能被继承，实现类不能重写接口静态方法，只能使用接口名调用。

如何选择呢？如果这个方法需要被实现类继承或重写，使用默认方法; 如果接口中的方法不需要被继承就使用静态方法。

三、函数式接口

内置函数式接口的由来

我们知道使用Lambda表达式的前提是需要有函数式接口。而Lambda使用时不关心接口名，抽象方法名，只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda方便，JDK提供了大量常用的函数式接口。

Supplier接口

java.util.function.Supplier 接口，它意味着”供给” , 对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。

package com.bz.jdk8.demo03functionalinterface;
import java.util.Arrays;
import java.util.function.Supplier;
/**
 * java.util.function.Supplier<T> 接口，它意味着"供给" , 对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。
 * 供给型接口，通过Supplier接口中的get方法可以得到一个值，无参有返回的接口。
 */
public class Demo02Supplier {
    // 使用Lambda表达式返回数组元素最大值
    public static void main(String[] args) {
        printMax(()->{
            int[] arr = new int[]{
    23,25,11,56,45};
            Arrays.sort(arr);//升序
            return arr[arr.length - 1];
        });
    }
    public static void printMax(Supplier<Integer> supplier){
        System.out.println("supplier函数式接口");
        Integer max = supplier.get();
        System.out.println("max: "+max);
    }
}

Consumer接口

java.util.function.Consumer 接口则正好相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型参数决定。

package com.bz.jdk8.demo03functionalinterface;
import java.util.function.Consumer;
/**
 * java.util.function.Consumer<T> 接口则正好相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型参数决定。
 */
public class Demo03Consumer {
    // 使用Lambda表达式将一个字符串转成大写的字符串
    public static void main(String[] args) {
        System.out.println("开始了");
        printHello((s)->{
            System.out.println(s.toUpperCase());
        });
    }
    public static void printHello(Consumer<String> consumer){
        System.out.println("consumer");
        consumer.accept("holle world");
    }
}

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

package com.bz.jdk8.demo03functionalinterface;
import java.util.function.Consumer;
public class Demo04ConsumerAndThen {
    // 使用Lambda表达式先将一个字符串转成小写的字符串,再转成大写
    public static void main(String[] args) {
        System.out.println("开始啦");
        printHello((String str) -> {
            System.out.println(str.toLowerCase());
        }, (String str) -> {
            System.out.println(str.toUpperCase());
        });
    }
    public static void printHello(Consumer<String> c1, Consumer<String> c2) {
        System.out.println("aa");
        String str = "Hello World";
        // c1.accept(str);
        // c2.accept(str);
        c1.andThen(c2).accept(str);
    }
}

Function接口

java.util.function.Function 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。有参数有返回值。

Function转换型接口，对apply方法传入的T类型数据进行处理，返回R类型的结果，有参有返回的接口。使用的场景例如：将 String 类型转换为 Integer

package com.bz.jdk8.demo03functionalinterface;
import java.util.function.Function;
/**
 * Function接口
 * java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，
 * 后者称为后置条件。有参数有返回值。
 *
 * Function转换型接口，对apply方法传入的T类型数据进行处理，返回R类型的结果，有参有返回的接口。使用的场景
 * 例如：将 String 类型转换为 Integer 类型。
 */
public class Demo05Function {
//    使用Lambda表达式将字符串转成数字
    public static void main(String[] args) {
        System.out.println("开始了...");
        getNumber(str->{
            return Integer.parseInt(str);
        });
    }
    public static void getNumber(Function<String,Integer> function){
        System.out.println("输入字符串得到int数据");
        Integer apply = function.apply("98");
        System.out.println("num:"+apply);
    }
}

默认方法：andThen
Function 接口中有一个默认的 andThen 方法，用来进行组合操作。

package com.bz.jdk8.demo03functionalinterface;
import java.util.function.Function;
/**
 * 默认方法：andThen
 * Function 接口中有一个默认的 andThen 方法，用来进行组合操作。
 */
public class Demo06FunctionAndThen {
    //第一个操作是将字符串解析成为int数字，第二个操作是乘以10。两个操作通过 andThen 按照前后顺序组合到了一起。
    public static void main(String[] args) {
        getNumber(str->{
            return Integer.parseInt(str);
        },i->{
            return i * 6;
        });
    }
    public static void getNumber(Function<String,Integer> f1,Function<Integer,Integer> f2){
        System.out.println("先转为int类型，如何再乘以6");
/*        Integer apply = f1.apply("5");
        Integer count = f2.apply(apply);*/
        Integer count = f1.andThen(f2).apply("5");
        System.out.println("结果："+count);
    }
}

Predicate接口

有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用java.util.function.Predicate 接口。

package com.bz.jdk8.demo03functionalinterface;
import java.util.function.Predicate;
public class Demo07Predicate {
    // 使用Lambda判断一个人名如果超过3个字就认为是很长的名字
    public static void main(String[] args) {
        System.out.println("开始啦");
        isLongName((String name) -> {
            return name.length() > 3;
        });
    }
    public static void isLongName(Predicate<String> predicate) {
        System.out.println("aa");
        boolean isLong = predicate.test("迪丽热巴");
        System.out.println("是否是长名字: " + isLong);
    }
}

默认方法：and，使用“与”逻辑实现“并且”的效果。
默认方法：or，实现逻辑关系中的“或”。
默认方法：negate，“非”（取反）。

package com.bz.jdk8.demo03functionalinterface;
import java.util.function.Predicate;
public class Demo08Predicate_And_Or_Negate {
    // 使用Lambda表达式判断一个字符串中即包含W,也包含H
    // 使用Lambda表达式判断一个字符串中包含W或者包含H
    // 使用Lambda表达式判断一个字符串中不包含W
    public static void main(String[] args) {
        test((String str) -> {
            // 判断是否包含W
            return str.contains("W");
        }, (String str) -> {
            // 判断是否包含H
            return str.contains("H");
        });
    }
    public static void test(Predicate<String> p1, Predicate<String> p2) {
        // String str = "Hello orld";
        // boolean b1 = p1.test(str);
        // boolean b2 = p2.test(str);
        // if (b1 && b2) {
        //     System.out.println("即包含W,也包含H");
        // }
        // 使用Lambda表达式判断一个字符串中即包含W,也包含H
        String str = "Hello World";
        boolean b = p1.and(p2).test(str);
        if (b) {
            System.out.println("即包含W,也包含H");
        }
        // 使用Lambda表达式判断一个字符串中包含W或者包含H
        boolean b1 = p1.or(p2).test(str);
        if (b1) {
            System.out.println("包含W或者包含H");
        }
        // 使用Lambda表达式判断一个字符串中不包含W
        boolean b2 = p1.negate().test("Hello W");
        // negate相当于取反 !boolean
        if (b2) {
            System.out.println("不包含W");
        }
    }
}

四、方法引用

方法引用的格式

符号表示 ::

符号说明 : 双冒号为方法引用运算符，而它所在的表达式被称为方法引用。
应用场景 : 如果Lambda所要实现的方案 , 已经有其他方法存在相同方案，那么则可以使用方法引用,

package com.bz.jdk8.demo04methodref;
import java.sql.SQLOutput;
import java.util.function.Consumer;
/**
 * 方法引用的格式
 * 符号表示 : ::
 *  * 符号说明 : 双冒号为方法引用运算符，而它所在的表达式被称为方法引用。
 * 应用场景 : 如果Lambda所要实现的方案 , 已经有其他方法存在相同方案，那么则可以使用方法引用
 */
public class Demo01MethodRefIntro {
    public static void printMax(Consumer<int[]> consumer) {
        int[] arr = {
    11, 22, 33, 44, 55};
        consumer.accept(arr);
    }
    //求一个数组的和
    public static void getSum(int[] arr){
        int sum = 0;
        for (int i : arr){
            sum += i;
        }
        System.out.println("和："+sum);
    }
    // 使用方法引用
    // 让这个指定的方法去重写接口的抽象方法,到时候调用接口的抽象方法就是调用传递过去的这个方法
    public static void main(String[] args) {
        // 使用Lambda表达式求一个数组的和
        /*printMax((int[] arr) -> {
            getMax(arr);
        });*/
        printMax(Demo01MethodRefIntro::getSum);
    }
}

方法引用的注意事项:

• 被引用的方法,参数要和接口中抽象方法的参数一样。
• 当接口抽象方法有返回值时,被引用的方法也必须有返回值。

方法引用是对Lambda表达式符合特定情况下的一种缩写，它使得我们的Lambda表达式更加的精简，也可以理解为 Lambda表达式的缩写形式 , 不过要注意的是方法引用只能”引用”已经存在的方法!

对象名::引用成员方法

/**
     *对象名::引用成员方法
     *
     *注意:方法引用有两个注意事项
     * 1.被引用的方法，参数要和接口中抽象方法的参数一样
     * 2.当接口抽象方法有返回值时，被引用的方法也必须有返回值
     */
    @Test
    public void test1(){
        Date now = new Date();
        Supplier<Long> supplier = ()->{
            return now.getTime();
        };
        Supplier<Long> sp = now::getTime;
        Long aLong = sp.get();
        System.out.println("时间："+aLong);
    }

类名::静态方法

/**
     *类名::静态方法
     */
    @Test
    public void test2(){
        Supplier<Long> supplier = ()->{
            return System.currentTimeMillis();
        };
        Supplier<Long> sup = System::currentTimeMillis;
        Long aLong = supplier.get();
        Long aLong1 = sup.get();
        System.out.println(aLong + "---"+aLong1);
    }

类名::实例方法

/**
     *类名::实例方法
     */
    @Test
    public void test3(){
        /*Function<String, Integer> f1 = (String str) -> {
            return str.length();
        };*/
        // 类名::实例方法(注意:类名::类名::实例方法实际上会将第一个参数作为方法的调用者)
        Function<String, Integer> f1 = String::length;
        int length = f1.apply("hello");
        System.out.println("length = " + length);
        // BiFunction<String, Integer, String> f2 = String::substring;
        // 相当于这样的Lambda
        BiFunction<String, Integer, String> f2 = (String str, Integer index) -> {
            return str.substring(index);
        };
        String str2 = f2.apply("helloworld", 3);
        System.out.println("str2 = " + str2); // loworld
    }

类名::new引用类的构造器

// 类名::new引用类的构造器
    @Test
    public void test04() {
        /*Supplier<Person> su1 = () -> {
            return new Person();
        };*/
        Supplier<Person> su1 = Person::new;
        Person person = su1.get();
        System.out.println("person = " + person);
        /*BiFunction<String, Integer, Person> bif = (String name, Integer age) -> {
            return new Person(name, age);
        };*/
        BiFunction<String, Integer, Person> bif = Person::new;
        Person p2 = bif.apply("凤姐", 18);
        System.out.println("p2 = " + p2);
    }

类型[]::new

// 类型[]::new
    @Test
    public void test05() {
        /*Function<Integer, int[]> f1 = (Integer length) -> {
            return new int[length];
        };*/
        Function<Integer, int[]> f1 = int[]::new;
        int[] arr1 = f1.apply(10);
        System.out.println(Arrays.toString(arr1));
    }

五、Stream流

注意：Stream和IO流(InputStream/OutputStream)没有任何关系，请暂时忘记对传统IO流的固有印象！
Stream是流式思想,相当于工厂的流水线,对集合中的数据进行加工处理

体验集合操作数据的弊端

package com.bz.jdk8.demo05stream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/*
目标：体验集合操作数据的弊端
小结：
    1.集合操作数据的弊端?
        每个需求都要循环一次,还要搞一个新集合来装数据, 麻烦
 */
public class Demo01Intro {
    public static void main(String[] args) {
        // 一个ArrayList集合中存储有以下数据:张无忌,周芷若,赵敏,张强,张三丰
        // 需求:1.拿到所有姓张的 2.拿到名字长度为3个字的 3.打印这些数据
        List<String> arr = new ArrayList<>();
        Collections.addAll(arr,"张无忌","周芷若","张强","张三丰");
        List<String> list = new ArrayList<>();
//        1.拿到所有姓张的
        for (String str : arr){
            if (str.contains("张")){
                list.add(str);
            }
        }
        //拿到名字长度为3个字的
        List<String> three = new ArrayList<>();
        for (String str : arr){
            if (str.length() == 3){
                three.add(str);
            }
        }
        System.out.println(Arrays.toString(list.toArray()));
        System.out.println(Arrays.toString(three.toArray()));
        System.out.println("=================");
        //使用流
        arr.stream().filter(str->{
            return str.startsWith("张");
        }).filter(str->{
            return str.length() == 3;
        }).forEach(s -> System.out.println(s));
    }
}

获取流

Collection 集合通过 stream 默认方法获取流

package com.bz.jdk8.demo05stream;
import java.util.*;
import java.util.stream.Stream;
/**
 * java.util.stream.Stream<T> 是JDK 8新加入的流接口。
 *  获取一个流非常简单，有以下几种常用的方式：
 *   所有的 Collection 集合都可以通过 stream 默认方法获取流；
 *   Stream 接口的静态方法 of 可以获取数组对应的流。
 */
public class Demo02GetStream {
    public static void main(String[] args) {
        // 方式1 : 根据Collection获取流
        // Collection接口中有一个默认的方法: default Stream<E> 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<>();
        Stream<String> stream3 = map.keySet().stream();
        Stream<String> stream4 = map.values().stream();
        Stream<Map.Entry<String, String>> stream5 = map.entrySet().stream();
    }
}

Stream中的静态方法of获取流

// 方式2 : Stream中的静态方法of获取流
      // static<T> Stream<T> of(T... values)
      Stream<String> stream6 = Stream.of("aa", "bb", "cc");
      String[] strs = {
    "aa", "bb", "cc"};
      Stream<String> stream7 = Stream.of(strs);
      // 基本数据类型的数组行不行?不行的,会将整个数组看做一个元素进行操作.
      int[] arr = {
    11, 22, 33};
      Stream<int[]> stream8 = Stream.of(arr);

stream方法分为：终结方法和函数拼接方法

package com.bz.jdk8.demo05stream;
import java.util.stream.Stream;
/**
 * 我们学习了Stream的常用方法,我们知道Stream这些常用方法可以分成两类,
 *      终结方法,
 *      函数拼接方法
 *
 * Stream的3个注意事项:
 *  1. Stream只能操作一次
 *  2. Stream方法返回的是新的流
 *  3. Stream不调用终结方法，中间的操作不会执行
 */
public class Demo03StreamNotice {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("aa", "bb", "cc");
        //stream只能操作一次
//        long count = stream.count();
//        long count1 = stream.count();// stream has already been operated upon or closed
//        Stream<String> limit = stream.limit(1);
//
//        System.out.println("流是否相等："+(stream == limit));//流是否相等：false
        //3. Stream不调用终结方法，中间的操作不会执行
        stream.filter(s->{
            System.out.println(s);
            return true;
        }).count();
    }
}

常用方法

forEach 用来遍历流中的数据

/**
     * forEach 用来遍历流中的数据
     * 该方法接收一个 Consumer 接口函数，会将每一个流元素交给该函数进行处理。
     */
    @Test
    public void testForEach() {
        List<String> one = new ArrayList<>();
        Collections.addAll(one, "迪丽热巴", "宋远桥", "苏星河", "老子", "庄子", "孙子");
        //lambda表达式遍历
//        one.stream().forEach(str-> System.out.println(str));
        //使用方法引用
        one.stream().forEach(System.out::println);
    }

count 方法来统计其中的元素个数

/**
     * Stream流提供 count 方法来统计其中的元素个数
     * 该方法返回一个long值代表元素个数。
     */
    @Test
    public void testCount() {
        List<String> one = new ArrayList<>();
        Collections.addAll(one, "迪丽热巴", "宋远桥", "苏星河", "老子", "庄子", "孙子");
        long count = one.stream().count();
        System.out.println("总数："+count);
    }

filter用于过滤数据，返回符合过滤条件的数据

/**
     * filter用于过滤数据，返回符合过滤条件的数据
     * 可以通过 filter 方法将一个流转换成另一个子集流。
     *
     * 该接口接收一个 Predicate 函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件。
     */
    @Test
    public void testFilter() {
        List<String> arr = new ArrayList<>();
        Collections.addAll(arr, "宋远桥", "苏星河", "老子", "庄子", "孙子");
        arr.stream().filter(str->str.length() == 3).forEach(System.out::println);//宋远桥,苏星河
    }

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

/**
     *limit 方法可以对流进行截取，只取用前n个。
     * 参数是一个long型，如果集合当前长度大于参数则进行截取。否则不进行操作。
     */
    @Test
    public void testLimit() {
        List<String> one = new ArrayList<>();
        Collections.addAll(one, "迪丽热巴", "宋远桥", "苏星河", "老子", "庄子", "孙子");
        one.stream().limit(3).forEach(System.out::println);
    }

skip 方法跳过前几个元素，获取一个截取之后的新流

/**
     * 如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流：
     *
     * 如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。
     */
    @Test
    public void testSkip() {
        List<String> one = new ArrayList<>();
        Collections.addAll(one, "迪丽热巴", "宋远桥", "苏星河", "老子", "庄子", "孙子");
        one.stream().skip(2).forEach(System.out::println);
    }

map 方法将流中的元素映射到另一个流中

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

/**
     * 如果需要将流中的元素映射到另一个流中，可以使用 map 方法。
     * 该接口需要一个 Function 函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。
     */
    @Test
    public void testMap() {
        Stream<String> original = Stream.of("11", "22", "33");
//        original.map(str->Integer.parseInt(str)).forEach(System.out::println);
        // 将Stream流中的字符串转成Integer
        //方法引用简化
        original.map(Integer::parseInt).forEach(System.out::println);
    }

sorted 方法将数据排序

/**
     *如果需要将数据排序，可以使用 sorted 方法。
     *sorted 方法根据元素的自然顺序排序，也可以指定比较器排序
     */
    @Test
    public void testSorted() {
        // sorted(): 根据元素的自然顺序排序
        // sorted(Comparator<? super T> comparator): 根据比较器指定的规则排序
        Stream<Integer> stream = Stream.of(33, 22, 11, 55);
//        stream.sorted().forEach(System.out::println);
        //自定义排序规则
        stream.sorted((o1, o2) -> o2-o1).forEach(System.out::println);
    }

distinct 方法去除重复数据

/**
     *如果需要去除重复数据，可以使用 distinct 方法。
     *
     * 自定义类型是根据对象的hashCode和equals来去除重复元素的。
     */
    @Test
    public void testDistinct() {
        Stream<Integer> stream = Stream.of(22, 33, 22, 11, 33);
        stream.distinct().forEach(System.out::println);
        Stream<String> streamStr = Stream.of("aa","bb","cc","bb");
        streamStr.distinct().forEach(System.out::println);
        System.out.println("===============");
        //自定义类型是根据对象的hashCode和equals来去除重复元素的。
        Stream<Person> streamPer = Stream.of(
                new Person("貂蝉", 18),
                new Person("杨玉环", 20),
                new Person("杨玉环", 20),
                new Person("西施", 16),
                new Person("西施", 16),
                new Person("王昭君", 25)
        );
        streamPer.distinct().forEach(System.out::println);
    }

Match 相关方法，判断数据是否匹配指定的条件

/**
     *如果需要判断数据是否匹配指定的条件，可以使用 Match 相关方法。
     * allMatch: 元素是否全部满足条件
     * anyMatch: 元素是否任意有一个满足条件
     * noneMatch: 元素是否全部不满足条件
     */
    @Test
    public void testMatch() {
        Stream<Integer> stream = Stream.of(5, 3, 6, 1);
        //allMatch: 匹配所有元素,所有元素都需要满足条件
//        boolean all = stream.allMatch(i -> i > 0);
//        System.out.println("是否都大于0："+all);
        //anyMatch: 匹配某个元素,只要有其中一个元素满足条件即可
//        boolean any = stream.anyMatch(i -> i > 5);
//        System.out.println("是否存在大于5的元素："+any);
        //noneMatch: 匹配所有元素,所有元素都不满足条件
        boolean none = stream.noneMatch(i -> i < 0);
        System.out.println("是否都不满足："+none);
    }

find 方法，要找到某些数据

/**
     *如果需要找到某些数据，可以使用 find 相关方法。
     */
    @Test
    public void testFind() {
        Stream<Integer> stream = Stream.of(33, 11, 22, 5);
        //获取第一个元素
//        Optional<Integer> first = stream.findFirst();
        Optional<Integer> any = stream.findAny();
        System.out.println(any.get());
    }

max 和 min 方法，获取最大和最小值

/**
     * 如果需要获取最大和最小值，可以使用 max 和 min 方法。
     */
    @Test
    public void testMax_Min() {
        Integer max = Stream.of(7, 5, 3, 8, 2, 6).max((o1, o2) -> o1 - o2).get();
        System.out.println("最大值："+max);//最大值：8
        Integer min = Stream.of(7, 5, 3, 8, 2, 6).min((o1, o2) -> o1 - o2).get();
        System.out.println("最小值："+min);//最小值：2
    }

reduce 方法将所有数据归纳得到一个数据

/**
     * 如果需要将所有数据归纳得到一个数据，可以使用 reduce 方法。
     */
    @Test
    public void testReduce() {
        // T reduce(T identity, BinaryOperator<T> accumulator);
        // T identity: 默认值
        // BinaryOperator<T> accumulator: 对数据进行处理的方式
        // reduce如何执行?
        // 第一次, 将默认值赋值给x, 取出集合第一元素赋值给y
        // 第二次, 将上一次返回的结果赋值x, 取出集合第二元素赋值给y
        // 第三次, 将上一次返回的结果赋值x, 取出集合第三元素赋值给y
        // 第四次, 将上一次返回的结果赋值x, 取出集合第四元素赋值给y
        Integer reduce = Stream.of(4, 5, 3, 9).reduce(0, (x, y) -> {
            System.out.println("x:" + x + ", y: " + y);
            return x + y;
        });
        System.out.println("reduce："+reduce);
        System.out.println("==============");
        //获取最大值
        Integer max = Stream.of(6,3,7,9).reduce(0,(x,y)->{
            return x > y ? x : y;
        });
        System.out.println("最大值："+max);
    }

Stream流的map和reduce组合使用

//Stream流的map和reduce组合使用
    @Test
    public void testMapReduce() {
        // 求出所有年龄的总和
        // 1.得到所有的年龄
        // 2.让年龄相加
        Integer totalAge = Stream.of(
                        new Person("刘德华", 58),
                        new Person("张学友", 56),
                        new Person("郭富城", 54),
                        new Person("黎明", 52))
                .map(Person::getAge).reduce(0, Integer::sum);
        System.out.println("totalAge = " + totalAge);
        // 找出最大年龄
        // 1.得到所有的年龄
        // 2.获取最大的年龄
        Integer maxAge = Stream.of(
                        new Person("刘德华", 58),
                        new Person("张学友", 56),
                        new Person("郭富城", 54),
                        new Person("黎明", 52))
                .map(Person::getAge)
                .reduce(0, Math::max);
        System.out.println("maxAge = " + maxAge);
        // 统计 a 出现的次数
        //                          1    0     0    1    0    1
        Integer count = Stream.of("a", "c", "b", "a", "b", "a")
                .map(s -> {
                    if (s == "a") {
                        return 1;
                    } else {
                        return 0;
                    }
                })
                .reduce(0, Integer::sum);
        System.out.println("count = " + count);
    }

mapToInt 方法，将Stream中的Integer类型数据转成int类型

/**
     * 如果需要将Stream中的Integer类型数据转成int类型，可以使用 mapToInt 方法。
     */
    @Test
    public void testNumericStream() {
        // Integer占用的内存比int多,在Stream流操作中会自动装箱和拆箱
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
        // 把大于3的打印出来
        stream.filter(i -> i > 3).forEach(System.out::println);
        System.out.println("=========先将流中的Integer数据转成int,后续都是操作int类型=======");
        IntStream intStream = Stream.of(1, 2, 3, 4, 5).mapToInt(Integer::intValue);
        intStream.filter(i -> i > 3).forEach(System.out::println);
    }

concat方法将两个流合并成为一个流

/**
     * 如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat ：
     *
     * 备注：这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的
     */
    @Test
    public void testContact() {
        Stream<String> streamA = Stream.of("张三");
        Stream<String> streamB = Stream.of("李四");
        // 合并成一个流
        Stream<String> newStream = Stream.concat(streamA, streamB);
        // 注意:合并流之后,不能操作之前的流啦.
        // streamA.forEach(System.out::println);
        newStream.forEach(System.out::println);
    }

综合案例

package com.bz.jdk8.demo05stream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;
/**
 * Stream综合案例
 * 现在有两个 ArrayList 集合存储队伍当若干集合存储队伍当中的多个成员姓名，要求使用传统的for循环（或增强for循环）依
 * 次进行以下操作步骤：
 *  1. 第一个队伍只要名字为3个字的成员
 *  2. 第一个队伍筛选之后只要前3个人
 *  3. 第二个队伍只要姓张的成员姓名；
 *  4. 第二个队伍筛选之后不要前2个人；
 *  5. 将两个队伍合并为一个队伍；
 *  6. 根据姓名创建 Person 对象；
 *  7. 打印整个队伍的Person对象信息。
 */
public class Demo05 {
    public static void main(String[] args) {
        // 第一个队伍
        List<String> one = new ArrayList<>();
        Collections.addAll(one,"迪丽热巴", "宋远桥", "苏星河", "老子", "庄子", "孙子", "洪七公");
        // 第二个队伍
        List<String> two = new ArrayList<>();
        Collections.addAll(two,"古力娜扎", "张无忌", "张三丰", "赵丽颖", "张二狗", "张天爱", "张三");
        //1. 第一个队伍只要名字为3个字的成员姓名；
        //2. 第一个队伍筛选之后只要前3个人；
        Stream<String> streamA = one.stream().filter(str -> str.length() == 3).limit(3);
        //3. 第二个队伍只要姓张的成员姓名；
        //4. 第二个队伍筛选之后不要前2个人；
        Stream<String> streamB = two.stream().filter(str -> str.startsWith("张")).skip(2);
        //5. 将两个队伍合并为一个队伍；
        Stream<String> stream = Stream.concat(streamA,streamB);
        //6. 根据姓名创建 Person 对象；
        //7. 打印整个队伍的Person对象信息。
        stream.map(Person2::new).forEach(System.out::println);
    }
}

收集Stream流中的结果

Stream流中的结果到集合中

/**
     *  将流中数据收集到集合中
     * Stream流提供 collect 方法，其参数需要一个 java.util.stream.Collector<T,A, R> 接口对象来指定收集到哪
     * 种集合中。java.util.stream.Collectors 类提供一些方法，可以作为 Collector`接口的实例：
     */
    @Test
    public void testStreamToCollection() {
        Stream<String> stream = Stream.of("aa", "bb", "cc", "bb");
        //list集合
//        List<String> list = stream.collect(Collectors.toList());
//        System.out.println("list= "+list);
        //set集合
//        Set<String> set = stream.collect(Collectors.toSet());
//        System.out.println("set="+set);
        //收集到指定的集合中ArrayList
//        ArrayList<String> arrayList = stream.collect(Collectors.toCollection(ArrayList::new));
//        System.out.println("收集到指定的集合中ArrayList="+arrayList);
        //HashSet
        HashSet<String> hashSet = stream.collect(Collectors.toCollection(HashSet::new));
        System.out.println("hashSet="+hashSet);
    }

Stream流中的结果到数组中

/**
     * Stream流中的结果到数组中
     * Stream提供 toArray 方法来将结果放到一个数组中，返回值类型是Object[]的：
     */
    @Test
    public void testStreamToArray() {
        Stream<String> stream = Stream.of("aa", "bb", "cc");
        // 转成Object数组不方便
        // Object[] objects = stream.toArray();
        // for (Object o : objects) {
        //     System.out.println("o = " + o);
        // }
        // String[]
        String[] strings = stream.toArray(String[]::new);
        for (String string : strings) {
            System.out.println("string = " + string + ", 长度: " + string.length());
        }
    }

对流中数据进行聚合计算

// 其他收集流中数据的方式(相当于数据库中的聚合函数)
    @Test
    public void testStreamToOther() {
        Stream<Student> studentStream = Stream.of(
                new Student("赵丽颖", 58, 95),
                new Student("杨颖", 56, 88),
                new Student("迪丽热巴", 56, 99),
                new Student("柳岩", 52, 77));
//        Optional<Student> max = studentStream.collect(Collectors.maxBy((s1, s2) -> s1.getSocre() - s2.getSocre()));
//        System.out.println("最大值: " + max.get());
//        Optional<Student> min = studentStream.collect(Collectors.minBy((o1, o2) -> o1.getSocre() - o2.getSocre()));
//        System.out.println("最小值："+min);
//        Integer count = studentStream.collect(Collectors.summingInt(Student::getAge));
//        System.out.println("年龄总和："+count);
        // 平均值
        // Double avg = studentStream.collect(Collectors.averagingInt(s -> s.getSocre()));
        // Double avg = studentStream.collect(Collectors.averagingInt(Student::getSocre));
        // System.out.println("平均值: " + avg);
        // 统计数量
        Long count = studentStream.collect(Collectors.counting());
        System.out.println("统计数量: " + count);
    }

对流中数据进行分组

/**
     * 对流中数据进行分组
     * 当我们使用Stream流处理数据后，可以根据某个属性将数据分组：
      */
    @Test
    public void testGroup() {
        Stream<Student> studentStream = Stream.of(
                new Student("赵丽颖", 52, 95),
                new Student("杨颖", 56, 88),
                new Student("迪丽热巴", 56, 55),
                new Student("柳岩", 52, 33));
        //根据年龄分组
//        Map<Integer, List<Student>> ageGroup = studentStream.collect(Collectors.groupingBy(Student::getAge));
        //根据分数分组
        Map<String, List<Student>> socreGroup = studentStream.collect(Collectors.groupingBy(s -> {
            if (s.getSocre() > 60) {
                return "及格";
            } else {
                return "不及格";
            }
        }));
        socreGroup.forEach((k,v)-> System.out.println(k + "::" +v));
    }

对流中数据进行多级分组

// 多级分组
    @Test
    public void testCustomGroup() {
        Stream<Student> studentStream = Stream.of(
                new Student("赵丽颖", 52, 95),
                new Student("杨颖", 56, 88),
                new Student("迪丽热巴", 56, 55),
                new Student("柳岩", 52, 33));
        // 先根据年龄分组,每组中在根据成绩分组
        Map<Integer, Map<String, List<Student>>> map = studentStream.collect(Collectors.groupingBy(Student::getAge, Collectors.groupingBy((s) -> {
            if (s.getSocre() > 60) {
                return "及格";
            } else {
                return "不及格";
            }
        })));
        // 遍历
        map.forEach((k, v) -> {
            System.out.println(k);
            // v还是一个map,再次遍历
            v.forEach((k2, v2) -> {
                System.out.println("\t" + k2 + " == " + v2);
            });
        });
    }