[Python知识库]java新特性_Stream流_隋小白

Stream流

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author suizh
 * @version 1.0
 * @date 2021/9/22 14:35
 * 常用方法
 * count   统计个数   是终结方法 不支持链式调用
 * forEach 逐一处理   是终结方法 不支持链式调用
 * filter  过滤      函数拼接   支持链式调用
 * limit   取用前几个 函数拼接   支持链式调用
 * skip    跳过前几个 函数拼接   支持链式调用
 * map     映射      函数拼接   支持链式调用
 * concat  组合      函数拼接   支持链式调用
 */
public class StreamTest {
    /**
     * 调用forEach方法进行逐个处理
     * void forEach(Consumer<? super T> action);
     * // 该方法接收一个Consumer接口函数(这是一个功能界面，因此可以用作lambda表达式或方法引用的赋值对象)，会将每一个流元素交给该函数进行处理。
     */
    @Test
    public void test1() {
        // 得到流对象
        String[] names = {"aa", "bb", "cc", "dd"};
        Stream<String> stream = Stream.of(names);
        /**
         * 两个均可
         */
//        stream.forEach((String c) -> {
//            System.out.println(c);
//        });

        stream.forEach(c -> System.out.println(c));
    }

    /**
     * count:统计个数
     * long count(); // 返回一个long值代表元素个数（不再像旧集合那样是int值）。
     */
    @Test
    public void test2(){
        // 统计个数
        long count = Stream.of("aa", "bb", "cc", "dd").count();

        System.out.println("arrays->"+count);

        ArrayList<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        long listCount = list.stream().count();
        System.out.println("list->"+listCount);

    }
    /**
     * filter:过滤
     * 可以通过filter方法将一个流转换成另一个子集流
     * Stream<T> filter(Predicate<? super T> predicate);
     * // 该接口接收一个Predicate函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件
     */
    @Test
    public void test3(){
        // 定义集合
        ArrayList<String> list = new ArrayList<>();
        // 添加数据
        list.add("sui aa");
        list.add("sui bb");
        list.add("cc");
        list.add("dd");
        list.add("sui ee");

        // 只要所有带有sui的数据
        Stream<String> s = list.stream().filter((String c) -> c.startsWith("sui"));
        // 逐个处理(打印)
        s.forEach(c-> System.out.println(c));
    }
    /**
     * limit:取用前几个
     * limit方法可以对流进行截取，只取用前n个。
     * Stream<T> limit(long maxSize); // 参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。
     */
    @Test
    public void test4() {
        // 定义集合
        ArrayList<String> list = new ArrayList<>();
        // 添加数据
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
        list.add("ee");

        // 获得前3个元素数据
        list.stream().limit(3).forEach(c-> System.out.println("获得前3个元素数据"+c));
    }
    /**
     * skip:跳过前几个
     * 如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流
     * Stream<T> skip(long n); // 如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。
     */
    @Test
    public void test5() {

        // 定义集合
        ArrayList<String> list = new ArrayList<>();
        // 添加数据
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
        list.add("ee");

        Stream<String> stream = list.stream();
        // 获得前3个元素数据
        stream.limit(3).forEach(c-> System.out.println("获得前3个元素数据"+c));
//        stream.limit(4).forEach(name-> System.out.println(name));//会报错 一个stream流只能操作一次

        // 跳过前2个元素
        list.stream().skip(2).forEach(c-> System.out.println("跳过前2个元素"+c));

        // 获得最后2个元素数据
        list.stream().skip(list.size()-2).forEach(c-> System.out.println("获得最后2个元素数据"+c));
    }
    /**
     * map:映射
     * 如果需要将流中的元素映射到另一个流中，可以使用map方法。
     * <R> Stream<R> map(Function<? super T, ? extends R> mapper);
     * // 接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流
     */
    @Test
    public void test6(){
        // 定义集合
        ArrayList<String> list = new ArrayList<>();
        // 添加数据
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");

        // 将list转成对应的流【类型是String的】
        Stream<String> stream = list.stream();

        // 将stream流映射到另外一个流【类型已经发生变化！类型是Integer】
        Stream<Integer> stream1 = stream.map((String s) ->{return Integer.parseInt(s);});

        // 对数据进行加法运算+10
        stream1.forEach(s-> System.out.println(s+5));
    }
    /**
     *  concat:组合
     *  如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat
     *  static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b);
     */
    @Test
    public void test7() {
        // 定义2个数组
        String[] s1 = {"a","b","c","d"};
        String[] s2 = {"A","B","C","D"};

        // 将2个数组转成对应的Stream流
        Stream<String> stream1 = Stream.of(s1);
        Stream<String> stream2 = Stream.of(s2);

        // 将2个流合并为一个流
        Stream<String> stream = Stream.concat(stream1, stream2);

        // 逐个处理(打印出来)
        stream.forEach(s-> System.out.println(s));
    }
    /**
     * 收集到集合中
     * Stream流提供collect方法，其参数需要一个java.util.stream.Collector<T,A, R>接口对象来指定收集到哪种集合中
     * java.util.stream.Collectors类提供一些方法，可以作为Collector接口的实例：stream.collect(Collectors.toList);
     * * Collectors的静态方法：
     * public static <T> Collector<T, ?, List<T>> toList()：转换为List集合。
     * public static <T> Collector<T, ?, Set<T>> toSet()：转换为Set集合。
     */
    @Test
    public void test8() {
        Stream<String> stream = Stream.of("10", "20", "30", "40", "50");
        List<String> list = stream.collect(Collectors.toList());
        System.out.println(list);
//        Set<String> set = stream.collect(Collectors.toSet());
//        System.out.println(set);

        //Collectors.groupingBy()
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("aa",18));
        students.add(new Student("bb",18));
        students.add(new Student("cc",15));
        students.add(new Student("dd",20));
        students.add(new Student("ee",22));
        Map<Integer, List<Student>> listMap = students.stream().collect(Collectors.groupingBy(Student::getAge));
        for (Integer key : listMap.keySet()) {
            System.out.println(key);
            List<Student> students1 = listMap.get(key);
            students1.stream().forEach((Student a)-> System.out.println(a));
        }
    }
    /**
     * 收集到数组中
     * Stream提供toArray方法来将结果放到一个数组中，由于泛型擦除的原因，返回值类型是Object[]的：
     * Object[] toArray();
     */
    @Test
    public void test9() {
        Stream<String> stream = Stream.of("10", "20", "30", "40", "50");
        Object[] objArray = stream.toArray();
        Stream<Object> stream1 = Stream.of(objArray);
        stream1.forEach((Object a)->{
            System.out.println(a);
        });
    }

}