代码编织梦想

package com.example.testutils.service.impl;

import com.example.testutils.domain.LicensePlateInfo;
import com.example.testutils.domain.Person;
import org.apache.commons.compress.utils.Lists;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
 * @author Cheertan
 * @date 2023-01-10
 */
public class DeclarativeFunctionTest {
    public List<Person> infos;
    public List<Integer> numberList;

    @BeforeEach
    void init() {
        infos = new ArrayList<>();
        numberList = new ArrayList<>();
        infos.add(new Person("lily", 18));
        infos.add(new Person("nick", 20));
        infos.add(new Person("bob", 22));
        numberList.add(2);
        numberList.add(24);
        numberList.add(21);
        numberList.add(21);
        numberList.add(200);
    }

    @Test
    void testDeclarative() {
        infos.stream().limit(2).forEach(System.out::println);
        List<Person> personList = infos.stream()
                .filter(person -> person.getAge() > 18).collect(Collectors.toList());
        personList.forEach(person -> System.out.println(person));
    }

    @Test
    void rangeIterate() {
        IntStream.range(0, infos.size() - 1).
                forEach(index -> {
                    Person p = infos.get(index);
                    System.out.println(p);
                });

        IntStream.rangeClosed(0, infos.size() - 1).forEach(index -> {
            System.out.println(infos.get(index));
        });

        IntStream.iterate(0, operand -> operand + 1).limit(10)
                .forEach(System.out::println);
    }

    @Test
    void MinOrMax() {
        //get min number
        System.out.println(numberList.stream().min(Integer::compare).get());
        // get max number
        System.out.println(numberList.stream().min(Comparator.reverseOrder()).get());
    }

    @Test
    void distinct() {
        List<Integer> collect = numberList.stream().distinct()
                .sorted(Comparator.reverseOrder())
                .collect(Collectors.toList());
        collect.forEach(System.out::println);
    }


    /**
     * filter使用的时候会创建一个predicate的类作为stream的判断条件
     */
    @Test
    void filterPredicate() {
        Predicate<Person> personPredicate = person -> person.getAge() > 18;
        infos.stream()
                .filter(personPredicate)
                .collect(Collectors.toList())
                .forEach(System.out::println);
    }

    @Test
    void reduce() {
        String[] strs = {"m", "y", "name", "is"};
        List<ArrayList<String>> names = Lists.newArrayList();
        ArrayList<String> subname = new ArrayList<>();
        subname.add("nick");
        names.add(subname);
        System.out.println(Arrays.stream(strs).reduce("", (a, b) -> a + b));
        System.out.println(Arrays.stream(strs).reduce("", String::concat));
//        Arrays.stream(strs).forEach(System.out::println);
    }

    @Test
    void joinWithStream() {
        String[] strs = {"my", "first", "name", "is"};
        String join = "";
        for (String s : strs) {
            join = join + s + ", ";
        }
        System.out.println(Arrays.stream(strs)
                .map(String::toUpperCase)
                .collect(Collectors.joining(",")));
    }

    @Test
    void understandCollect() {
        List<Integer> nameCollect = infos.stream()
                .map(Person::getAge)
                .collect(Collectors.toList());
        nameCollect.forEach(System.out::println);

        infos.stream()
                .map(Person::getAge)
                .collect(() -> new ArrayList<Integer>(),
                        (list, element) -> list.add(element),
                        (list1, list2) -> list1.addAll(list2))
                .forEach(System.out::println);

        infos.stream()
                .map(Person::getAge)
                .collect(ArrayList::new,
                        ArrayList::add,
                        ArrayList::addAll)
                .forEach(System.out::println);
    }


    /**
     * @param :
     * @return void
     * @description
     * .collect被称为TerminalOperation,lazy
     * 当filter,多个map一起组合时,符合第一个filter的数据会马上执行下一个map,而不是把filter全部筛选出后再执行后面的map
     * @author cheertan
     * @date 2023/1/11 15:13
     **/
    @Test
    void intermediateAndTerminalOperation() {
        System.out.println(infos.stream()
                .filter(person -> {
                    System.out.println(person);
                    return person.getAge() <= 18;
                })
                        .map(person -> {
                            System.out.println("mapping person " + person);
                            return person.getAge();
                        })
                .map(age -> {
                    System.out.println("mapping age " + age );
                    return age + 1;
                })
                .collect(Collectors.toList())
        );
    }

}

函数式编程视频教程

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/weixin_43877605/article/details/128726693

一文带你入门Java Stream流,太强了-爱代码爱编程

两个星期以前,就有读者强烈要求我写一篇 Java Stream 流的文章,我说市面上不是已经有很多了吗,结果你猜他怎么说:“就想看你写的啊!”你看你看,多么苍白的喜欢啊。那就“勉为其难”写一篇吧,嘻嘻。 单从“Stream”这个单词上来看,它似乎和 java.io 包下的 InputStream 和 OutputStream 有些关系。实际上呢,没毛

Java8 Stream:2万字20个实例,玩转集合的筛选、归约、分组、聚合-爱代码爱编程

Java8 Stream 1 Stream概述2 Stream的创建3 Stream的使用案例使用的员工类3.1 遍历/匹配(foreach/find/match)3.2 筛选(filter)3.3 聚合(max/min/count)3.4 映射(map/flatMap)3.5 归约(reduce)3.6 收集(collect)3.6.1 归集(t

java stream order by_Java Stream 使用详解-爱代码爱编程

Stream是 Java 8新增加的类,用来补充集合类。 Stream代表数据流,流中的数据元素的数量可能是有限的,也可能是无限的。 Stream和其它集合类的区别在于:其它集合类主要关注与有限数量的数据的访问和有效管理(增删改),而Stream并没有提供访问和管理元素的方式,而是通过声明数据源的方式,利用可计算的操作在数据源上执行,当然BaseS

Java Stream流(详解)-爱代码爱编程

一、Stream流引入         Lambda表达式,基于Lambda所带来的函数式编程,又引入了一个全新的Stream概念,用于解决集合类库既有的鼻端。(Lambda表达式详解在上篇博客内容)         现有一个需求:                 将list集合中姓张的元素过滤到一个新的集合中                 然后

Java stream 排序-爱代码爱编程

数字排序 List<Student> students = new ArrayList<>(); Student student1 = new Student("六年级","Math","小张",1D); students.add(student1); Student student2 = new Student("三年级上",

java stream详解-爱代码爱编程

Stream数据源 1. Collection 2. Arrays Stream流处理逻辑 数据源(datasource) --> 数据转换(中间操作) -->数据转换(中间操作) -->执行操作获取结果(终止操作) Stream创建 通过collection创建( collection.stream() or collect

java Stream sorted 排序-爱代码爱编程

List<类> list; 代表某集合 //返回 对象集合以类属性一升序排序 list.stream().sorted(Comparator.comparing(类::属性一)); //返回 对象集合以类属性一降序排序 注意两种写法 list.stream().sorted(Comparator.comparing(类::属性一).re

java steam原理和常见操作_王者之路001的博客-爱代码爱编程

1.Stream原理 Stream是JAVA8开始的新的用法。Stream本意为流,Stream也确实如流一样,给操作带来了方便。 Stream的表现是: 1)提供一个特定类型的队列; 2)提供一系列操作,让队列拥有类似于SQL语句的操作。 Stream的原理或背后的基本支持是ForkJoinPool。ForkJoinPool主要用来使用分治法(

java stream map的使用_birdman98的博客-爱代码爱编程

介绍 经常的,我们需要抽取一个对象列表中的某个属性作为新列表,此时我们就可以使用Java8新特性Lambda表达式来快速处理,通过情况下如果不适用Lambda表达式,我们一般会通过for循环将对象列表中每个实体的属性值提取

java stream过滤_java stream过滤器_m0_67393828的博客-爱代码爱编程

java stream过滤 Java Stream filter can be very helpful when you want to do some processing only on some elements

java stream分组之后求和_癞蛤蟆吃了小天鹅的博客-爱代码爱编程

注:elementComponentDtos.stream().mapToDouble(ElementComponentDto::getAmount).sum();为求和可以根据返回类型的不同去改变相对应的求和函数(mapToDouble) 注 BigDecimal为了保留double类型两位小数(方法二和三没做处理) 注:collect1为原数据 col

java stream map-爱代码爱编程

1 背景 1)  JDK1.8推出的新特性 stream。 2)  stream是一种新的编程思想,提供了很多函数,简化了代码量,提高了开发速度 3)  Map函数是其中一个具体的方法 4) MapReduce 模型将数据处理方式抽象为 map 和 reduce,其中 map 也叫映射,是数据的一对一映射,通常完成数据转换的工作 2

java stream reduce_java的stream的reduce-爱代码爱编程

1 背景 1.1 编程思想 Map Reduce是一种编程思想 ,MapReduce 模型将数据处理方式抽象为 map 和 reduce map 也叫映射,它表现的是数据的一对一映射,通常完成数据转换的工作 reduce 被称为归约,它表示另外一种映射方式,通常完成聚合的工作 1.2 具体应用 有一组数据,数据是整数,需要求这一

java——stream流_加入stream-爱代码爱编程

Stream流 stream流的概述 在Java 8中,得益于Lambda所带来的函数式编程, 引入了一个全新的Stream流概念。 目的:用于简化集合和数组操作的[[API]]。 案例:体验Stream流