Stream 流笔记

package com.wang.Stream;

import org.junit.Test;

import javax.swing.*;
import java.lang.reflect.Array;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.function.BiFunction;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * @author admin
 * @version 1.0.0
 * @ClassName StreamTest.java
 * @Description TODO
 * @createTime 2022年01月05日 22:14:00
 */
//stream流的测试类
public class StreamTest1
{
    @Test
    public void test01()
    {//创建集合对象
        List<Integer>nums= Arrays.asList(1,2,3,4,5);
        //创建stream流
        //filter() 返回结果生成新的流，流中只包含满足简单条件的数据
        //collect()
        List<Integer>list= nums.stream().filter(n->n>2).collect(Collectors.toList());
        System.out.println(list);
    }
    @Test
    public void test02()
    {//串行
        List<Integer>list= Arrays.asList(1,2,3,4,5);
        Stream<Integer> stream = list.stream();
        Stream<Integer> stream1=Stream.of(6,7,8);
        //bingxing
        List<String>list1=Arrays.asList("tom","blue","scott");
        Stream<String>stream2=list1.parallelStream();
        //串行转并行
        Stream<Integer> parallel = stream.parallel();
    }
    @Test
    public void test03()
    {//初始化1千万条数据
        System.out.println("初始化测试数据。。。");
        //iterate(),也可以获取流，无线流
        List<UUID> datas = Stream.iterate(UUID.randomUUID(), t -> UUID.randomUUID()).limit(10000000).collect(Collectors.toList());
        //开始测试串行流
        System.out.println("开始测试串行流...");
        long streamStartTime=System.nanoTime();//纳秒
        datas.stream().sorted().count();
        long streamEndTime=System.nanoTime();


        //开始测试并行流
        System.out.println("开始测试并行流...");
        long parallelstreamStartTime=System.nanoTime();//纳秒
        datas.parallelStream().sorted().count();
        long parallelstreamEndTime=System.nanoTime();//纳秒
        System.out.println("测试完毕，计算结果");
        BiFunction<Long,Long,Long> workMillionTime= (start, end) -> TimeUnit.NANOSECONDS.toMillis(end - start);
        //apply(streamStartTime,streamEndTime)将参数应用于函数执行
        Long streamTime = workMillionTime.apply(streamStartTime, streamEndTime);//计算串行时间
        Long parallelStreamTime = workMillionTime.apply(parallelstreamStartTime, parallelstreamEndTime);//计算并行时间

        //串行并行耗时测试结果
        System.out.println(String.format("串行流耗时：%d,并行流耗时：%d",streamTime,parallelStreamTime));


    }
    @Test
    public void test04()
    {
        Stream<String>stream=Stream.of("小米","小黄","小花","鑫鑫");
        //函数是接口 变量名=类实例：：方法名 的方式对改方法进行引用
        stream.filter(name->name.startsWith("小")).forEach(System.out::println);
    }
    @Test
    public void test05()
    {
       List list=new ArrayList();
       list.add(10);
        list.add(1);
        list.add(6);
        list.add(9);
        list.add(7);
        list.add(4);
        list.add(3);
        list.stream().sorted().forEach(System.out::println);
    }
    @Test
    public void test06()
    {
        List list=new ArrayList();
        list.add(10);
        list.add(1);
        list.add(6);
        list.add(9);
        list.add(7);
        list.add(4);
        list.add(3);
        //Comparator.reverseOrder();返回一个自然排序相反的比较器
        list.stream().sorted(Comparator.reverseOrder()).forEach(System.out::println);

    }
    @Test
    public void test07()
    {
        List<Student>list=new ArrayList<>();
        list.add(new Student(1,"Mahesh",12));
        list.add(new Student(2,"Suresh",15));
        list.add(new Student(3,"Nilesh",10));
        System.out.println("----------------根据名称自然排序---------------------");
        list.stream().sorted().forEach(System.out::println);
        System.out.println("----------------根据名称反转自然排序---------------------");
        list.stream().sorted(Comparator.reverseOrder()).forEach(System.out::println);
        System.out.println("----------------使用比较器对年龄属性进行自然排序---------------------");
        //Comparator.comparing(Student::getAge)返回，对象集合以类属性进行升序排序
        list.stream().sorted(Comparator.comparing(Student::getAge)).forEach(System.out::println);
        System.out.println("----------------使用比较器对年龄属性进行升序，然后进行降序---------------------");
        //返回，对象集合以类属性进行升序排序
        //在对结果进行降序，反转
        list.stream().sorted(Comparator.comparing(Student::getAge).reversed()).forEach(System.out::println);


    }
    @Test
    public void test08()
    {
        String[] arr={"小李","小王","小刘","小赵","小王"};
        Stream<String> stream= Stream.of(arr);
        //使用imit对stream牛中的数据操作，只要前三个元素
        stream.limit(3).forEach(System.out::println);

    }
    @Test
    public void test09()
    {
        List<String>list=  Arrays.asList("aa","bb","cc","bb","cc","aa","aa");
        long count = list.stream().distinct().count();
        System.out.println("count = " + count);
        //Collectors.joining(",")可以指定字符串链接时的分隔符，前缀和后缀字符串，来连接stream中的流
        String collect = list.stream().distinct().collect(Collectors.joining(","));
        System.out.println("collect = " + collect);
    }
    @Test
    public void test10()
    {
        List<Book> list=new ArrayList<>();
        list.add(new Book("CoreJava",200));
        list.add(new Book("CoreJava",200));
        list.add(new Book("LearningFreeMarker",200));
        list.add(new Book("SpringMVC",200));
        list.add(new Book("spingMVC",200));
       long cout=list.stream().distinct().count();
        System.out.println("cout = " + cout);
       list.stream().distinct().forEach(System.out::println);
    }
    @Test
    public void test11()
    {
        String[] arr={"小李","小王","小刘","小赵","小王"};
        Stream<String>stream=Stream.of(arr);
        stream.skip(2).forEach(name-> System.out.println(name));
    }
    @Test
    public  void test12()
    {
        List<String>list=Arrays.asList("3","6","8","14","15");
        /*
        * mapToInt();接收一个函数作为参数
        * 改函数会被应用到每个元素上
        * 并将其映射成为一个新的元素，返回新的流；IntStream
        * 这种流中的元素都是原始数据类型，比如int double long*/
        IntStream intStream = list.stream().mapToInt(num -> Integer.parseInt(num)).filter(num -> num % 3 == 0);
        intStream.forEach(System.out::println);
    }
    @Test
    public void test13()
    {/*
    rang()表示生成数值范围 ，可以用于IntStream(int)和Long Stream（long）的
    静态方法。参数，1接收起始值，2，接收结束值，结果不包含结束值*/

        IntStream intStream=IntStream.range(1,100).skip(85);
        /*boxed();将int类型转换成stream
        * */
        Stream<Integer> stream = intStream.boxed();
        /*collect();收集器，就是吧一个流收集起来，最终可以是收集成一个值，亦可以收集成一个新的集合，
        collect主要依赖于Java.util.Collectors类内置的静态方法
        * */
        List<Integer> collect = stream.collect(Collectors.toList());
        System.out.println("collect = " + collect);


    }
}