Java8新特性之Stream基础操作

最新推荐文章于 2022-09-09 20:13:19 发布
最新推荐文章于 2022-09-09 20:13:19 发布
阅读量216 收藏
点赞数
分类专栏： Java基础 文章标签： java stream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DQ1521166966/article/details/106597877
版权

Java8 Stream基础API

使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询，Stream API提供了一种高效且易于使用的处理数据的方式。
1、Stream是什么？
是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。集合讲的是数据，Stream讲的是计算。
“注意”
（1） Stream自己不会存储元素。
（2） Stream不会改变源对象。相反，它会返回一个持有结果的新Stream。
（3） Stream操作是延迟执行的，这意味着它会等到需要结果时才执行。
2、Stream操作步骤
（1）创建Stream
一个数据源（如：集合，数组），获取一个流
（2）中间操作
一个中间操作链，对数据源的数据进行处理。例：过滤，映射等
（4）终止操作
一旦执行终止操作，就执行中间操作链，并产生结果，之后，不再被使用。

在这里插入图片描述
3、stream实例化4种方式

package stream;
import bean.Person;
import org.junit.Test;

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

public class TestDay1 {   
    //创建stream方式一：通过集合
    @Test
    public void test1(){
        List<Person> list = Person.getPersonList();

        //default Stream<E> stream()：返回一个顺序流
        Stream<Person> stream = list.stream();

        //default Stream<E> parallelStream() 返回一个并行流
        Stream<Person> parallelStream =  list.parallelStream();
    }

    //创建stream方式二：通过数组
    @Test
    public void test2(){
        int[] arr = new  int[]{1,2,3};
        IntStream  intStream =  Arrays.stream(arr);

        //对象数组返回对象类型stream
        Person p1 = new Person("jim",11);
        Person p2 = new Person("angel",12);
        Person[] arr2 = new Person[]{p1,p2};
        Stream<Person> parallelStream =  Arrays.stream(arr2);
    }

    //创建stream方式三：通过stream的of()方法
    @Test
    public void test3(){
       Stream<Integer>  stream  = Stream.of(1,2,3,4,5);
    }

    //创建stream方式四：创建无限流，造数据用，一般不用
    @Test
    public void test4(){
        //迭代
        // public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        //遍历输出前十个偶数  limit中间操作，forEach 终止操作
        Stream.iterate(0,t->t+2).limit(10).forEach(System.out::println);

        //生成
        //public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }
}

4、Stream的中间操作
（1）筛选与切片（filter，limit，skip，distinct）
（2）映射 (map)
（3）排序(sored)
(4) 并行流（parallel），节约时间

package stream;

import bean.Person;
import org.junit.Test;

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

public class TestMid {

    //stream的中间操作一、筛选与切片
    @Test
    public void test1(){

        List<Person> list = Person.getPersonList();

        //default Stream<E> stream()：返回一个顺序流
         Stream<Person> stream = list.stream();
         //集合中年龄大于12岁的
         stream.filter(p->p.getAge()>12).forEach(System.out::println);
         System.out.println("#######################");

         //limit(n)截断流，不超过给定长度n
         list.stream().limit(3).forEach(System.out::println);
         System.out.println("#######################");

         //skip(n)跳出元素，跳过前n个,若集合中不足,返回空流 与limit互补
        list.stream().skip(13).forEach(System.out::println);
        System.out.println("#######################");

        //distinct（）--筛选，通过流所生成元素的hashCode()和equals去除重复元素
        list.add(new Person("Tom",22));
        list.add(new Person("Tom",22));
        list.add(new Person("Tom",23));
        list.stream().distinct().forEach(System.out::println);
    }

    //stream的中间操作二、映射
    @Test
    public void test2(){
        List<String> list = Arrays.asList("aaa","bbb","ccc");
        //map（Function f）接收一个函数作为参数，将元素转换成其他形式或者提取信息，
        // 该函数会被应用到每个元素上，并将其映射成一个新元素
        list.stream().map(str->str.toUpperCase()).forEach(System.out::println);
        System.out.println("#######################");

        //练习
        List<Person> personList = Person.getPersonList();
        Stream<String> stringStream = personList.stream().map(Person::getName);
        stringStream.filter(name->name.length()>3).forEach(System.out::println);

        //flatMap(Function f)将流中的每个值都换成另外一个流，然后把所有的流连接成一个流
       //1.用map相当于list1.add(list2);
        Stream<Stream<Character>> streamStream = list.stream().map(TestMid::StringToStream);
        streamStream.forEach(s->{
            s.forEach(System.out::println);
        });
        System.out.println("#######################");
        //2.用flatMap当于list1.addAll(list2)
        Stream<Character> characterStream = list.stream().flatMap(TestMid::StringToStream);
        characterStream.forEach(System.out::println);
    }

    //将字符串中的多个字符构成的集合转化为对应的stream的实例
    public static Stream<Character> StringToStream(String str){
        ArrayList<Character> arrayList = new ArrayList<>();
        for(Character c:str.toCharArray()){
            arrayList.add(c);
        }
        return arrayList.stream();
    }
    //简单举例类比
    @Test
    public void test3(){
        List list1 = new ArrayList();
        list1.add(1);
        list1.add(2);
        list1.add(3);

        List list2 = new ArrayList();
        list2.add(4);
        list2.add(5);
        list2.add(6);

        //输出4个元素
       // list1.add(list2);
        //System.out.println(list1);
        //输出6个元素
        list1.addAll(list2);
        System.out.println(list1);
    }

    //stream的中间操作三、排序
    @Test
    public void test4() {
        //1、sored（）自然排序
        List<Integer> list = Arrays.asList(5, 1, -1, 23, 3, 20);
        list.stream().sorted().forEach(System.out::println);
        System.out.println("#######################");

        //2、sored（comparator com）定制排序
        List<Person> list1 = Person.getPersonList();
        list1.stream().sorted((p1, p2) -> Integer.compare(p1.getAge(), p2.getAge())).
                forEach(System.out::println);

    }

}

5、Stream的终止操作
（1）匹配与查找（forEach，min，max，count）
（2）规约 (reduce)
（3）收集collect(Collectors c) 将流转化为其他形式，
接收一个Collectors接口实现,用于给Stream中元素做汇总的方法。例如：（set，List）

package stream;

import bean.Person;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class OverTest {

    //1、匹配与查找
    @Test
    public void test1(){
        //（1）allMatch(Predicate p)检查是否匹配所有元素
        List<Person> p1 = Person.getPersonList();
        boolean b1 = p1.stream().allMatch(p -> p.getAge() > 10);
        System.out.println(b1);
        System.out.println("#######################");

        //（2）anyMatch(Predicate p)检查是否匹配任一元素
        List<Person> p2 = Person.getPersonList();
        boolean b2 = p2.stream().anyMatch(p -> p.getAge() > 20);
        System.out.println(b2);
        System.out.println("#######################");

        //（3）findFirst返回第一个元素
        List<Person> p3 = Person.getPersonList();
        Optional<Person> first = p3.stream().findFirst();
        System.out.println(first);
        System.out.println("#######################");

        //(4)count（）返回流中元素的总个数
        List<Person> p4 = Person.getPersonList();
        long count = p4.stream().filter(p -> p.getAge() > 12).count();
        System.out.println(count);
        System.out.println("#######################");

        //(5)max（Comparator c）返回流中的最大值
        List<Person> p5= Person.getPersonList();
        Stream<Integer> stream = p5.stream().map(p -> p.getAge());
        Optional<Integer> max = stream.max(Integer::compareTo);
        System.out.println(max);
        System.out.println("#######################");

        //(6)min（Comparator c）返回流中的最小值
        List<Person> p6= Person.getPersonList();
        Optional<Person> min = p6.stream().min((a, b) -> Integer.compare(a.getAge(), b.getAge()));
        System.out.println(min);
        System.out.println("#######################");

        //(7)forEach(Consumer c)内部迭代器
        List<Person> p7= Person.getPersonList();
        p7.stream().forEach(System.out::println);
        System.out.println("#######################");

        //集合里面的遍历操作
        p7.forEach(System.out::println);
    }

    //2、规约
    @Test
    public void test2() {

        //（1）reduce(T identity, BinaryOperator<T> accumulator)可以将流中元素反复结合起来，得到一个值返回
        //求和1-5
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        Integer reduce = list.stream().reduce(0, Integer::sum);   //第一个参数为初始值
        System.out.println(reduce);
        System.out.println("#######################");


        //2.Optional<T> reduce(BinaryOperator<T> accumulator)求和,返回Optional<T>
        //求和年龄
        List<Person> p1 = Person.getPersonList();
       // Optional<Integer> reduce1 = p1.stream().map(Person::getAge).reduce(Integer::sum);
        Optional<Integer> reduce1 = p1.stream().map(Person::getAge).reduce((a,b)->a+b);
        System.out.println(reduce1);
        System.out.println("#######################");
    }
    //3、收集collect(Collectors c) 将流转化为其他形式，
    // 接收一个Collectors接口实现,用于给Stream中元素做汇总的方法 例如：（set，List）
    @Test
    public void test3() {

        //1.输出List
        List<Person> p1 = Person.getPersonList();
        List<Person> personList = p1.stream().filter(a -> a.getAge() > 20).collect(Collectors.toList());
        personList.forEach(System.out::println);
        System.out.println("#######################");

        //2.输出set
        Set<Person> personSet = p1.stream().filter(a -> a.getAge() > 20).collect(Collectors.toSet());
        personSet.forEach(System.out::println);
        System.out.println("#######################");

    }
}

用到的Person类

package bean;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class Person {
    private String name;
    private Integer  age;

    public String getName() {
        return name;
    }

    public Integer getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Person() {
        System.out.println("Person()......");
    }

    public Person(Integer age) {
        this.age = age;
        System.out.println("Person(Integer age)......"+age);
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(name, person.name) &&
                Objects.equals(age, person.age);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    public static List<Person> getPersonList(){
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("张三力",12));
        personList.add(new Person("李四狗",11));
        personList.add(new Person("王五蛋",13));
        personList.add(new Person("Tom",22));
        personList.add(new Person("Jerry",21));
        personList.add(new Person("Mary",23));
        return personList;
    }
}

Stream简单基础和实现到此结束，具体详细方法和操作可查看相关API添加链接描述。

年少一梦
关注
专栏目录
【项目实训】Bean拷贝工具类
par_ser的博客
05-14 630
我们知道在MVC开发过程中，各个层之间往往有不同的对象在函数调用中传递，而这些对象虽然类型不同，但往往是有很多相同的属性，典型的比如数据库能查到很多数据，但在服务层我们需要用的只是其中一部分，或者我们希望给用户展示/暴露的只是一部分，那么在这种场景下，我们就需要bean拷贝工具类（当然你也可以直接写get,set，这样性能也很好，但却给开发与维护带来了许多不便）。 主流的bean拷贝实现大致有Apache BeanUtils ，SpringBeanUtils，cglibBeanCopier，Huto...
java8新特性之Stream流操作
l_l_jh的博客
04-22 1498
Stream流操作是java8的最重要的新特性之一，功能强大,非常常用。可以说每个java coder必须掌握，这次把理论放在最后面，因为你可能不需要知道的多么详细，只是需要看看某个功能，可能听名字就大概知道它是做什么的。 举个简单例子，现在给了你同学信息和成绩，你需要统计班级平均分 // 以前可能的做法 public static avgScore(List<Student> stus){ int sum=0; for (Student student : stus) {
Java8新特性Stream流
我不是李大侠
10-23 2327
什么是Stream流？ Stream流是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。 Stream的优点：声明性，可复合，可并行。这三个特性使得stream操作更简洁，更灵活，更高效。 Stream的操作有两个特点：可以多个操作链接起来运行，内部迭代。 Stream可分为并行流与串行流，Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间
Java8新特性 - Stream - 05 - Stream的filter()方法详解
northcastle的博客
03-12 8533
1.方法介绍 【方法签名】Stream<T> filter(Predicate<? super T> predicate); 【方法属性】非终结方法 【方法参数】函数式接口 Predicate , 因此可以直接传入一个Lambda表达式 【方法作用】过滤stream中的元素，返回符合条件的元素到一个新的stream中 【方法返回值】 Stream<T> 一个新的Stream对象，可以继续支持链式调用 2.案例代码 2.1 代码 package com.north
[个人翻译] JDK11 API- Package Stream- 部分中文版
Ella4的博客
06-23 1428
Stream API的个人翻译~
Java8的 Stream 流学习与使用总结
weixin_43927773的博客
09-02 681
1. Stream 流介绍 Stream的原理：将要处理的元素看做一种流，流在管道中传输，并且可以在管道的节点上处理，包括过滤筛选、去重、排序、聚合等。元素流在管道中经过中间操作的处理，最后由最终操作得到前面处理的结果。 Stream 流的使用总是按照一定的步骤进行，可以抽象出下面的使用流程。 数据源 -> 数据处理/转换-> 结果处理 1.1. 数据源 数据源也就是数据的来源，可以通过多种方式获得 Stream 数据源，下面列举几种常见的获取方式。 • Collection.stream();
Java8新特性之方法引用&Stream流应用实例md，学习代码
最新发布
06-21
Java 8是Java语言的一个重要版本，引入了许多新特性，极大地提升了开发效率和代码的可读性。在本文中，我们将重点关注两个关键特性：方法引用和Stream流，并结合实际应用实例进行深入探讨。 首先，我们来看一下方法...
夯实基础，Java8新特性Stream详细教程
zhaohuodian的博客
09-09 761
Java8的API中添加了一个新的特性： 流，即stream。stream是将数组或者集合的元素视为流，流在管道中流动过程中，对数据进行筛选、排序和其他操作。
679.677.JAVA基础教程_动态代理与Java8新特性-Stream的中间操作：筛选(679).rar
11-09
本教程聚焦于Java的基础部分，特别是Java动态代理和Java 8的新特性——Stream API，尤其是Stream的中间操作——筛选。 动态代理是Java提供的一种机制，允许我们在运行时创建具有特定接口的代理类实例。这主要通过...
680.678.JAVA基础教程_动态代理与Java8新特性-Stream的中间操作：映射(680).rar
11-09
在Java编程语言中，动态代理和Java 8的新特性，如Stream API，是现代Java开发中的重要组成部分。本文将深入探讨这两个主题，并特别关注Stream API的中间操作——映射（Map）。 首先，让我们理解什么是动态代理。在...
streamjs用流的方式来对数组对象进行系列操作
08-10
streamjs 用流的方式来对数组，对象进行系列操作
list.sort和list.stream.sorted
iloki的博客
09-01 2700
问题描述 最近写接口的时候，查完数据顺手排序了一下，结果列表数据始终是乱序的，查了好久都没看出问题，最后才发现是自己写list.sort写习惯了，把list.stream.sorted也当成list.sort使用了。 知识盘点 一、list.sort 用法 templateObjs.sort( Comparator.comparing(AnalysisTemplateObj::getGroupKey, Comparator.nullsFirst
Stream流处理数据（集合，数组，I/O）
Mr_muu的博客
10-16 1134
/* * java高级特性 Stream流式处理集合（把一个数据集中的元素并行聚合处理的操作） * * stream（elements元素）--->filter（过滤spit）--->sorted(排序)---map()--->collect() *elements：流的来源：集合list set map 数组，内存（I/O通道） *steam的使用，就是实现了fitel-map-reduce的过程。 */ import java.util.*; import ...
TestDataStream的用法
Sui_Phoebe的博客
04-06 451
package com.ylkj0401; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException;
Java 8 中使用 Stream 方式处理数据
mingyuli的博客
01-20 2161
目录 一、什么是 Stream 二、Stream 操作分类 三、Stream 特性 四、数据转换为 Stream 五、Stream 转换得到指定类型数据 六、Stream 对于基本类型的封装 七、Stream 的串行与并行 1、Stream 的并行介绍 2、Stream 并行示例 八、Stream 中间操作（有状态）常用 API 1、distinct 2、sorted 3、skip 4、limit 九、Stream 中间操作（无状态）常用 API 1、map 2、pe.
java8Stream操作集合进行排序和过滤
YoungLee16的博客
09-13 1万+
//对listResult进行排序,根据伴随度进行降序 List&lt;FollowIMSI&gt; collect = listResult.stream() .sorted(Comparator.comparing(FollowIMSI::getFollowDegree).reversed()) .collect(Collectors.toList()); ...
stream流（三）
qq_38777614的博客
06-06 218
Stream流的操作 1.什么是Stream 它是一个数据渠道，用于操作数据源(集合，数组等)所生成的元素序列，集合讲的是数据，Stream讲的是计算！使用Stream API对集合数据进行操作，就类似使用SQL执行的数据库查询！ 2.为什么要使用Stream API 实际开发中，项目中多数数据源来自Mysql,Oracel关系型数据库，但现在 还有来自Nosql的数据：如MongoDB,Redis，而这些NoSQL的数据就需要 java层面去处理 3.Stream的操作三个步骤 1.创建Stre
Java8排序stream.sorted()
热门推荐
延陵缥缈的博客
07-03 11万+
在这个页面上我们将提供java 8 Stream sorted（）示例。我们可以按照自然排序以及Comparator提供的排序对流进行排序。在java 8中Comparator可以使用lambda表达式进行实例化。我们还可以反转自然排序以及提供的排序Comparator。自然排序使用提供的顺序Comparable，必须由其实例是流元素的类实现。在这个页面上我们将排序List，Map并...
JDK8新特性 - Stream API及Optional类
江南烟雨却痴缠丶
04-29 758
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。 Stream是什么 它是数据渠道，用于操作数据源（集...
Java8新特性：Lambda表达式与StreamAPI详解
以下重点介绍Java8中的两大核心新特性：Lambda表达式和Stream API。 Lambda表达式 Lambda表达式是Java8的一大亮点，它引入了匿名函数的概念，使得代码更加简洁易读。Lambda允许我们将函数作为方法参数传递，或者将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值