Java核心类库之(Stream流:生成、中间、终结、收集操作)

简介: 黑马程序员全套Java教程_Java基础入门视频教程,零基础小白自学Java必备教程

以下博客是根据黑马视频写的Javase全集博客笔记:黑马程序员全套Java教程_Java基础入门视频教程,零基础小白自学Java必备教程


(一)Java语言基础

(二)Java面向对象编程

(三)Java核心类库之(常用API、字符串类、集合类、泛型)

(四) Java核心类库之(异常机制)

(五)Java核心类库之(字符集/编码集、File类、递归、IO流:字节流、字符流、特殊操作流)

(六)Java核心类库之(类加载器、反射机制、模块化)

(七)Java核心类库之(Lambda表达式)

(八)Java核心类库之(接口组成更新、方法引用、函数式接口)

(九)Java核心类库之(Stream流:生成、中间、终结、收集操作)

(十)Java核心类库之(多线程:实现多线程、线程同步)

(十一)Java核心类库之(网络编程:网络编程入门、UDP通信程序、TCP通信程序)


1 Stream流

体验Stream流

需求

image.png

package test;
import java.lang.reflect.Array;
import java.util.ArrayList;
public class Demo {
    public static void main(String[] args) {
        //创建集合,储存多个字符
        ArrayList<String> list = new ArrayList<>();
        list.add("小黑");
        list.add("张无忌");
        list.add("大熊猫");
        list.add("张天峰");
        list.add("小白");
        list.add("张飞");
        //把集合中所有以“张”开头的数据存储到新的集合
        ArrayList<String> zhanglist = new ArrayList<>();
        for(String s:list) {
            if(s.startsWith("张")) {
                zhanglist.add(s);
            }
        }
//        System.out.println(zhanglist); //[张无忌, 张天峰, 张飞]
        //把"张“开头长度为3的存到新集合
        ArrayList<String> threelist = new ArrayList<>();
        for(String s:zhanglist) {
            if(s.length()==3) {
                threelist.add(s);
            }
        }
        for(String s:threelist) {
            System.out.println(s);
//            张无忌
//            张天峰
        }
        //Stream流
        list.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3);
//            张无忌
//            张天峰
    }
}

使用Stream流的方式完成过滤操作

list.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3);

直接阅读代码的字面意思即可完美展示无关逻辑方式的语义: 生成流、过滤姓张、过滤长度为3、逐一打印

Stream流把真正的函数式编程风格引入到Java中

1.1 Stream流的生成方式

Stream流的常见生成方式

1、Collection体系的集合可以使用默认方法stream()生成流:default Stream<E> stream()

2、Map体系的集合间接的生成流

3、数组可以通过Stream接口的静态方法生成流:of (T... values)

package test;
import java.util.*;
import java.util.stream.Stream;
public class Demo {
    public static void main(String[] args) {
        //1、Collection体系的集合可以使用默认方法stream()生成流:default Stream<E> stream()
        List<String> list = new ArrayList<>();
        Stream<String> listStream = list.stream();
        Set<String> set = new HashSet<>();
        Stream<String> setStream = set.stream();
        //2、Map体系的集合间接的生成流
        Map<String,Integer> map = new HashMap<>();
        Stream<String> keyStream = map.keySet().stream(); //KeySet()方法得到一个Set集合
        Stream<Integer> valueStream = map.values().stream();
        Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();
        //3、数组可以通过Stream接口的静态方法生成流:of (T... values)
        String[] strArray = {"java","python","scala"};
        Stream<String> strArrayStream1 = Stream.of(strArray);
        Stream<String> strArrayStream2 = Stream.of("java","python");
        Stream<Integer> integerStream = Stream.of(10, 20, 30);
    }
}

Stream流的使用方法

方法名 说明

list.stream() 生成流:通过数据源(集合,数组等)生成流

filter() 中间操作:一个流后面可以跟随零个或多个中间操作, 其目的主要是打开流,做出某种程度的数据过滤映射,然后返回一个新的流,交给下一个操作使用

forEach() 终结操作:一个流只能有一个终结操作,当这个操作执行后,流就被使用“光" 了,无法再被操作。所以这必定是流的最后一个操作

1.2 Stream流中间操作之 filter

Stream<T> filter(Predicate predicate):用于对流中的数据进行过滤


Predicate接口中的方法boolean test(T t):対给定的参数迸行判断,返回一个布尓值


范例


package test;
import java.util.ArrayList;
public class Demo {
    public static void main(String[] args) {
        //创建一个集合存储多个元素
        ArrayList<String> list = new ArrayList<>();
        list.add("小黑");
        list.add("张无忌");
        list.add("大熊猫");
        list.add("张天峰");
        list.add("小白");
        list.add("张飞");
        //需要1:把list集合中以张开头的在控制台输出
        list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
        System.out.println("--------");
//        张无忌
//        张天峰
//        张飞
        //需要2:把list集合中长度为3的元素输出
        list.stream().filter(s -> s.length() == 3).forEach(System.out::println);
        System.out.println("--------");
//        张无忌
//        大熊猫
//        张天峰
        //需求3:把以张开头,长度为3的在控制台输出
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
//        张无忌
//        张天峰
    }
}

1.3 Stream流中间操作之 limit 和 skip

Stream<T> limit(long maxSize):返回此流中的元素组成的流,截取前指定参数个数的数据

Stream<T> skip(long n):跳过指定参数个数的数据,返回由该流的剩余元素组成的流

范例:

package test;
import java.util.ArrayList;
public class Demo {
    public static void main(String[] args) {
        //创建一个集合存储多个元素
        ArrayList<String> list = new ArrayList<>();
        list.add("小黑");
        list.add("张无忌");
        list.add("大熊猫");
        list.add("张天峰");
        list.add("小白");
        list.add("张飞");
        //需要1:取前三个数据在控制台输出
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("---------");
//        小黑
//        张无忌
//        大熊猫
        //需求2:跳过3个元素,把剩下的在控制台输出
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("---------");
//        张天峰
//        小白
//        张飞
        //需求3:跳过2个元素,把剩下元素的前两个输出
        list.stream().skip(2).limit(2).forEach(System.out::println);
//        大熊猫
//        张天峰
    }
}

1.4 Stream流中间操作之 concat 和 distinct

static <T> Stream<T> concat(Stream а, Stream b):合并a和b两个流为一个流


Stream<T> distinct():返回由该流的不同元素(根据Object.equals(Object)) 组成的流


范例:


package test;
import java.util.ArrayList;
import java.util.stream.Stream;
public class Demo {
    public static void main(String[] args) {
        //创建一个集合存储多个元素
        ArrayList<String> list = new ArrayList<>();
        list.add("小黑");
        list.add("张无忌");
        list.add("大熊猫");
        list.add("张天峰");
        list.add("小白");
        list.add("张飞");
        //需要1:取前4个数据组成一个流
        Stream<String> s1 = list.stream().limit(4);
        //需求2:跳过2个数据组成一个流
        Stream<String> s2 = list.stream().skip(2);
        //需求3:合并1,2结果得到的流,并输出
//        Stream.concat(s1,s2).forEach(System.out::println);
//        小黑
//        张无忌
//        大熊猫
//        张天峰
//        大熊猫
//        张天峰
//        小白
//        张飞
        //需求4:合并1,2结果得到的流,并输出,要求结果不重复
        Stream.concat(s1, s2).distinct().forEach(System.out::println);
//        小黑
//        张无忌
//        大熊猫
//        张天峰
//        小白
//        张飞
    }
}

1.5 Stream流中间操作之 sorted

Stream<T> sorted():返回由此流的元素组成的流,根据自然顺序排序

Stream<T> sortểd(Comparator comparator):返回由此流的元素组成的流,根据提供的Comparator排序

范例

package test;
import java.util.ArrayList;
public class Demo {
    public static void main(String[] args) {
        //创建一个集合存储多个元素
        ArrayList<String> list = new ArrayList<>();
        list.add("b123");
        list.add("a1");
        list.add("f1234");
        list.add("c12");
        list.add("e12345");
        list.add("d12345");
        //需要1:按照字母顺序在控制台输出
        list.stream().sorted().forEach(System.out::println);
//        a1
//        b123
//        c12
//        d12345
//        e12345
//        f1234
        //需求2:按照字符串长度,长度相同自然排序
        list.stream().sorted((s1, s2) -> {
            int num1 = s1.length() - s2.length();
            int num2 = num1 == 0 ? s1.compareTo(s2) : num1;
            return num2;
        }).forEach(System.out::println);
//        a1
//        c12
//        b123
//        f1234
//        d12345
//        e12345
    }
}

1.6 Stream流中间操作之 map 和 mapToInt

<R> Stream<R> map(Function mapper):返回由给定函数应用于此流元素的结果组成的流

Function接口中的方法—R apply(T t)

IntStream mapToInt(ToIntFunction mapper):返回一个InStream其中包含给定函数应用于此流的元素的结果

Instream:表示原始流

TolntFunction接口中的方法—int applyAslnt(T value)

范例:

package test;
import java.util.ArrayList;
public class Demo {
    public static void main(String[] args) {
        //创建一个集合存储多个元素
        ArrayList<String> list = new ArrayList<>();
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");
        //需要:将集合中的字符串转换为整数后在控制台输出
//        list.stream().map(s->Integer.parseInt(s)).forEach(System.out::println);
        //方法引用
//        list.stream().map(Integer::parseInt).forEach(System.out::println);
//        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
//        10
//        20
//        30
//        40
//        50
        //InStream中方法 :int sum()返回流中元素总和
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result); //150
    }
}

1. 7 Stream流终结操作之 forEach 和 count

Stream流的常见终结操作方法


void forEach(Consumer action):对此流的每个元素执行操作

Consumer接口中的方法—void accept(T t):对给定的参数执行此操作

long count():返回此流中的元素数

范例

package test;
import java.util.ArrayList;
public class Demo {
    public static void main(String[] args) {
        //创建一个集合存储多个元素
        ArrayList<String> list = new ArrayList<>();
        list.add("小黑");
        list.add("张无忌");
        list.add("大熊猫");
        list.add("张天峰");
        list.add("小白");
        list.add("张飞");
        //需求1:输出集合中的元素
        list.stream().forEach(System.out::println);
//        小黑
//        张无忌
//        大熊猫
//        张天峰
//        小白
//        张飞
        //需求2:统计以张开头的个数
        long count = list.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(count); //3
    }
}

1.8 Stream流收集操作

对数据使用Stream流的方式操作完毕后,我想把流中的数据收集到集合中,该怎么办呢?

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集合中

范例

package test;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Demo {
    public static void main(String[] args) {
        //创建list集合存储多个元素
        ArrayList<String> list = new ArrayList<>();
        list.add("小黑");
        list.add("大熊猫");
        list.add("张飞");
        list.add("小熊猫");
        //需求1:得到名字为三个字的流
        Stream<String> listStream = list.stream().filter(name -> name.length() == 3);
        //需求2:把使用Stream操作得到数据存入list集合并遍历
        List<String> names = listStream.collect(Collectors.toList());
        for (String name : names) {
            System.out.println(name);
//            大熊猫
//            小熊猫
        }
        //创建Set集合对象
        Set<Integer> set = new HashSet<>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(40);
        //需求3:得到年龄大于25的流
        Stream<Integer> setStream = set.stream().filter(age -> age > 25);
        //需求4:把使用Stream操作得到数据存入set集合并遍历
        Set<Integer> ages = setStream.collect(Collectors.toSet());
        for (Integer age : ages) {
            System.out.println(age);
//            40
//            30
        }
        //定义个字符串数组,由姓名和年龄组成
        String[] strArray = {"小黑,10", "小白,20", "小熊猫,30", "大熊猫,40"};
        //需求5:得到字符串数组中年龄大于25的流
        Stream<String> arrayStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 28);
        //需求6:把使用Stream操作得到数据存入map集合并遍历,姓名做键,年龄做值
        Map<String, Integer> map = arrayStream.collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1])));
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            Integer vlaue = map.get(key);
            System.out.println(key + "," + vlaue);
//            大熊猫,40
//            小熊猫,30
        }
    }
}
相关文章
|
3天前
|
Java API
深入探讨 Java 8 集合操作:全面解析 Stream API 的强大功能
深入探讨 Java 8 集合操作:全面解析 Stream API 的强大功能
13 2
|
7天前
|
DataWorks 数据挖掘 调度
DataWorks产品使用合集之如何查看HTTP触发器调用的域名
DataWorks作为一站式的数据开发与治理平台,提供了从数据采集、清洗、开发、调度、服务化、质量监控到安全管理的全套解决方案,帮助企业构建高效、规范、安全的大数据处理体系。以下是对DataWorks产品使用合集的概述,涵盖数据处理的各个环节。
|
3天前
|
安全 Java 程序员
[笔记] 疯狂JAVA讲义(第3版)第7章 Java基础类库
[笔记] 疯狂JAVA讲义(第3版)第7章 Java基础类库
|
3天前
|
存储 消息中间件 NoSQL
使用 Java 操作 Redis 数据类型的详解指南
使用 Java 操作 Redis 数据类型的详解指南
5 0
|
4天前
|
存储 缓存 Java
滚雪球学Java(59):从基础到高阶:Java中LinkedList的操作指南
【6月更文挑战第13天】🏆本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
10 1
滚雪球学Java(59):从基础到高阶:Java中LinkedList的操作指南
|
4天前
|
Java 大数据 API
【大数据】HDFS、HBase操作教程(含指令和JAVA API)
【大数据】HDFS、HBase操作教程(含指令和JAVA API)
33 0
【大数据】HDFS、HBase操作教程(含指令和JAVA API)
|
5天前
|
JSON Java 网络架构
【elastic search】JAVA操作elastic search
【elastic search】JAVA操作elastic search
7 1
|
5天前
|
存储 Java API
Java8实战-使用Stream
Java8实战-使用Stream
7 0
Java8实战-使用Stream
|
5天前
|
存储 分布式计算 Java
Java8实战-引入流(Stream)
Java8实战-引入流(Stream)
8 0
|
6天前
|
JavaScript Java Serverless
Serverless 应用引擎操作报错合集之Java函数在运行时出现报错:"operation not permitted",是什么意思
Serverless 应用引擎(SAE)是阿里云提供的Serverless PaaS平台,支持Spring Cloud、Dubbo、HSF等主流微服务框架,简化应用的部署、运维和弹性伸缩。在使用SAE过程中,可能会遇到各种操作报错。以下是一些常见的报错情况及其可能的原因和解决方法。