Java8新特性之Stream流

最新推荐文章于 2023-08-21 16:40:19 发布
最新推荐文章于 2023-08-21 16:40:19 发布
阅读量79 收藏
点赞数
分类专栏： 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());
        }
    }
}
CCQsuai戈尔
关注
专栏目录
Java8新特性Stream流实例详解
08-29
Java8新特性Stream流实例详解 Java 8 中引入了 Stream 流，用于操作数据源（集合、数组等）所生成的元素序列。Stream 流是数据渠道，具有声明性、可复合、可并行三个特性，使得 Stream 操作更简洁、更灵活、高效。...
Java8中Stream流的详细用法
不惧困难 顽强拼搏
06-14 4857
Java8的两个重大改变，一个是Lambda表达式，另一个就是的Stream 是Java8中处理集合的关键抽象概念，它可以对集合进行非常复杂的查找、过滤、筛选等操作。
万字详解 Stream 流式编程，写代码也可以很优雅
兴趣是最好的老师，勤能补拙
07-13 597
Stream（流）是 Java 8 引入的一个新的抽象概念，它代表着一种处理数据的序列。简单来说，Stream 是一系列元素的集合，这些元素可以是集合、数组、I/O 资源或者其他数据源。Stream API 提供了丰富的操作方法，可以对 Stream 中的元素进行各种转换、过滤、映射、聚合等操作，从而实现对数据的处理和操作。Stream API 的设计目标是提供一种高效、可扩展和易于使用的方式来处理大量的数据。
Java8 Stream 流
weixin_44061521的博客
12-24 2627
简介 Java8两大新特征，一是支持 lambda 表达式，二是 Stream API。在使用 Stream API 之前，最好有 lambda表达式的基础，如果不太清楚，可以看我的另一篇博客lambda表达式。 在编写代码的过程中，我们经常要对集合或数组数据进行操作，而有了 Stream API，我们能够非常轻松的对集合、数据进行映射、过滤、查找等操作，使得我们能够像操作数据库一样的操作集合。 Stream 本身并不存储元素，它并不改变源数据，每次操作都会形成一个新的流，并且只有执行了Stream的终止操
Java8之Stream流
Java小菜鸟
07-18 695
在编写代码的过程中，我们经常要对集合或数组数据进行操作，而有了 Stream API，我们能够非常轻松的对集合、数据进行映射、过滤、查找等操作，使得我们能够像操作数据库一样的操作集合。Stream 本身并不存储元素，它并不改变源数据，每次操作都会形成一个新的流，并且只有执行了Stream的终止操作，中间的过滤、查找等操作才会执行。集合注重存储，Stream注重计算。集合是基于内存层面的，而Stream是基于CPU的。
Java8 Stream 使用详解
qq_39939541的博客
07-12 2021
Java 8引入了Stream流的概念，它是对集合对象（Collection）进行操作的高级抽象。Stream流的操作分为两种：中间操作和终端操作。中间操作是指在流上进行的操作，返回的仍然是一个流，可以进行链式操作，而终端操作是指对流的最终操作，返回的是一个结果或者一个副作用。Stream流的特点如下：Stream流是对集合对象的一种封装，使得可以用函数式编程的方式对集合进行操作。Stream流的操作是延迟执行的，只有在终端操作时才会触发执行。
java8新特性 stream流的方式遍历集合和数组操作
08-18
Java 8 新特性 Stream 流的方式遍历集合和数组操作 Java 8 中引入了 Stream 流的概念，旨在提供一种更加优雅的方式来遍历集合和数组。Stream 流可以看作是一种 lazy 的数据结构，它可以对集合和数组进行遍历、过滤...
java8新特性-最新
12-18
在Java 8中，最重要的两个新特性无疑是Lambda表达式和Stream API。这两个特性都与函数式编程思想密切相关，让Java开发者能够更加灵活地处理数据。 ### Lambda表达式 Lambda表达式是Java 8中最显著的新特性之一，它...
Java8新特性之方法引用&Stream流应用实例md，学习代码
最新发布
06-21
Java 8是Java语言的一个重要版本，引入了许多新特性，极大地提升了开发效率和代码的可读性。在本文中，我们将重点关注两个关键特性：方法引用和Stream流，并结合实际应用实例进行深入探讨。 首先，我们来看一下方法...
Java8之Stream流代替For循环操作
08-24
Java8之Stream流代替For循环操作 Java8中引入了Stream流代替For循环操作，具有很好的参考价值，希望对大家有所帮助。Stream流代替For循环进行输出可以使代码更简洁。 Stream流的优点 1. 代码简洁：使用Stream流...
java8 Stream流
纯洁的小魔鬼
11-04 1141
1.流操作 分为两大类：中间操作和终端操作，可以连接起来的流操作称为中间操作，关闭流的操作称为终端操作。 2.中间操作和终端操作 例如filter等中间操作会返回另一个流,除非流水线上触发一个终端操作，否则中间操作不会执行任何处理，它们很懒。这是因为中间操作一般都可以合并起来，在终端操作时一次性全部处理。 流的使用一般包括三个步骤：生成流，中间操作，终端操作 常用的中间操作:filte......
Java8的Stream流详解
qq_43751200的博客
04-09 2094
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流
qq_44113347的博客
06-21 291
中间操作：使用中间操作对Stream对象进行过滤、映射、排序、限制等操作。同种类型的多个值 —> 通过Stream接口的静态方法of(T…终止操作： 使用终止操作执行Stream流并产生最终结果。终止操作会触发实际的计算。创建Stream：通过集合、数组、I/O管道等源数据创建一个Stream对象。Collection集合 —> 使用默认方法stream()生成流。在集合中添加一些数据，过滤出开头为李的名称并且只要长度为2的数据。Map集合 —> 把Map转成Set集合，间接的生成流。
Java—JDK8新特性—Steam流
Acloasia的博客
05-11 1816
在JDK 8中提供了Stream API，把真正的函数式编程风格引入到Java中，它可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。Stream是JDK 8中处理集合的关键抽象概念，它可以指定你希望对进行的操作，可以执非常复杂查找、过滤和映射数据等。使用Stream APl对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作。简而言之，StreamAPI提供了一种高效且易于使用的处理数据的方式。
Java 8特性---Stream流
weixin_51464838的博客
08-21 142
/创建Stream//集合--->Stream流并进行排序、遍历});
JAVA8 Stream
qq_34125999的博客
05-22 1598
Stream和IO流(InputStream/OutputStream)没有任何关系，请暂时忘记对传统IO流的固有印象！Stream流式思想类似于工厂车间的“生产流水线”，Stream流不是一种数据结构，不保存数据，而是对数据进行加工处理。Stream可以看作是流水线上的一个工序。在流水线上，通过多个工序让一个原材料加工成一个商品。Stream API能让我们快速完成许多复杂的操作，如筛选、切片、映射、查找、去除重复，统计，匹配和归约。
Java8新特性-Stream流的介绍与具体使用
有见寒舍
02-19 1321
Java8新特性-stream流
Java8新特性 stream流常用方法
PPX、小布的博客
06-08 259
元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。内部迭代： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。
Java8的 Stream流
初心不改
07-18 269
Stream是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。特点：1 . 不是数据结构，不会保存数据。2. 不会修改原来的数据源，它会将操作后的数据保存到另外一个对象中。保留意见：毕竟peek方法可以修改流中元素。
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、付费专栏及课程。

余额充值