Stream流学习笔记_隋小bai

隋小白

已于 2022-03-14 20:10:58 修改

阅读量146

点赞数 1

分类专栏： java新特性文章标签： java

于 2021-10-04 23:21:56 首次发布

本文链接：https://blog.csdn.net/weixin_44066672/article/details/120609558

版权

java新特性专栏收录该内容

2 篇文章 0 订阅

订阅专栏

此为学习笔记,若有侵权请联系我,谢谢!!!

Stream流主要是为了操作集合相关的数据

创建流

创建stream的四种方式
1.通过集合
2.通过数组
3.stream.of
4.创建无限流  迭代(iterate)  生成(qenerate)

package new1_8.stream.s1creat;

import new1_8.stream.Entity;
import org.junit.Test;

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

/**
 * @author suizh
 * @version 1.0
 * @date 2022/3/13 20:09
 */
public class CreatStream {
    /**
     * 创建stream的四种方式
     * 1.通过集合
     * 2.通过数组
     * 3.stream.of
     * 4.创建无限流  迭代(iterate)  生成(qenerate)
     */
    //通过集合
    @Test
    public void test01() {
        ArrayList<String> list = new ArrayList<>();
        //顺序流
        Stream<String> stream = list.stream();
        //并行流
        Stream<String> stringStream = list.parallelStream();
    }

    //通过数组
    @Test
    public void test02() {
        int[] arr = new int[5];
        IntStream stream = Arrays.stream(arr);
    }
    //通过stream.of
    @Test
    public void test03() {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);
    }
    //创建无限流
    @Test
    public void test04() {
        //迭代
        Stream.iterate(0,c->c+1).limit(5).forEach(System.out::println);
        System.out.println(Entity.divider);
        //生成
        Stream.generate(Math::random).limit(5).forEach(c-> System.out.println(c));
    }
}

筛选与切片

filter(Predicate p)	接收Lambda ，从流中排除某些元素
distinct()	筛选，通过流所生成元素的hashCode() 和equals() 去除重复元素
limit(long maxSize)	截断流，使其元素不超过给定数量
skip(long n)	跳过元素，返回一个扔掉了前n 个元素的流。若流中元素不足n 个，则返回一个空流。与limit(n)互补

package new1_8.stream.s2screenslicer;

import new1_8.stream.Entity;
import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author suizh
 * @version 1.0
 * @date 2022/3/13 20:17
 */
public class ScreenSlicerTest {
    /**
     * 筛选与切片
     */
    /**
     * filter(Predicate p)	接收Lambda ，从流中排除某些元素
     * distinct()	筛选，通过流所生成元素的hashCode() 和equals() 去除重复元素
     * limit(long maxSize)	截断流，使其元素不超过给定数量
     * skip(long n)	跳过元素，返回一个扔掉了前n 个元素的流。若流中元素不足n 个，则返回一个空流。与limit(n)互补
     */
    List<Entity> entities = Entity.CreatEntity();
    //分割线


    //过滤
    @Test
    public void test01() {
        //年龄大于30  使用filter
        entities.stream().filter(c -> c.getAge() > 30).forEach(System.out::println);
        System.out.println(Entity.divider);
        //年龄大于30  名字长度大于等于3
        entities.stream().filter(c -> c.getAge() > 30)
                .filter(c -> c.getName().length() >= 3)
                .forEach(System.out::println);
    }

    //去重
    @Test
    public void test02() {
        //去重
        //对集合中相同元素进行去重
        List<Integer> numList = Arrays.asList(1, 1, 2, 3, 1, 2, 5);
        numList.stream().distinct().forEach(c -> System.out.print(c + "  "));
        System.out.println();
        System.out.println(Entity.divider);
        //根据名字进行去重
        entities.stream().distinct().forEach(System.out::println);//不可取
        System.out.println(Entity.divider);
        /**
         * collectingAndThen先进行结果集的收集，然后将收集到的结果集进行下一步的处理
         * public static <T,A,R,RR> Collector<T,A,RR> collectingAndThen(Collector<T,A,R> downstream,Function<R,RR> finisher)
         * 参数类型
         * T -输入元素的类型           Entity
         * A -下游集电极中间堆积型      String name的类型
         * R -下游集结果类型           TreeSet
         * RR -结果集的结果类型        ArrayList
         * 第一个参数是Collector接口的子类   第二个参数是一个Function函数
         */
        List<Entity> list = entities.stream().collect(
                Collectors.collectingAndThen(
                        Collectors.toCollection(() -> new TreeSet<Entity>(
                                Comparator.comparing(c -> c.getName()))), ArrayList::new)
        );
        list.stream().forEach(System.out::println);
    }

    //跳过  截断
    @Test
    public void test03() {
        //跳过前三个
        entities.stream().skip(3).forEach(System.out::println);
        System.out.println(Entity.divider);
        //截断前三个
        entities.stream().limit(3).forEach(System.out::println);
    }
}

映射

map(Function f)	接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
mapToDouble(ToDoubleFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream。
mapToInt(ToIntFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream。
mapToLong(ToLongFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream。
flatMap(Function f)	接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

package new1_8.stream.s3map;

import new1_8.stream.Entity;
import new1_8.stream.EntityAddress;
import org.junit.Test;

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

/**
 * @author suizh
 * @version 1.0
 * @date 2022/3/13 20:44
 */
public class MapTest {
    /**
     * 映射
     *
     * map(Function f)	接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
     * mapToDouble(ToDoubleFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream。
     * mapToInt(ToIntFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream。
     * mapToLong(ToLongFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream。
     * flatMap(Function f)	接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
     */
    List<Entity> entities = Entity.CreatEntity();

    //map
    @Test
    public void test01() {
        entities.stream().map(Entity::getName).forEach(System.out::println);
    }

    //mapToDouble
    @Test
    public void test02() {
        entities.stream().mapToDouble(Entity::getAge).forEach(System.out::println);
    }

    //mapToInt
    @Test
    public void test03() {
        entities.stream().mapToInt(Entity::getAge).forEach(System.out::println);
    }

    //mapToLong
    @Test
    public void test04() {
        entities.stream().mapToLong(Entity::getAge).forEach(System.out::println);
    }

    @Test
    public void test05() {
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        //        flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
        //地址值
        list.stream().map(MapTest::fromStringToStream).forEach(System.out::println);
        //具体内容
        list.stream().flatMap(MapTest::fromStringToStream).forEach(System.out::println);

    }

    public static Stream<Character> fromStringToStream(String str) {
        ArrayList<Character> list = new ArrayList<>();
        for (Character c : str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }

    @Test
    public void dizhi() {
        EntityAddress entityAddress = new EntityAddress();
        //类的地址值
        System.out.println(entityAddress);
        System.out.println(Entity.divider);
        //类的相对路径
        Class<? extends EntityAddress> clazz = entityAddress.getClass();
        System.out.println(clazz);
        System.out.println(Entity.divider);
        //类的哈希值
        System.out.println(Integer.toHexString(entityAddress.hashCode()));
    }
}

排序

sorted()	产生一个新流，其中按自然顺序排序
sorted(Comparator com)	产生一个新流，其中按比较器顺序排序

package new1_8.stream.s4sort;

import new1_8.stream.Entity;
import org.junit.Test;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

/**
 * @author suizh
 * @version 1.0
 * @date 2022/3/13 20:53
 */
public class SortTest {
    /**
     * 排序
     *
     * sorted()	产生一个新流，其中按自然顺序排序
     * sorted(Comparator com)	产生一个新流，其中按比较器顺序排序
     */

    List<Entity> entities = Entity.CreatEntity();
    @Test
    public void test01(){
        List<Integer> list = Arrays.asList(1, 2, 4, 3, 6, 3);
        list.stream().sorted().forEach(System.out::println);
        System.out.println(Entity.divider);
        entities.stream().sorted((c1,c2)->{return c1.getAge().compareTo(c2.getAge());}).forEach(System.out::println);
        System.out.println(Entity.divider);
        //lambda简化写法
        entities.stream().sorted((c1,c2)->c1.getAge().compareTo(c2.getAge())).forEach(System.out::println);
        System.out.println(Entity.divider);
        //函数式编程写法
        entities.stream().sorted(Comparator.comparing(Entity::getAge)).forEach(System.out::println);
    }
}

终止操作匹配–查找

package new1_8.stream.s4find;

import new1_8.stream.Entity;
import org.junit.Test;

import java.util.Comparator;
import java.util.List;

/**
 * @author suizh
 * @version 1.0
 * @date 2022/3/13 20:57
 */
public class FindTest {
    /**
     * 终止操作    匹配--查找
     *
     * allMatch(Predicate p)	检查是否匹配所有元素
     * anyMatch(Predicate p)	检查是否至少匹配一个元素
     * noneMatch(Predicate p)	检查是否没有匹配所有元素
     * findFirst()	返回第一个元素
     * findAny()	返回当前流中的任意元素
     * count()	返回流中元素总数
     * max(Comparator c)	返回流中最大值
     * min(Comparator c)	返回流中最小值
     * forEach(Consumer c)	内部迭代(使用Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了)
     */

    List<Entity> entities = Entity.CreatEntity();

    //allMatch(Predicate p)	检查是否匹配所有元素
    @Test
    public void test01() {
        boolean flag = entities.stream().allMatch(c1 -> c1.getName().length() >= 2);
        System.out.println(flag);
    }

    //anyMatch(Predicate p)	检查是否至少匹配一个元素
    @Test
    public void test02() {
        boolean flag = entities.stream().anyMatch(c -> c.getName().equals("李四"));
        System.out.println(flag);
    }

    //noneMatch(Predicate p)	检查是否没有匹配所有元素
    @Test
    public void test03() {
        boolean flag = entities.stream().noneMatch(c -> c.getName().length() >= 9);
        System.out.println(flag);
    }

    //findFirst()	返回第一个元素
    @Test
    public void test04() {
        System.out.println(entities.stream().findFirst().get());
    }

    //findAny()	返回当前流中的任意元素
    @Test
    public void test05() {
        System.out.println(entities.stream().findAny().get());
    }

    //count()	返回流中元素总数
    @Test
    public void test06() {
        System.out.println(entities.stream().count());
    }

    //max(Comparator c)	返回流中最大值
    @Test
    public void test07() {
        Entity entity = entities.stream().max((c1, c2) -> c1.getAge().compareTo(c2.getAge())).get();
        System.out.println(entity);
        System.out.println(Entity.divider);
        Entity entity1 = entities.stream().max(Comparator.comparing(Entity::getAge)).get();
        System.out.println(entity1);
    }
    //min(Comparator c)	返回流中最小值
    @Test
    public void test08(){
        Entity entity = entities.stream().min((c1, c2) -> c1.getAge().compareTo(c2.getAge())).get();
        System.out.println(entity);
        System.out.println(Entity.divider);
        Entity entity1 = entities.stream().min(Comparator.comparing(Entity::getAge)).get();
        System.out.println(entity1);
    }
    //forEach(Consumer c)	内部迭代(使用Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了)
    @Test
    public void test09() {
        entities.stream().forEach(System.out::println);
    }
}

终止操作归约

reduce(T iden, BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回T
reduce(BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回Optional

package new1_8.stream.s6statute;

import new1_8.stream.Entity;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;

/**
 * @author suizh
 * @version 1.0
 * @date 2022/3/13 21:13
 */
public class StatuteTest {
    /**
     *终止操作  归约
     *
     * reduce(T iden, BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回T
     * reduce(BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回Optional
     */

    List<Entity> entities = Entity.CreatEntity();
    //reduce(T iden, BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回T
    @Test
    public void test01(){
        List<Integer> list = Arrays.asList(72,25,32,34,43,56,81,15,29,71);
        Integer sum1 = list.stream().reduce(0, (c1,c2)->c1 + c2);
        System.out.println(sum1);
        System.out.println(Entity.divider);
        Integer sum = list.stream().reduce(0, Integer::sum);
        System.out.println(sum);
        System.out.println(Entity.divider);
        Integer reduce = entities.stream().map(Entity::getAge).reduce(0, (c1, c2) -> c1 + c2);
        System.out.println(reduce);
        System.out.println(Entity.divider);
        Integer reduce1 = entities.stream().map(Entity::getAge).reduce(0, Integer::sum);
        System.out.println(reduce1);
    }
}

终止操作收集

collect(Collector c)	将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法

package new1_8.stream.s7collection;

import new1_8.stream.Entity;
import org.junit.Test;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author suizh
 * @version 1.0
 * @date 2022/3/13 21:23
 */
public class CollectionTest {
    /**
     * 终止操作  收集
     *
     * collect(Collector c)	将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
     */
    List<Entity> entities = Entity.CreatEntity();
    @Test
    public void test01(){
        List<Entity> collect = entities.stream().collect(Collectors.toList());
        System.out.println(collect);
        System.out.println(Entity.divider);
        Set<Entity> collect1 = entities.stream().collect(Collectors.toSet());
        System.out.println(collect1);
        System.out.println(Entity.divider);
        Map<Integer, Entity> collect2 = entities.stream().collect(Collectors.toMap(Entity::getAge, Function.identity()));
        System.out.println(collect2);
    }
    @Test
    public void test02(){
        Map<Integer, List<Entity>> collect = entities.stream().collect(Collectors.groupingBy(Entity::getAge));
        for (Map.Entry<Integer, List<Entity>> integerListEntry : collect.entrySet()) {
            System.out.println(integerListEntry.getKey()+"-->"+integerListEntry.getValue());
        }
        System.out.println(Entity.divider);
        List<Entity> list = entities.stream().collect(
                Collectors.collectingAndThen(
                        Collectors.toCollection(() -> new TreeSet<>(
                                Comparator.comparing(c-> c.getName()))), ArrayList::new)
        );
        list.stream().forEach(System.out::println);
        System.out.println(Entity.divider);
        Map<Boolean, List<Entity>> collect1 = entities.stream().collect(Collectors.partitioningBy(c -> c.getId() % 2 == 0));
        for (Map.Entry<Boolean, List<Entity>> booleanListEntry : collect1.entrySet()) {
            System.out.println(booleanListEntry.getKey()+"-->"+booleanListEntry.getValue());
        }
    }
    /**
     * 收集到数组中
     * 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);
        });

        Stream.of("10", "20", "30", "40", "50").forEach(System.out::println);
    }
}

组合

concat:组合
如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

package new1_8.stream.s8concat;

import org.junit.Test;

import java.util.stream.Stream;

/**
 * @author suizh
 * @version 1.0
 * @date 2022/3/14 20:00
 */
public class ConcatTest {
    /**
     *  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));
    }
}

隋小白

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Stream流学习笔记_隋小bai

此为学习笔记,若有侵权请联系我,谢谢!!!常用方法count 统计个数是终结方法不支持链式调用forEach 逐一处理是终结方法不支持链式调用filter 过滤函数拼接支持链式调用limit 取用前几个函数拼接支持链式调用skip 跳过前几个函数拼接支持链式调用map 映射函数拼接支持链式调用concat 组合函数拼接支持链式调用forEach /** * 调用
复制链接

扫一扫