探索Java 8新特性：流式编程（Stream流）

最新推荐文章于 2023-10-04 20:00:41 发布
最新推荐文章于 2023-10-04 20:00:41 发布
阅读量714 收藏 4
点赞数 3
文章标签： java jdk 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50033700/article/details/132269492
版权

目录

一、导言

二、什么是流式编程（Stream流）

三、Stream流的工作图

四、Stream流中常见的api

一、获取Stream流对象的方式

 二、Stream流中间操作

1.过滤(filter)：对Stream流中的数据进行过滤

2.映射(map)：对Stream流中的数据进行转换

3.映射(flatMap)：对Stream流中的数据作扁平化处理

4.排序(sort)：对Stream流中的数据做排序

5.去重(distinct)：对Stream流中的数据做去重操作

6.截取(limit)：用于截取流中的元素

 三、Stream流终止操作

 1.收集(collect)：用于将流中的元素收集到一个集合或者其他容器中

2.规约(reduce)：用于将流中的元素进行规约操作，它接收一个BinaryOperator参数，用于定义规约的逻辑

3.循环(forEach)：用来遍历流中的数据

4.计数(count)：统计流中元素个数

5.查找(find)：获取满足条件的第一个元素

6.匹配(match)：判断流中元素是否满足条件，返回值为Boolean类型

7.最值(max,min)

五、实际应用案例

一、导言

        简要介绍Java 8中引入的流式编程特性。强调流式编程在简化代码、提高性能和增强可读性方面的重要性。提及本文将深入探讨流式编程的定义、基本操作、中间操作、终端操作以及实际应用案例。

二、什么是流式编程（Stream流）

        流式编程（Stream流）是一种在计算机编程中用于处理数据集合的新型方法。它在Java 8中被引入，并在之后的版本中得到了扩展和优化。流式编程的核心思想是以一种类似于流水线的方式来处理数据，通过一系列的操作来对数据进行筛选、转换、合并和归约，从而实现更简洁、更高效、更可读的代码编写。

三、Stream流的工作图

四、Stream流中常见的api

一、获取Stream流对象的方式

  1. 集合类的stream()方法：通过集合类如List、Set、Map等的stream()方法获取对应集合的流对象。
  2. Arrays类的stream()方法：通过Arrays类的静态方法stream()获取数组的流对象。
  3. Stream类的of()方法：通过Stream类的静态方法of()创建一个包含指定元素的流对象。
  4. Stream类的builder()方法：通过Stream类的builder()方法手动创建一个流对象，并通过add()方法添加元素。
// 通过集合类的stream()方法
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

// 通过Arrays类的stream()方法
String[] array = {"a", "b", "c"};
Stream<String> stream = Arrays.stream(array);

// 通过Stream类的of()方法
Stream<String> stream = Stream.of("a", "b", "c");

// 通过Stream类的builder()方法
Stream.Builder<String> builder = Stream.builder();
builder.add("a").add("b").add("c");
Stream<String> stream = builder.build();

 二、Stream流中间操作

1.过滤(filter)：对Stream流中的数据进行过滤

​
public static void main(String[] args) {

        // 构建数据源
        Person person1 = new Chinese("大白", 25, Sex.woman);
        Person person2 = new Chinese("小赵", 28, Sex.man);
        Person person3 = new Chinese("小明", 20, Sex.man);
        Person person4 = new Chinese("小兰", 17, Sex.woman);
        Person person5 = new Chinese("小赵", 18, Sex.man);
        Person person6 = new Chinese("小马", 50, Sex.man);

        List<Person> peopleList = Arrays.asList(person1, person2, person3, person4, person5, person6);
        // 需求:筛选出年龄大于25的学生信息
        peopleList.stream() // 获取流对象
                .filter(person -> person.getAge() > 25)// 筛选出年龄大于25的学生信息
                .forEach(System.out::println);         // 打印输出满足条件的对象信息
    }

​

2.映射(map)：对Stream流中的数据进行转换

public class StreamMap {

    public static void main(String[] args) {
        // 构建数据源
        Person person1 = new Chinese("大白", 25, Sex.woman);
        Person person2 = new Chinese("小赵", 28, Sex.man);
        Person person3 = new Chinese("小明", 20, Sex.man);
        Person person4 = new Chinese("小兰", 17, Sex.woman);
        Person person5 = new Chinese("小赵", 18, Sex.man);
        Person person6 = new Chinese("小马", 50, Sex.man);

        List<Person> peopleList = Arrays.asList(person1, person2, person3, person4, person5, person6);

        // 需求：获取所有对象的姓名
        peopleList.stream() // 获取流对象
                .map(person -> person.getName()) // 将Person类型 --> String类型
                .forEach(System.out::println);   // 打印输出所有对象姓名
    }
}

3.映射(flatMap)：对Stream流中的数据作扁平化处理

// Grades类的定义如下:
public class Grades {

    // 班级名称
    public String className;

    public List<Person> personList;
}

public class FlatMapTest {

    public static void main(String[] args) {

        // 构建数据源
        List<Grades> classList = new ArrayList<>();

        Person person = new Chinese("小明", 25, Sex.man);
        Person person1 = new Chinese("小红", 23, Sex.woman);
        Person person2 = new Chinese("小白", 22, Sex.man);
        Person person3 = new Chinese("小黑", 20, Sex.man);
        Person person4 = new Chinese("小兰", 29, Sex.woman);
        Person person5 = new Chinese("小李", 18, Sex.man);
        Person person6 = new Chinese("小黄", 50, Sex.man);
        Person person7 = new Chinese("小青", 29, Sex.woman);
        Person person8 = new Chinese("小倩", 18, Sex.man);
        Person person9 = new Chinese("小灰", 50, Sex.man);

        // 班级1的学生信息
        Grades class1 = new Grades("class1", Arrays.asList(person, person1, person2, person3));
        // 班级2的学生信息
        Grades class2 = new Grades("class2", Arrays.asList(person4, person5, person6));
        // 班级3的学生信息
        Grades class3 = new Grades("class3", Arrays.asList(person7, person8, person9));
        classList.add(class1);
        classList.add(class2);
        classList.add(class3);

        // 需求:获取所有班级的学生信息,并打印输出
        classList.stream() // 获取流对象
                .flatMap(x->x.getPersonList().stream()) // 对Grades对象中的personList做扁平化处理
                .forEach(System.out::println); // 打印展示所有班级学生信息
    }
}

4.排序(sort)：对Stream流中的数据做排序

public class StreamSortBy {

    public static void main(String[] args) {
        // 构建数据源
        Person person1 = new Chinese("大白", 25, Sex.woman);
        Person person2 = new Chinese("小赵", 28, Sex.man);
        Person person3 = new Chinese("小明", 20, Sex.man);
        Person person4 = new Chinese("小兰", 17, Sex.woman);
        Person person5 = new Chinese("小赵", 18, Sex.man);
        Person person6 = new Chinese("小马", 50, Sex.man);

        List<Person> peopleList = Arrays.asList(person1, person2, person3, person4, person5, person6);
        // 需求:按照年龄升序排序
        peopleList.stream() // 获取流对象
                .sorted(Comparator.comparing(Person::getAge)) //传入一个比较器，按照年龄升序排列
                .forEach(System.out::println);  // 打印排序后的所有学生信息

    }
}

5.去重(distinct)：对Stream流中的数据做去重操作

public class StreamDistinct {

    public static void main(String[] args) {
        // 需求:去除重复元素
        Stream.of("张三", "李四", "王五", "张三", "赵六", "李四")   // 获取流对象
                .distinct() // 对重复元素进行去重操作
                .forEach(System.out::println); // 打印去重后的元素
    }
}

6.截取(limit)：用于截取流中的元素

public class StreamLimit {

    public static void main(String[] args) {
        // 构建数据源
        Person person1 = new Chinese("大白", 25, Sex.woman);
        Person person2 = new Chinese("小赵", 28, Sex.man);
        Person person3 = new Chinese("小明", 20, Sex.man);
        Person person4 = new Chinese("小兰", 17, Sex.woman);
        Person person5 = new Chinese("小赵", 18, Sex.man);
        Person person6 = new Chinese("小马", 50, Sex.man);

        List<Person> peopleList = Arrays.asList(person1, person2, person3, person4, person5, person6);
        // 需求:获取年龄最小的学生信息
        peopleList.stream()
                .sorted(Comparator.comparingInt(Person::getAge)) // 按照年龄升序排列
                .limit(1)                                        // 获取排序后的第一个元素
                .forEach(System.out::println);                   // 打印学生信息
    }
}

 三、Stream流终止操作

 1.收集(collect)：用于将流中的元素收集到一个集合或者其他容器中

@Slf4j
public class StreamCollect {

    public Person[] peoples;

    public List<Person> personList;

    // 构建数据源
    @Before
    public void before() {
        Person person = new Chinese("小明", 21, Sex.man);
        Person person1 = new Chinese("大白", 25, Sex.woman);
        Person person2 = new Chinese("小赵", 23, Sex.man);
        Person person3 = new Chinese("小兰", 20, Sex.man);
        Person person4 = new Chinese("小红", 18, Sex.woman);
        Person person5 = new Chinese("小李", 17, Sex.man);
        Person person6 = new Chinese("小麻", 50, Sex.man);
        this.peoples =new Person[]{ person, person1, person2, person3, person4, person5, person6};
        this.personList = Arrays.asList(peoples);
    }

    // 收集成List
    @Test
    public void collectToListTest() {
        // 需求:按照年龄升序排列，并收集为集合
        List<Person> persons = this.personList.stream() // 获取流对象
                .sorted(Comparator.comparingInt(Person::getAge)) // 按照年龄进行排序
                .collect(Collectors.toList());  //收集成集合
    }

    // 收集为map
    @Test
    public void groupBySexTest() {
        // 需求: 按照性别信息分组展示学生信息
        this.personList.stream() // 获取一个流对象
                .collect(Collectors.groupingBy(Person::getSex)) // 按照性别进行分组操作
                .forEach((key, value) -> {                      // 按性别分组打印学生信息
                    value.forEach(System.out::println);
                    System.out.println("================");
                });
    }


    // 收集为map
    @Test
    public void groupByAndAveragingIntTest() {
        // 需求:请计算全班男生的平均年龄和全班女生的平均年龄
        this.personList.stream()    // 获取流对象
                .distinct()         // 去重操作
                .collect(Collectors.groupingBy(Person::getSex, Collectors.averagingInt(Person::getAge))) //按性别分组，并求年龄平均值
                .forEach((sex, aLong) -> log.info("性别:{}, 年龄总和：{}", sex, aLong));   //打印信息

    }
}

2.规约(reduce)：用于将流中的元素进行规约操作，它接收一个BinaryOperator参数，用于定义规约的逻辑

public class StreamReduce {

    /**
     * reduce()方法有两种重载形式：
     *
     * 1.T reduce(T identity, BinaryOperator<T> accumulator)：指定一个初始值identity，通过accumulator定义的规约逻辑，将流中的元素进行累积计算，返回规约结果。
     * 2.Optional<T> reduce(BinaryOperator<T> accumulator)：根据accumulator定义的规约逻辑，将流中的元素进行递归计算，返回Optional类型的规约结果。
     */
    
    // 方式一
    @Test
    public void ReduceTest01() {
        // 需求：求解集合中所有元素的和
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        int sum = numbers.stream()
                .reduce(0, (a, b) -> a + b);
        // sum = 15
    }
    
    // 方式二
    @Test
    public void ReduceTest02() {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        Optional<Integer> max = numbers.stream()
                .reduce(Integer::max);
        // max = Optional[5]
    }
}

3.循环(forEach)：用来遍历流中的数据

public class Stream_ForEach {
    public static void main(String[] args) {
    //获取一个Stream流
    Stream<String>stream= Stream.of("张三","李四","王五","赵六");
        //使用Stream流的方法forEach对stream流中的数据遍历
        stream.forEach(System.out::println);
    }
}

4.计数(count)：统计流中元素个数

public class StreamCount {
    public static void main(String[] args) {
        
        long count = Stream.of("张三", "李四", "赵六", "王五", "小七").count();
        // count --> 5
    }
}

5.查找(find)：获取满足条件的第一个元素

public class StreamFind {

    public Person[] peoples;

    public List<Person> personList;

    // 构建数据源
    @Before
    public void before() {
        Person person = new Chinese("小明", 21, Sex.man);
        Person person1 = new Chinese("大白", 25, Sex.woman);
        Person person2 = new Chinese("小李", 23, Sex.man);
        Person person3 = new Chinese("小兰", 20, Sex.man);
        Person person4 = new Chinese("小红", 18, Sex.woman);
        Person person5 = new Chinese("小李", 17, Sex.man);
        Person person6 = new Chinese("小麻", 50, Sex.man);
        this.peoples =new Person[]{ person, person1, person2, person3, person4, person5, person6};
        this.personList = Arrays.asList(peoples);
    }

    @Test
    public void findTest01() {
        // 需求：查找姓名为小明的学生信息,找不到则抛出异常信息
        Person result = this.personList.stream()
                .filter(person -> "小明".equals(person.getName()))
                .findFirst()
                .orElseThrow(RuntimeException::new);
        System.out.println(result);
    }

}

6.匹配(match)：判断流中元素是否满足条件，返回值为Boolean类型

@Slf4j
public class AnyMatchStreamTest {
    public Person[] peoples;

    public List<Person> personList;

    @Before
    public void before() {
        Person person = new Chinese("小明", 22, Sex.man);
        Person person1 = new Chinese("小红", 24, Sex.woman);
        Person person2 = new Chinese("小李", 21, Sex.man);
        Person person3 = new Chinese("小明", 21, Sex.man);
        Person person4 = new Chinese("小红", 19, Sex.woman);
        Person person5 = new Chinese("小李", 18, Sex.man);
        Person person6 = new Chinese("小麻", 50, Sex.man);

        this.peoples =new Person[]{ person, person1, person2, person3, person4, person5, person6};
        this.personList = Arrays.asList(peoples);
    }

    @Test
    public void allMatchTest() {
        // 需求：判断学生年龄是否全部大于20岁
        if (this.personList.stream().allMatch(person -> person.getAge() > 20)) { //流中所有元素满足条件即为true
            System.out.println("学生年龄全部大于20岁");
        }
    }

    @Test
    public void anyMatchTest() {
        // 需求：判断所有学生中是否有姓名为"小麻"的学生
        if (this.personList.stream().anyMatch(person -> "小麻".equals(person.getName()))) { // 流中任意一个元素满足条件即为true
            System.out.println("学生中有姓名为小麻的学生");
        }
    }

    @Test
    public void noneMatchTest() {
        // 需求：判断所有学生中是否有姓名为"小麻"的学生
        if (this.personList.stream().noneMatch(person -> "小麻".equals(person.getName()))) { //流中所有元素都不满足条件即为true
            System.out.println("学生中没有姓名为小麻的学生");
        }
    }
}

7.最值(max,min)

public class StreamMaxAndMin {
    public static void main(String[] args) {
        List<Test> list = new ArrayList<>();
        list.add(new Test("小赵",23,new BigDecimal("3000"),new BigDecimal("1.1")));
        list.add(new Test("赵六",24,new BigDecimal("2800"),new BigDecimal("1.2")));
        list.add(new Test("小兰",22,new BigDecimal("3200"),new BigDecimal("1.3")));
        
        //获取年龄最大的人
        Test maxPeople = list.stream().max(Comparator.companing(Test::getAge)).get();
      
        //获取年龄最小的人
        Test minPeople = list.stream().min(Comparator.companing(Test::getAge)).get();
 
    }
}

五、实际应用案例

1.sort用法示例

@Test
    public void sortByAgeTest() {
        // 获取年龄最大的学生信息，没找到这返回"小麻"
        String name = this.personList.stream()
                .max(Comparator.comparing(Person::getAge))
                .orElseGet(() -> new Chinese("小麻", 23, Sex.man)).getName();
        System.out.println(name);
    }

2.flatMap用法示例

@Slf4j
public class FlatMapTest {

    public static void main(String[] args) {

        // 构建数据源
        List<Grades> classList = new ArrayList<>();

        Person person = new Chinese("小明", 25, Sex.man);
        Person person1 = new Chinese("小红", 23, Sex.woman);
        Person person2 = new Chinese("小白", 22, Sex.man);
        Person person3 = new Chinese("小黑", 20, Sex.man);
        Person person4 = new Chinese("小兰", 29, Sex.woman);
        Person person5 = new Chinese("小李", 18, Sex.man);
        Person person6 = new Chinese("小黄", 50, Sex.man);
        Person person7 = new Chinese("小青", 29, Sex.woman);
        Person person8 = new Chinese("小倩", 18, Sex.man);
        Person person9 = new Chinese("小灰", 50, Sex.man);

        // 班级1的学生信息
        Grades class1 = new Grades("class1", Arrays.asList(person, person1, person2, person3));
        // 班级2的学生信息
        Grades class2 = new Grades("class2", Arrays.asList(person4, person5, person6));
        // 班级3的学生信息
        Grades class3 = new Grades("class3", Arrays.asList(person7, person8, person9));
        classList.add(class1);
        classList.add(class2);
        classList.add(class3);

        // 需求:获取所有班级的学生信息,并打印输出
        classList.stream() // 获取流对象
                .flatMap(x->x.getPersonList().stream()) // 对Grades对象中的personList做扁平化处理
                .forEach(System.out::println); // 打印展示所有班级学生信息
    }
}

3.groupBy的用法示例

@Slf4j
public class GroupByStreamTest {
    public Person[] peoples;

    public List<Person> personList;

    public List<ActualByBudgetSubjectOrganization> actualByBudgetSubjectOrganizationList = new ArrayList<>();

    @Before
    public void before() {
        Person person = new Chinese("小明", 21, Sex.man);
        Person person1 = new Chinese("小红", 25, Sex.woman);
        Person person2 = new Chinese("小李", 23, Sex.man);
        Person person3 = new Chinese("小明", 20, Sex.man);
        Person person4 = new Chinese("小红", 18, Sex.woman);
        Person person5 = new Chinese("小李", 17, Sex.man);
        Person person6 = new Chinese("小麻", 50, Sex.man);

        ActualByBudgetSubjectOrganization actualByBudgetSubjectOrganization = null;
        for (int i =0; i<10; i++){
            // 生成0-100之间的随机数
            Random random = new Random();
            long amountMoney = random.nextLong() % 101; // 生成-100到100之间的随机数
            if (amountMoney < 0) {
                amountMoney = -amountMoney; // 将负数转化为正数
            }
            if(i<5){
                actualByBudgetSubjectOrganization=ActualByBudgetSubjectOrganization.builder()
                        .companyCode("10")
                        .operationNo("001")
                        .yearMonth("202210")
                        .budgetSubjectCode("PT101")
                        .amountMoney(amountMoney).build();
                this.actualByBudgetSubjectOrganizationList.add(actualByBudgetSubjectOrganization);
                continue;
            }
            actualByBudgetSubjectOrganization = ActualByBudgetSubjectOrganization.builder()
                    .companyCode("G0")
                    .operationNo("001")
                    .yearMonth("202210")
                    .budgetSubjectCode("PT102")
                    .amountMoney(amountMoney).build();
            this.actualByBudgetSubjectOrganizationList.add(actualByBudgetSubjectOrganization);
        }
        this.peoples =new Person[]{ person, person1, person2, person3, person4, person5, person6};
        this.personList = Arrays.asList(peoples);
    }

    // stream流的分组转换
    @Test
    public void groupByAgeTest() {
        Map<Integer, List<Person>> result = this.personList.stream().collect(Collectors.groupingBy(Person::getAge));
        Set<Integer> keys = result.keySet();
        for (Integer key : keys) {
            result.get(key).stream().forEach(System.out::println);
            System.out.println("================");
        }
    }

    @Test
    public void groupBySexTest() {
        Map<Sex, List<Person>> result = this.personList.stream().collect(Collectors.groupingBy(Person::getSex));
        Set<Sex> keys = result.keySet();
        for (Sex key : keys) {
            result.get(key).stream().forEach(System.out::println);
            System.out.println("================");
        }
    }


    // stream流的分组转换
    @Test
    public void groupByNameTest() {
        this.personList.stream()
                .collect(Collectors.groupingBy(Person::getName))
                .forEach((key, value) -> {
                    value.forEach(System.out::println);
                    System.out.println("================");
                });
    }

    // 先分组在求和
    @Test
    public void groupByAndSummingLongTest() {
        // 先分组在求和，注意Collectors.summingLong(ActualByBudgetSubjectOrganization::getAmountMoney是作为Collectors.groupingBy的一个参数
        Map<String, Long> collect = this.actualByBudgetSubjectOrganizationList.stream()
                .collect(Collectors.groupingBy(ActualByBudgetSubjectOrganization::getBudgetSubjectCode,
                        Collectors.summingLong(ActualByBudgetSubjectOrganization::getAmountMoney)));
        Set<String> keys = collect.keySet();
        keys.forEach(key-> log.info("key:{},value:{}",key, collect.get(key)));
    }

    // 请计算全班男生的平均年龄和全班女生的平均年龄。
    @Test
    public void groupByAndAveragingIntTest() {

        Map<Sex, Double> collect1 = this.personList.stream().distinct().collect(Collectors.groupingBy(Person::getSex, Collectors.averagingInt(Person::getAge)));
        collect1.forEach((sex, aLong) -> log.info("性别:{}, 年龄总和：{}", sex, aLong));
        boolean b = this.personList.stream().distinct().anyMatch(x -> x.getAge() > 9);
//        boolean b = this.personList.stream().distinct().max();
    }
}

4.peek用法示例


@Slf4j
public class PeekStreamTest {

    public Person[] peoples;

    public List<Person> personList;

    @Before
    public void before() {
        Person person = new Chinese("小明", 23, Sex.man);
        Person person1 = new Chinese("小红", 15, Sex.woman);
        Person person2 = new Chinese("小李", 58, Sex.man);
        Person person3 = new Chinese("小明", 62, Sex.man);
        Person person4 = new Chinese("小红", 11, Sex.woman);
        Person person5 = new Chinese("小李", 38, Sex.man);
        Person person6 = new Chinese("小麻", 20, Sex.man);

        this.peoples =new Person[]{ person, person1, person2, person3, person4, person5, person6};
        this.personList = Arrays.asList(peoples);
    }

    @Test
    public void peekTest01() {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        numbers.stream()
                .peek(number -> System.out.println("Processing number: " + number)) // 打印流的执行过程
                .filter(number -> number % 2 == 0)
                .forEach(System.out::println);
    }

    // 统一将Person对象中的某一属性修改成固定值
    @Test
    public void peekTest02() {
        //  统一将Person对象中的性别属性修改成男, 注意this.personList.stream().peek(x -> x.setSex(Sex.man))仍会返回一个stream流
        this.personList.stream().peek(x -> x.setSex(Sex.man)).forEach(System.out::println);
    }
}

3.first用法示例

  @Test
    public void firstTest() {
        // 获取年龄大于50岁，并取其第一个元素
        String firstElementValue = this.personList.stream()
                .filter(x -> x.getAge() > 50)
                .findFirst().map(Person::getName).orElseGet(() -> "");
        log.info("firstElementValue--->{}", firstElementValue);
    }

3.removeIf用法示例

public class RemoveIfStreamTest {
    public Person[] peoples;

    public List<Person> personList;

    @Before
    public void before() {
        Person person = new Chinese("小兰", 22, Sex.man);
        Person person1 = new Chinese("小赵", 24, Sex.woman);
        Person person2 = new Chinese("小白", 21, Sex.man);
        Person person3 = new Chinese("小黄", 21, Sex.man);
        Person person4 = new Chinese("小黑", 19, Sex.woman);
        Person person5 = new Chinese("小李", 18, Sex.man);
        Person person6 = new Chinese("小麻", 50, Sex.man);

        this.peoples =new Person[]{ person, person1, person2, person3, person4, person5, person6};
        this.personList = Arrays.asList(peoples);
    }

    @Test
    public void removeIfTest() {
        List<Person> personList = new ArrayList<>(this.personList);
        personList.add(null);
        personList.add(null);
        personList.add(null);
        personList.add(null);
        personList.removeAll(Collections.singletonList(null));
        //personList.removeIf(Objects::isNull);
        personList.removeIf(x -> x.getAge() > 30);
        personList.forEach(System.out::println);
    }
}

MidnightWhisper
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
java8stream源码-jroutine:随时随地进行并行编程
06-04
java8流源码JR例程 随时随地进行并行编程。 概述 受 Go 例程的启发，该库提供了一个强大、灵活且熟悉的并发框架，旨在使多线程编程变得简单有趣。 主要范式基于例程和通道。 例程是一段代码在其中异步执行的容器。 它负责同步并管理调用生命周期。 渠道是日常工作与外界沟通的手段。 可以以异步和并行方式调用例程。 异步调用和并行调用之间的主要区别在于，在前者中，所有输入数据都由同一个调用实例处理，而在后者中，每个输入项（可能）由不同的调用实例处理。 例如，如果例程必须计算输入的总和，则异步调用是可行的方法，而当例程用于计算例如数字的平方时，所有输入都可以是安全地并行处理。 调用后，例程返回一个用于传递输入参数的通道。 输入数据可以批量传递或流式传输、延迟或从另一个通道异步获取。 输入完成后，通道关闭。 相同的通道用于读取调用结果，甚至可能在调用完成之前发布。 定义例程的主要方式是实现一个调用对象。 不过，该库提供了几种其他方式（始终由调用支持）来异步调用任何对象（甚至在第三方源代码中定义）的任何方法。 它是React式的！ 图书馆遵守 . 它是响应式的、有弹性的、弹性的和消息驱动的。 它
java8源码-bridge:类似于Stream流，但操作单个元素的工具
06-04
java8 源码 作者：王亚奇 联系方式qq：1160782779 这是一个用来改变编码方式的工具，大量使用lambda和函数式，使代码分块编写，便于开发人员阅读；可以用来提高代码的可阅读型，可维护性； 工具开发的灵感来源：公司多人协同开发，代码不规范，相互维护代码简直就是灾难；作者使用过spring WebFlux开发过项目，特别喜欢里面的Flux与Mono流式操作编程，又因为java8有了Stream操作集合，在不使用WebFlux模块的情况下，操作单个元素的却没有，于是借鉴WebFlux的Mono自己开发了一套工具，目前工具API继续扩展中； 使用方式：pull下项目，打成jar包，引入工程即可 优点： ①使用lambda实现懒触发； ②通过以下操作符只是构建数据走过的桥梁，数据并不会真正的处理； ③使用操作符可以使代码分块，并且可以通过onError操作符来进行异常处理，使代码中再也不用处理运行时异常，便于阅读、维护； ④操作符易上手、操作简单、灵活高、自由组合，可以满足各种场景； ⑤桥梁节点操作符易扩展； API说明： 首先使用BridgeBuild.from工厂方法来构建桥
Java8新特性及实战视频教程完整版.txt
06-10
备注：“如果连接失效请联系UP” Java8是Java发布以来改动最大的一个版本，其中主要添加了函数式编程、Stream、一些日期处理类。 函数式编程中中新加了一些概念：Lambda表达式、函数式接口、函数引用、默认方法、Optional类等；Stream中提供了一些流式处理集合的方法，并提供了一些归约、划分等类的方法；日期中添加了ZoneDateTime、DataFormat等线程安全的方法类；
《Java 8 in Action》是一本关于 Java 编程语言的书籍，重点介绍了 Java 8 中引入的新特性和改进
最新发布
02-21
该书由 Mario Fusco、Alan Mycroft 和 Raoul-Gabriel Urma 合著，旨在帮助读者深入了解 Java 8，并掌握其中的关键概念和技术。 该书通常会涵盖以下内容： Lambda 表达式： 介绍 Java 8 中引入的 Lambda 表达式，以及如何使用 Lambda 表达式来简化代码和实现函数式编程风格。 Stream API： 介绍 Java 8 中引入的 Stream API，以及如何使用 Stream API 来处理集合数据和进行流式操作。 新的日期和时间 API： 探讨 Java 8 中新增的日期和时间 API，以及如何使用这些 API 来处理日期、时间和时区等相关操作。 并发编程改进： 讨论 Java 8 中对并发编程的改进，包括 CompletableFuture、新的并发工具和并发数据结构等。 其他新特性： 简要介绍 Java 8 中引入的其他新特性，如接口的默认方法、方法引用、Optional 类型等。
Stream流式编程
weixin_48302334的博客
07-05 165
在Java中，Stream 是一个用于操作集合元素的抽象概念。它提供了一种类似于流水线的方式来处理和操作数据。使用 Stream，你可以通过一系列的中间操作和最终操作来对集合进行转换、过滤、映射等操作，从而以一种简洁、函数式的方式处理数据。
Java流式编程详解
CodePanda@GPF的博客
04-07 1万+
Java流式编程、Stream
流式编程
m0_46363470的博客
11-14 2832
一、Stream流 在Java 8中得益于lambda所带来的函数是编程，便引入了全新的Stream概念，用于解决集合类库中已有的弊端。 1.1引言 循环的弊端： Java 8的lambda让我们可以更加专注于做什么而不是怎么做 -for循环的语法就是怎么做 -for循环的循环体就是做什么 为什么使用循环？因为要进行遍历。 但是循环是遍历的唯一方式吗？ 遍历是指每一个元素逐一进行处理，而并不是从第一个到最后一个顺次处理的循环，前者是目的，后者是方式。 如果希望通过对集合中的元素进行筛选过滤： 1.将集合A根
Stream流式编程详解
muranchenhui的博客
05-21 3949
Stream流式编程详解 一、 什么是 Stream Stream 中文称为 “流”，通过将集合转换为这么一种叫做 “流” 的元素序列，通过声明性方式，能够对集合中的每个元素进行一系列并行或串行的流水线操作。 换句话说，你只需要告诉流你的要求，流便会在背后自行根据要求对元素进行处理，而你只需要 “坐享其成”。 二、流操作 整个流操作就是一条流水线，将元素放在流水线上一个个地进行处理。 其中数据源便是原始集合，然后将如 List 的集合转换为 Stream 类型的流，并对流进行一系列的中间操作，比如过滤保留部
Java8流式编程
骑个小蜗牛的博客
02-01 2万+
Java8流式编程：Stream创建、Stream中间操作、Stream终止操作
Stream流式编程详解，让代码变得更优雅
kkwyting的博客
10-04 372
Stream流式编程详解，让代码变得更优雅
19年全新JDK8~JDK13全套新特性视频教程java教程lambda函数式编程
06-16
2)lambda表达式、四大函数式接口、自定义函数式编程、集合框架Stream流式处理、Collector聚合统计 3)JDK8新特性综合实战之电商订单数据处理等知识点； 4)玩转JDK9/10/11/12/13 涵盖新特性 Jshell实战、接口私有方法...
Java Stream流式编程
热门推荐
ThinkStu的博客
08-09 5万+
Java Stream 从 JDK8 开始引入，支持链式书写。
stream流式编程
weixin_46113450的博客
03-20 518
文章目录stream api 流式编程常用的stream三种创建方式Stream的终止操作Collectors 具体方法常用方法filtermapgroupBy求和交集,并集,差集flatMappeekdistinctlimitsortedmatch匹配find寻找元素计数和极值 stream api 流式编程 常用的stream三种创建方式 集合 Collection.stream() 静态方法 Stream of 数组 Arrays.stream //1.集合 Stream<Stu
java中的一些骚操作（日后会经常更新）
youshang520i
04-01 1121
1. StringUtils 1.逗号切割 for (Agentband agentband : agentbands) { String str = agentband.getListIds(); if ("" != str && null != str) { ...
每日一课 | Java 8 Stream List 获取最后一个元素
sinat_32849897的博客
11-20 1万+
在Java 8中，我们可以使用reduce或skip获取Stream的最后一个元素。1. Stream.reduceJava8Example1.javapackage com.mkyon...
Stream流--获取流对象
czw的博客
12-21 3597
获取流对象 java.util.stream.Stream 是JDK 1.8引入的新特性，较为常用的接口（本身并不是函数式接口） 获取一个流对象，有以下常用的操作： - 所有的Collection集合都可以通过stream()默认方法来获取 - Stream 接口里面含有一个静态方法of 也可以获取对应的流对象 根据Collection集合或者of方法获取对象 只要是Collection集合的实现类或者子类接口都可以调用stream默认方法获取流对象 代码如下： public static void m
13、流式编程
抛砖引玉
04-22 1093
十四、流式编程 利用流，无需迭代集合中的元素，就可以提取和操作它们。组合在一起，在流上形成一条操作管道。 　lambda表达式、方法引用、流式编程结合使用。 　声明式编程（Declarative programming）是一种：声明要做什么，而非怎么做的编程风格。正如我们在函数式编程中所看到的。 　流式编程采用内部迭代，这是流式编程的核心特性之一。这种机制使得编写的代码可读性更强，也更能利用多核处...
Java 流式编程
Eden Garden
05-17 3350
1. 什么是流式编程 流式编程通常是对集合处理，让集合中的对象像水流一样流动，分别进行去重、过滤、映射等操作，就和批量化生产线一样。利用流，我们无需迭代集合中的元素，就可以提取和操作它们，这些操作通常被组合在一起，在流上形成一条操作管道。 流式编程的优点：编程的逻辑分明，按照顺序依次执行，同时代码短小。 2. 流式编程步骤 创建流： //将数组转换成流，可以产生基本数据类型的流， //如IntStream、FloatStream、DoubleStream等，运行效率比较高
14.流式编程
EdSheeran的博客
10-20 472
文章目录*流式编程**14.1流支持**14.2流创建**14.2.1随机数流**14.2.2`int`类型的范围**14.2.3`generate()`**14.2.4`iterate()`**14.2.5流的建造者模式**14.2.6`Arrays`**14.3中间操作**14.3.1跟踪和调试**14.3.2流元素排序**14.3.3移除元素**14.3.4应用函数到元素**14.3.5在`map()`中组合流**14.4`Optional`类**14.4.1便利函数**14.4.2创建`Option
java stream流式编程
10-22
Java Stream流式编程是一种函数式编程风格的集合操作方法，它可以让我们以一种更简洁、更易读的方式对集合进行操作。Stream流分为两种类型：流(Stream)和并行流(ParallelStream)。流表示顺序流，按照数据源的顺序进行操作，适用于串行操作；而并行流可以同时对数据源的多个元素进行操作，适用于并行计算。Stream流提供了一系列的操作方法，如filter、map、flatMap、distinct、sorted、limit、skip、peek等，这些方法可以在流上执行，并发地处理数据。并行流会自动将数据分成多个部分，并在多个线程上同时进行处理，加快了处理速度。相比于传统的迭代器或循环遍历集合元素的方式，Stream流式编程更加简洁、易读、易于维护和并行化处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值