Lambda表达式与Stream 表达式新特性

package Demo.java3.java的新特性;

import org.junit.jupiter.api.Test;

import java.lang.reflect.Array;

import java.util.*;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;


public class java8新特性main {
    public static void main(String[] args) {

    }
}

@FunctionalInterface  //查看是否是一个函数值接口就是代表只有一个函数
interface JiekouLambda
{
    void abc();

}

class Java8Lambda表达式
{

    @Test
    void   Lambda() //Lambda表达式   减少代码太多   所有匿名对象都可以用Lambda表达式做
    {
        //使用普通的方法调用匿名实现类
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("你好中国");
            }

        };
        r1.run(); //调用方法

        System.out.println("***********************方式2**********************");

        //使用Lambda 拉姆达 调用方法  代码少
        Runnable r2=()-> System.out.println("我爱中国");//无参数的
        //Runnable r2=(String a)-> System.out.println("我爱中国"+s);//无参数但是有形参的
        r2.run();//调用方法


        System.out.println("***********************举例2.1**********************");
        //常规的调用
        Comparator<Integer> c1=new Comparator<>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);  //比较2个大小
            }
        };
        int i = c1.compare(1, 2); //比较大小 负一为前面一个小
        System.out.println("比较:"+i);

        System.out.println("***********************举例2.2**********************");
        Comparator<Integer> c3=(o1,o2)->Integer.compare(o1,o2);   //有参数的
        /*
        格式:
        ->左边lambda形参列表 (就是借口中的抽象方法形参列表)
        ->右边:lambda体(其实就是重写的抽象方法的方法体)
         */
        int j = c3.compare(1, 2); //比较大小
        System.out.println("比较二:"+j);

        System.out.println("***********************举例2.3**********************");

        Comparator<Integer> c2=Integer::compare;   //声明泛型为 Integer    调用的方法名称为 compare    :: 这样子的符号是方法引用
        int k = c2.compare(1, 2); //比较大小
        System.out.println("比较二:"+k);


    }


/*
// 1. 不需要参数,返回值为 5
() -> 5

// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x

// 3. 接受2个参数(数字),并返回他们的差值
(x, y) -> x – y

// 4. 接收2个int型整数,返回他们的和
(int x, int y) -> x + y

// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)
 */
}

class 测试类StreamApI
{
    private int a;
    private String b;
    private int c;
    private double d;

    public int getA() {
        return a;
    }

    public String getB() {
        return b;
    }

    public int getC() {
        return c;
    }

    public double getD() {
        return d;
    }





    public 测试类StreamApI(int a, String b, int c, double d) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
    }



    @Override
    public String toString() {
        return "测试类StreamApI{" +
                "a=" + a +
                ", b='" + b + '\'' +
                ", c=" + c +
                ", d=" + d +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        测试类StreamApI apI = (测试类StreamApI) o;
        return a == apI.a && c == apI.c && Double.compare(apI.d, d) == 0 && b.equals(apI.b);
    }

    @Override
    public int hashCode() {
        return Objects.hash(a, b, c, d);
    }
}

class StreamAPIaTest   //StreamApI 接口
{

    //开始
    List<测试类StreamApI> listText()
    {
        List<测试类StreamApI> li=new ArrayList();
        li.add(new 测试类StreamApI(1001,"张三",12,120.5));
        li.add(new 测试类StreamApI(1002,"张四",13,130.6));
        li.add(new 测试类StreamApI(1003,"张五",14,140.7));
        li.add(new 测试类StreamApI(1004,"张六",15,150.8));
        li.add(new 测试类StreamApI(1005,"张七",16,160.9));

        return li;
    }



    @Test
    void a1()
    {
        List l1=listText();

        //顺序流
        Stream stream = l1.stream(); //拿到stream类  顺序流

        //并行流
        Stream stream1 = l1.parallelStream(); //拿到并行流    相当于有几个就开几个线程去调用 并行流顺序随机

    }

    void a2()
    {
        int[] a={1,2,3,4,5};
        IntStream stream = Arrays.stream(a); //返回一个流


    }
    @Test
    void a2_1()
    {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);  //对数组进行操作


    }
@Test
    void a3()
    {
        //无线流
        //1.迭代遍历    前10个偶数
       Stream.iterate(0,t->t+2).limit(10).forEach(System.out::println);// 第一个是种子就是刚刚开始的数
        /*
        0
        2
        4
        6
        8
        10
        12
        14
        16
        18
         */

        //生成随机数  10个
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
        /*
        0.41720027805430804
        0.6921197215211785
        0.4327924077702632
        0.5656028549250586
        0.9005713688713138
        0.16710625008408997
        0.0035521677153773634
        0.6852037583584997
        0.23140835752454203
        0.24339932837556266

        进程已结束，退出代码为 0

         */

    }

// 结束

    void a5()
    {

    }



}
//StreamAPI只要被结束掉就必须重新声明方法
class StreamAPI切片和筛选_映射_排序
{
    List<测试类StreamApI> listText()
    {
        List li=new ArrayList();
        li.add(new 测试类StreamApI(1001,"吴李张三",12,7000.5));
        li.add(new 测试类StreamApI(1002,"李张四",13,6000.6));
        li.add(new 测试类StreamApI(1003,"张五",14,2000.7));
        li.add(new 测试类StreamApI(1004,"王李张六",15,9876.8));
        li.add(new 测试类StreamApI(1005,"张七",16,160.9));

        li.add(new 测试类StreamApI(1005,"张七",16,160.9));
        li.add(new 测试类StreamApI(1005,"张七",16,160.9));

        return li;
    }
@Test
    void  a1()  //筛选和切片截断
    {
        //筛选
        System.out.println("****************筛选*****************");//换行
        List<测试类StreamApI> l1 = listText(); //获取集合
        Stream<测试类StreamApI> str1 = l1.stream();//获取stream格式
        str1.filter(e->e.getD()>700.0).forEach(System.out::println); //查询员工大于700的工资信息


            /*
             测试类StreamApI{a=1001, b='张三', c=12, d=7000.5}
            测试类StreamApI{a=1002, b='张四', c=13, d=6000.6}
            测试类StreamApI{a=1003, b='张五', c=14, d=2000.7}
            测试类StreamApI{a=1004, b='张六', c=15, d=9876.8}
             */

        //截断
        System.out.println("***************截断******************");//换行
        List<测试类StreamApI> l2 = listText(); //重新获取集合 因为上一个已经调用了forEach方法结束掉了
        Stream<测试类StreamApI> st2 = l2.stream();
        st2.limit(3).forEach(System.out::println);//输出前三个并且终止运行

        /*
        测试类StreamApI{a=1001, b='张三', c=12, d=7000.5}
        测试类StreamApI{a=1002, b='张四', c=13, d=6000.6}
        测试类StreamApI{a=1003, b='张五', c=14, d=2000.7}
         */


        //跳过
        System.out.println("**************跳过*******************");//换行
        listText().stream().skip(2).forEach(System.out::println);  //跳过前面三个数据，后面全部输出

        //筛选-》去重
        System.out.println("**************筛选-去重复*******************");//换行
        listText().stream().distinct().forEach(System.out::println);  //不输出重复的数据(需要重写equals和hashCode)


    }

@Test
    void  a2()  //映射
    {
        System.out.println("****************map映射*****************");//换行
        List<String> l1 = Arrays.asList("aa", "bb", "cc", "dd", "ee");
        l1.stream().map(str->str.toUpperCase()).forEach(System.out::println);
        //映射就是针对里面的所有值都执行一遍相同的操作，这里是遍历集合中的所有数据并且转换成大写
    /*
     AA BB CC DD EE
     */

        //遍历名字大于三位的名字
        System.out.println("****************map测试二*****************");//换行
        List<测试类StreamApI> l2= listText();
        Stream<String> nameStream = l2.stream().map(测试类StreamApI::getB); //获取他的名字
        nameStream.filter(e->e.length()>3).forEach(System.out::println); //输出大于三的数据

        /*
        ****************map测试二*****************
        吴李张三
        王李张六

         */

        l1.stream().<Character>flatMap(StreamAPI切片和筛选_映射_排序::st1).forEach(System.out::println); //获取集合
        //Stream<Stream<Character>> stream = l1.stream().map(StreamAPI切片和筛选_映射_排序::st1);

    }
    public static Stream<Character> st1(String a)
    {
        List l1=new ArrayList();
        for (Object obj:a.toCharArray())  //转换成集合
        {
            l1.add(obj);
        }
        return l1.stream();
    }

    void  a3()  //排序
    {
        List li= Arrays.asList(1,2,3,4,-1,23,1,12);
        li.stream().sorted().forEach(System.out::println); //输出排序后的值

    }



}
class StreamAPI匹配_与_查找_收集
{
    @Test
    void  a1()  // 匹配
    {
        StreamAPIaTest st=new StreamAPIaTest();
        List<测试类StreamApI> is = st.listText();
        boolean b = is.stream().allMatch(e -> e.getD() > 16); //判断输出出来的值是否（都大于）16岁
        System.out.println(b);  //true
    }

    void  a2()  // 收集
    {
        StreamAPIaTest st=new StreamAPIaTest();
        List<测试类StreamApI> is = st.listText();

        List<测试类StreamApI> collect = is.stream().collect(Collectors.toList()); //获取里面的数据返回给collect集合  就不需要forEach直接读取出来了

    }

    void  a3()  //防止空指针异常
    {
        StreamAPIaTest st=new StreamAPIaTest();
        List<测试类StreamApI> is = st.listText();


    }

    void  a4()  //
    {

    }


}