Java8新特性之Stream流

最新推荐文章于 2023-08-24 15:30:32 发布
最新推荐文章于 2023-08-24 15:30:32 发布
阅读量98 收藏
点赞数
分类专栏： Java基础知识 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CCQDDQ/article/details/120298447
版权 
package StreamT;

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

/**
 * @className: Test01
 * @description: Stream流初尝试
 * @author: CCQ
 * @date: 2021/9/12
 **/

public class Test01 {
    public static void main(String[] args) {
        ArrayList<String> s1 = new ArrayList<>();
        s1.add("林青霞");
        s1.add("棋棋");
        s1.add("风清扬");
        s1.add("张敏");
        s1.add("张曼玉");
        s1.add("张无忌");
        s1.add("刘岩");

        //找出集合中每个字符串首个字符为张的元素，并从这些元素中找出长度等于3的元素，然后将最终的结果打印
        s1.stream().filter(s -> s.startsWith("张")).filter(s -> s.length()==3).forEach(System.out::println);

    }
}


package StreamT;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.stream.Stream;

/**
 * @className: Test02
 * @description: Stream流常见的生成方式
 * @author: CCQ
 * @date: 2021/9/12
 **/


/*
* Stream流常见的生成方式
*   1.Collection体系的集合可以使用默认方法stream()生成流
*       default Stream<E> stream();
*   2.Map体系的集合可以间接的生成流，如利用set集合生成流(以下会有例子)
*   3.数组可以通过Stream接口的静态方法of(T... values)生成流
*
* */
public class Test02 {
    public static void main(String[] args) {
        //Collection体系集合生成流
        Stream<String> stream = new ArrayList<String>().stream();
        Stream<String> stream1 = new HashSet<String>().stream();

        //Map体系生成流
        Stream<Map.Entry<String, String>> stream2 = new HashMap<String, String>().entrySet().stream();
        Stream<String> stream3 = new HashMap<String, String>().keySet().stream();
        Stream<String> stream4 = new HashMap<String, String>().values().stream();

        //数组通过Stream接口的静态方法of(T...values)生成流
        String[] s1 ={"hello","java","i love you"};
        Stream<String> s11 = Stream.of(s1);
        Stream<String> hello = Stream.of("hello", "java");
        Stream<Integer> integerStream = Stream.of(10, 20, 30);

    }
}


package StreamT;

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

/**
 * @className: Test03
 * @description: Stream流常见中间操作之filter
 * @author: CCQ
 * @date: 2021/9/12
 **/

/*
*   Stream<T> filter(Predicate predicate)用于对流中的数据进行过滤
*   Predicate接口中的方法boolean test(T t),对给定的参数作判断，返回一个布尔值
*
* */
public class Test03 {
    public static void main(String[] args) {
        //创建一个集合
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("林青霞");
        arrayList.add("棋棋");
        arrayList.add("王祖贤");
        arrayList.add("刘岩");
        arrayList.add("张无忌");
        arrayList.add("张曼玉");

        //需求一：输出ArrayList集合中以张开头的元素
        arrayList.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
        System.out.println("----------------------");
        //需求二：输出ArrayList集合中长度为3的元素
        arrayList.stream().filter(s -> s.length()==3).forEach(System.out::println);
        System.out.println("----------------------");

        //需求三：输出ArrayList集合中以张开头长度为3的元素
        //第一种方式
        arrayList.stream().filter(s -> s.startsWith("张")).filter(s -> s.length()==3).forEach(System.out::println);
        System.out.println("----------------------");
        //第二种方式
        arrayList.stream().filter(s -> s.startsWith("张") && s.length()==3).forEach(System.out::println);


    }

}


package StreamT;

import java.util.ArrayList;

/**
 * @className: limitskipTest
 * @description: Stream流中间操作之limit&skip(截取和跳跃)
 * @author: CCQ
 * @date: 2021/9/13
 **/

/*
* Stream<T> limit(long maxSize)返回此流中的元素组成的流，截取指定参数个数的数据
* Stream<T> skip(long n)，跳过指定参数个数的数据，返回由该流的剩余元素组成的流
*
* */

public class limitskipTest {
    public static void main(String[] args) {
        ArrayList<Object> a1 = new ArrayList<>();
        a1.add("林青霞");
        a1.add("林青霞");
        a1.add("棋棋");
        a1.add("王祖贤");
        a1.add("刘岩");
        a1.add("张无忌");
        a1.add("张曼玉");

        //需求1：取前三个元素并打印,这里的distinct是去重
        a1.stream().distinct().limit(3).forEach(System.out::println);
        System.out.println("----------------------------");

        //需求2：跳过3个元素并打印剩余元素
        a1.stream().distinct().skip(3).forEach(System.out::println);
        System.out.println("----------------------------");

        //需求3：跳过2个元素，把剩下元素的前两个在控制台输出
        a1.stream().distinct().skip(2).limit(2).forEach(System.out::println);
        System.out.println("----------------------------");

    }
}


package StreamT;

import java.util.ArrayList;
import java.util.Comparator;

/**
 * @className: sortedTest
 * @description: Stream流之sorted (排序)
 * @author: CCQ
 * @date: 2021/9/13
 **/


/*
* Stream<T> sorted();返回由此流的元素组成的流，根据自然顺序排序
* Stream<T> sorted(Comparator comparator)返回由该流的元素组成的流，根据提供的Comparator进行排序
*       Comparator接口中的方法  int compara(T o1,T o2)
*
* */
public class sortedTest {
    public static void main(String[] args) {
        ArrayList<String> a1 = new ArrayList<>();
        a1.add("林青霞");
        a1.add("林青霞");
        a1.add("王祖贤");
        a1.add("刘岩");
        a1.add("棋棋");
        a1.add("张无忌");
        a1.add("张曼玉");

        //需求1：根据自然排序并打印数据
        a1.stream().sorted().forEach(System.out::println);

        System.out.println("---------------------");
        //需求2：根据字符串长度排序然后打印
        //第一种方式
        a1.stream().sorted((s1,s2) -> s1.length()-s2.length()).forEach(System.out::println);

        System.out.println("---------------------");
        //第二种方式
        a1.stream().sorted((s1,s2)->{
            int num =s1.length()-s2.length();
            int num2 =num==0?s1.compareTo(s2):num;
            return num2;
        }).forEach(System.out::println);

    }
}


package StreamT;

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

/**
 * @className: concatdistinctTest
 * @description: Stream流中间操作之concat&distinct（去重）
 * @author: CCQ
 * @date: 2021/9/13
 **/


/*
* static <T> Stream<T> concat(Stream a,Stream b)合并a和b两个流为一个流
* Stream<T> distinct();去重
* */
public class concatdistinctTest {
    public static void main(String[] args) {
        ArrayList<String> a1 = new ArrayList<>();
        a1.add("林青霞");
        a1.add("林青霞");
        a1.add("棋棋");
        a1.add("王祖贤");
        a1.add("刘岩");
        a1.add("张无忌");
        a1.add("张曼玉");

        //需求1：取前四个数据组成一个流
        Stream<String> limit = a1.stream().limit(4);

        //需求2：跳过两个数据组成一个流
        Stream<String> skip = a1.stream().skip(2);

        //需求3：合并需求1和需求2得到的流并打印
        Stream.concat(limit,skip).forEach(System.out::println);
        System.out.println("------------------------------------------");

        //需求4：合并需求1和需求2得到的流并去重打印
        Stream.concat(skip,limit).distinct().forEach(System.out::println);

    }
}



package StreamT;

import java.util.ArrayList;

/**
 * @className: foreachcountTest
 * @description: Stream流终结操作之foreach&count
 * @author: CCQ
 * @date: 2021/9/14
 **/

/*
    void forEach(Consumer action);对此流的每个元素执行操作
            Consumer接口中的方法  void accept(T t);对给定的参数执行此操作
    Long count();返回此流中的元素个数
*/

public class foreachcountTest {
    public static void main(String[] args) {
        ArrayList<String> a1 = new ArrayList<>();
        a1.add("林青霞");
        a1.add("林青霞");
        a1.add("王祖贤");
        a1.add("刘岩");
        a1.add("棋棋");
        a1.add("张无忌");
        a1.add("张曼玉");

        //需求1：打印集合元素
        a1.stream().forEach(System.out::println);
        System.out.println("---------");
        //统计以张开头的元素，并把结果输出
        long num = a1.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(num);
    }
}


package StreamT;

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

/**
 * @className: mapmapTointTest
 * @description: Stream流之map，maptoint
 * @author: CCQ
 * @date: 2021/9/14
 **/

/*
* <R> Stream<R> map(Function mapper);返回由给定函数应用于此流的元素的结果组成的流
* Function接口中的方法 R apply(T t)
*
* IntStream mapToInt(TointFunction mapper),返回一个IntStream流其中包含将给定函数应用于此流的元素的结果
*       IntStream：表示原始int流
*          其中IntStream流中有一个常用的方法，Stream流是没有的，需要转换为IntStream流
*          就是int num()方法，可以返回流中元素的总和
*
*       ToIntFunction接口中的方法  int applyAsInt(T value)
*/

public class mapmapTointTest {
    public static void main(String[] args) {
        ArrayList<String> a1 = new ArrayList<>();
        a1.add("300");
        a1.add("100");
        a1.add("20");
        a1.add("50");
        a1.add("45");
        a1.add("457");

        //需求1：将集合中的字符串数据转换为整数之后在控制台输出
        a1.stream().map(Integer::parseInt).forEach(System.out::println);

        System.out.println("----------------");

        int sum = a1.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(sum);
    }
}


	package StreamT;

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

/**
 * @className: StreamBigTest
 * @description: Stream流综合练习
 * @author: CCQ
 * @date: 2021/9/14
 **/

/*
    有两个集合分别存储男演员和女演员，现要求
        1.男演员只要名字为3个字的前三人
        2.女演员只要姓林的，并且不要第一个
        3.把过滤后的男女演员合并在一起
        4.把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据
*/
public class StreamBigTest {
    public static void main(String[] args) {
        ArrayList<String> a1 = new ArrayList<>();
        a1.add("林青霞");
        a1.add("王祖贤");
        a1.add("刘岩");
        a1.add("棋棋");
        a1.add("张无忌");
        a1.add("张曼玉");

        ArrayList<String> a2= new ArrayList<>();
        a2.add("棋1");
        a2.add("林青霞");
        a2.add("林夕");
        a2.add("林小姐");
        a2.add("棋4");
        a2.add("棋5");
        a2.add("棋6");
        a2.add("棋7");

        Stream<String> maleStream = a1.stream().filter(s -> s.length() == 3);
        Stream<String> femaleStream= a2.stream().filter(s -> s.startsWith("林")).skip(1);

        Stream<String> concat = Stream.concat(maleStream, femaleStream);
        concat.map(actor::new).forEach(s-> System.out.println(s.getName()));
        System.out.println("-----------");

        Stream.concat(a1.stream().filter(s -> s.length()==3),a2.stream().filter(s -> s.startsWith("林")).skip(1)).map(actor::new).forEach(s-> System.out.println(s.getName()));

    }
}

class actor{
    private String name;

    public actor(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

package StreamT;

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

/**
 * @className: CollectDemo
 * @description: Stream流之Collection操作 (把流中的数据收集到集合中)
 * @author: CCQ
 * @date: 2021/9/14
 **/


/*
    Stream流的收集方法
     R collect(Collector collector);
    但是这个收集方法的参数是一个Collector接口

    工具类Collectors提供了具体的收集方式
    public static <T> Collector toList():把元素收集到List集合中
    public static <T> Collector toSet():把元素收集到Set集合中
    public static Collector toMap(Function keyMapper,Function valueMapper):把元素收集到Map集合中

*/
public class CollectDemo {
    public static void main(String[] args) {
        ArrayList<String> a1 = new ArrayList<>();
        a1.add("林青霞");
        a1.add("王祖贤");
        a1.add("刘岩");
        a1.add("棋棋");
        a1.add("张无忌");
        a1.add("张曼玉");

        //需求1：得到名字为3个字的流，并把流中的数据收集到List集合中遍历
        Stream<String> stringStream = a1.stream().filter(s -> s.length() == 3);
        List<String> collect = stringStream.collect(Collectors.toList());
        for (String value : collect)
            System.out.println(value);

        HashSet<Integer> h1 = new HashSet<>();
        h1.add(10);
        h1.add(20);
        h1.add(30);
        h1.add(25);
        h1.add(22);
        h1.add(21);

        System.out.println("--------------------");
        //需求2：得到set集合中年龄大于等于25的流，并把流中的数据收集到Set集合中并遍历
        Set<Integer> collect1 = h1.stream().filter(s -> s >= 25).collect(Collectors.toSet());
        for (Integer a : collect1) {
            System.out.println(a);
        }

        System.out.println("--------------------");

        String[] arr ={"林青霞,25","王祖贤,30","刘岩,50","棋棋,21","张无忌,85","张曼玉,23"};
        //需求3：得到字符串数组中姓名长度为3年龄大于28的流，并把流中的数据收集到Map集合中，姓名为键，年龄为值，遍历Map
        Stream<String> stringStream1 = Stream.of(arr).filter(s -> s.split(",")[0].length() == 3).filter(s -> Integer.parseInt(s.split(",")[1]) > 28);
        Map<String, Integer> map = stringStream1.collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1])));
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        for (Map.Entry<String, Integer> a : entries) {
            System.out.println(a.getKey()+","+a.getValue());
        }
    }
}
Java8新特性之Stream流详解+案例
橘子汁的博客
06-11 2050
Stream是一个流，在java.util.Stream包路径下，主要作用就是对集合数据进行查找过滤等操作，一种高效且易用的数据处理方式 流的创建：此处列举3种常用方法 //1. 通过 java.util.Collection.stream() 方法 List<String> list = Arrays.asList("a", "b", "c"); Stream<String> stream = list.stream // 创建并行流 Stream<String>
java8新特性之Stream流操作
l_l_jh的博客
04-22 1517
Stream流操作是java8的最重要的新特性之一，功能强大,非常常用。可以说每个java coder必须掌握，这次把理论放在最后面，因为你可能不需要知道的多么详细，只是需要看看某个功能，可能听名字就大概知道它是做什么的。 举个简单例子，现在给了你同学信息和成绩，你需要统计班级平均分 // 以前可能的做法 public static avgScore(List<Student> stus){ int sum=0; for (Student student : stus) {
Java8 Stream流
不管多大的困难都要跨过去
08-08 289
Java8 Stream流
Java8 stream流
qq_44113347的博客
06-21 304
中间操作：使用中间操作对Stream对象进行过滤、映射、排序、限制等操作。同种类型的多个值 —> 通过Stream接口的静态方法of(T…终止操作： 使用终止操作执行Stream流并产生最终结果。终止操作会触发实际的计算。创建Stream：通过集合、数组、I/O管道等源数据创建一个Stream对象。Collection集合 —> 使用默认方法stream()生成流。在集合中添加一些数据，过滤出开头为李的名称并且只要长度为2的数据。Map集合 —> 把Map转成Set集合，间接的生成流。
java8 Stream流
m0_61682705的博客
04-10 7217
目录 前言 一.stream的使用场景特点 特点: 二.初步体验一下stream 三.简单看一下Stream的常用API 3.1 forEach()遍历集合中的对象 3.2filter对流对象进行过滤 3.3map()方法: 3.4count():计数 3.5 limit():选取流数据的前多少条数据 3.6 skip():跳转 3.7 concat():合并 四.总结: 4.1stream的实际开发好处 4.2stream应用中的不足 前言 今天我们主要对于str..
Java8的 Stream流
初心不改
07-18 289
Stream是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。特点：1 . 不是数据结构，不会保存数据。2. 不会修改原来的数据源，它会将操作后的数据保存到另外一个对象中。保留意见：毕竟peek方法可以修改流中元素。
Java8新特性Stream流实例详解
08-29
Java8新特性Stream流实例详解 Java 8 中引入了 Stream 流，用于操作数据源（集合、数组等）所生成的元素序列。Stream 流是数据渠道，具有声明性、可复合、可并行三个特性，使得 Stream 操作更简洁、更灵活、高效。...
java8新特性 stream流的方式遍历集合和数组操作
08-18
Java 8 新特性 Stream 流的方式遍历集合和数组操作 Java 8 中引入了 Stream 流的概念，旨在提供一种更加优雅的方式来遍历集合和数组。Stream 流可以看作是一种 lazy 的数据结构，它可以对集合和数组进行遍历、过滤...
Java8新特性之Stream流 （图片整理）
qq_43268400的博客
08-10 1004
Java8新特性之Stream流 学习笔记全面总结（图片整理） 由于放着一张图上太大，反而影响总结的效果。 故根据以下方式进行分类分开总结，最后再转一篇流的操作的案例的文章。 一 Stream流的概述 二 流的获取 三 流的操作方法列表及分类 四 流的操作方法-按使用目的分类 五 Stream流部分执行机制分析 六 转一篇流操作案例参考文 一 Stream流的概述 二 流的获取 三...
Java8 Stream 流
weixin_44061521的博客
12-24 2667
简介 Java8两大新特征，一是支持 lambda 表达式，二是 Stream API。在使用 Stream API 之前，最好有 lambda表达式的基础，如果不太清楚，可以看我的另一篇博客lambda表达式。 在编写代码的过程中，我们经常要对集合或数组数据进行操作，而有了 Stream API，我们能够非常轻松的对集合、数据进行映射、过滤、查找等操作，使得我们能够像操作数据库一样的操作集合。 Stream 本身并不存储元素，它并不改变源数据，每次操作都会形成一个新的流，并且只有执行了Stream的终止操
Java8之Stream流
Java小菜鸟
07-18 706
在编写代码的过程中，我们经常要对集合或数组数据进行操作，而有了 Stream API，我们能够非常轻松的对集合、数据进行映射、过滤、查找等操作，使得我们能够像操作数据库一样的操作集合。Stream 本身并不存储元素，它并不改变源数据，每次操作都会形成一个新的流，并且只有执行了Stream的终止操作，中间的过滤、查找等操作才会执行。集合注重存储，Stream注重计算。集合是基于内存层面的，而Stream是基于CPU的。
Java8--Stream流
最新发布
lfnew的博客
08-24 240
stream流操作是Java 8提供一个重要新特性，它允许开发人员以声明性方式处理集合，其核心类库主要改进了对集合类（Collection）的 API和新增Stream操作。Stream类中每一个方法都对应集合上的一种操作。将真正的函数式编程引入到Java中，能 让代码更加简洁，极大地简化了集合的处理操作，提高了开发的效率和生产力。
JAVA8 Stream
qq_34125999的博客
05-22 1621
Stream和IO流(InputStream/OutputStream)没有任何关系，请暂时忘记对传统IO流的固有印象！Stream流式思想类似于工厂车间的“生产流水线”，Stream流不是一种数据结构，不保存数据，而是对数据进行加工处理。Stream可以看作是流水线上的一个工序。在流水线上，通过多个工序让一个原材料加工成一个商品。Stream API能让我们快速完成许多复杂的操作，如筛选、切片、映射、查找、去除重复，统计，匹配和归约。
Java 8特性---Stream流
weixin_51464838的博客
08-21 156
/创建Stream//集合--->Stream流并进行排序、遍历});
万字详解 Stream 流式编程，写代码也可以很优雅
兴趣是最好的老师，勤能补拙
07-13 711
Stream（流）是 Java 8 引入的一个新的抽象概念，它代表着一种处理数据的序列。简单来说，Stream 是一系列元素的集合，这些元素可以是集合、数组、I/O 资源或者其他数据源。Stream API 提供了丰富的操作方法，可以对 Stream 中的元素进行各种转换、过滤、映射、聚合等操作，从而实现对数据的处理和操作。Stream API 的设计目标是提供一种高效、可扩展和易于使用的方式来处理大量的数据。
Java8的Stream流详解
qq_43751200的博客
04-09 2119
Java8的Stream流详解Stream流的概述Stream流的获取Stream流的常用APIStream流的综合应用收集Stream流 Stream流的概述 什么是Stream流？ 在Java 8中，得益于Lambda所带来的函数式编程， 引入了一个全新的Stream流概念。 目的：用于简化集合和数组操作的API。 Stream流式思想的核心： 1、先得到集合或者数组的Stream流（就是一根传送带） 2、把元素放上去 3、然后就用这个Stream流简化的API来方便的操作元素。 问题1、Stre
Java8新特性-Stream流的介绍与具体使用
有见寒舍
02-19 1365
Java8新特性-stream流
Java8新特性之Stream API（含具体案例）
Javaの甘乃迪的博客
10-13 540
Java8新特性--Stream API
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值