Java8Stream

于 2024-05-24 12:43:09 发布
阅读量861 收藏 14
点赞数 20
分类专栏： Java篇 文章标签： 算法 开发语言 java 后端 idea 面试 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_77543831/article/details/139087962
版权

目录

什么是Stream?

IO流：

Java8Stream：

什么是流？

stream图解

获取流

集合类，使用 Collection 接口下的 stream()

代码

数组类，使用 Arrays 中的 stream() 方法

代码

stream，使用 Stream 中的静态方法

代码

流操作

按步骤写

代码

链式调用

代码

运行

中间操作：

 API

代码 

运行

代码 

运行

代码

运行 

终端操作：

API

代码

运行

代码

运行

代码

运行

代码

运行

代码

运行

代码

运行

什么是Stream?

IO流：

输入输出文件的

Java8Stream：

处理数据集合（数组，集合类）；

对数组，集合类 进行各种操作（过滤，排序......）；

stream处理数据的大体过程：

数组/集合类-->流-->各种操作（排序，过滤...）-->结果。

什么是流？

数据和集合类更偏向于存储数据（各种结构）；

stream更偏向于数据操作。

stream图解

获取流

获取流，把集合或者数组转化为stream对象。

集合类，使用 Collection 接口下的 stream()
代码
package com.ffyc.stream;

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

public class Demo1 {
    public static void main(String[] args) { 
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(4);
        //把集合转为流
        Stream<Integer> stream = arrayList.stream(); 
    }
}
数组类，使用 Arrays 中的 stream() 方法
代码
package com.ffyc.stream; 

import java.util.Arrays;
import java.util.stream.IntStream; 

public class Demo1 {
    public static void main(String[] args) { 
        int[] array = new int[]{1,2,3,4};
        //把数组转为流
        IntStream intStream = Arrays.stream(array); 
    }
}
stream，使用 Stream 中的静态方法
代码
package com.ffyc.stream;

import java.util.stream.Stream;

public class Demo1 {
    public static void main(String[] args) { 
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);
    }
}

流操作

按步骤写
代码
package com.ffyc.stream;

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

public class Demo2 {
    public static void main(String[] args) {   
        Integer[] array = new Integer[]{1,2,3,4,5};
        Stream<Integer> stream = Arrays.stream(array);
        Stream stream1 = stream.filter();
        Stream stream2 = stream1.sorted();
    }
}
链式调用
代码
package com.ffyc.stream;


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

public class Demo2 {
    public static void main(String[] args) { 
        long sum = Arrays.stream(array)
                .sorted()
                .count();
    }
}
运行

中间操作：

流的各种数据处理

 API

filter：过滤流中的某些元素,
sorted(): 自然排序，流中元素需实现 Comparable 接口
distinct: 去除重复元素 

代码 
package com.ffyc.stream;


import java.util.Arrays; 

public class Demo2 {
    public static void main(String[] args) { 
        Integer[] array = new Integer[]{1,2,3,4,2,5}; 
        Arrays.stream(array)
                .filter((e)->{
                    return e<5;
                })
                .sorted((o1,o2)->{
                    return o2-o1;
                })
                .distinct()
                .forEach((e)->{
                    System.out.println(e);
                });
    }
}
运行

limit(n): 获取 n 个元素
skip(n): 跳过 n 元素，配合 limit(n)可实现分页

代码 
package com.ffyc.stream;


import java.util.Arrays; 

public class Demo2 {
    public static void main(String[] args) { 
        Integer[] array = new Integer[]{1,2,3,4,2,5}; 
        Arrays.stream(array)
                //跳过指定数量个元素
                .skip(2)
                //取出指定数量个元素
                .limit(2)
                .forEach((e)->{
                    System.out.println(e);
                }); 
    }
}
运行

map():将其映射成一个新的元素

代码
package com.ffyc.stream;
 

public class Student {
    private int num;
    private String name;
    private int age;

    public Student(int num, String name, int age) {
        this.num = num;
        this.name = name;
        this.age = age;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

package com.ffyc.stream;

import java.util.ArrayList;
import java.util.Arrays; 
import java.util.Map;
import java.util.stream.Collectors;

public class Demo4 {
    public static void main(String[] args) {
        Student s1 = new Student(001,"张三",18);
        Student s2 = new Student(002,"李四",19);
        Student s3 = new Student(003,"王五",29);
        Student s4 = new Student(004,"王麻子",21);
        Student s5 = new Student(005,"丽丽",19);

        ArrayList<Student> students = new ArrayList<>();
        students.add(s3);
        students.add(s1);
        students.add(s2);
        students.add(s5);
        students.add(s4); 

        Object[] array = students.stream()
                .map((Student::getNum))//将对象中某个属性的值映射到一个新集合中
                .toArray();
        System.out.println(Arrays.toString(array));

        Map<Integer, String> map = students.stream()
                .collect(Collectors.toMap(Student::getNum, Student::getName));
        System.out.println(map);
    }
}
运行 

终端操作：

把流转为最终结果（数组/集合/单值）

API

Min:返回流中元素最小值
Max:返回流中元素最大值 

代码
package com.ffyc.stream;

import java.util.Arrays; 

public class Demo3 {
    public static void main(String[] args) { 
        Integer[] array = new Integer[]{1,2,3,4,2,5};
        Integer max = Arrays.stream(array)
                .distinct()
                .max((o1, o2) -> {//最大值
                    return o1 - o2;
                }).get();
        System.out.println(max);

        Integer min = Arrays.stream(array)
                .distinct()
                .min((o1, o2) -> {//最小值
                    return o1 - o2;
                }).get();
        System.out.println(min); 
}
运行

count:返回流中元素的总个数

代码
package com.ffyc.stream;

import java.util.Arrays; 

public class Demo3 {
    public static void main(String[] args) { 
        Integer[] array = new Integer[]{1,2,3,4,2,5}; 

        long count = Arrays.stream(array)
                .distinct()
                .count();//统计元素个数
        System.out.println(count); 
    }
}
运行

Reduce:所有元素求和

代码
package com.ffyc.stream;

import java.util.Arrays; 

public class Demo3 {
    public static void main(String[] args) { 
        Integer[] array = new Integer[]{1,2,3,4,2,5}; /

        long reduce = Arrays.stream(array)
                .distinct()
                .reduce((a,b)->{//求和
                    return a+b;
                }).get();
        System.out.println(reduce); 
    }
}
运行

anyMatch:接收一个 Predicate 函数，只要流中有一个元素满足条件则返回 true，否则返回 false
allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返回 true，否则返回 false

代码
package com.ffyc.stream;

import java.util.Arrays; 

public class Demo3 {
    public static void main(String[] args) { 
        Integer[] array = new Integer[]{1,2,3,4,2,5}; 

        Boolean result1 = Arrays.stream(array)
                .distinct()
                .anyMatch((e)->{//只有有一个元素满足条件，返回true
                    return e>2;
                });
        System.out.println(result1);

        Boolean result2 = Arrays.stream(array)
                .distinct()
                .allMatch((e)->{//所有的条件都满足条件，返回true
                    return e>2;
                });
        System.out.println(result2); 
    }
}
运行

findFirst：返回流中第一个元素

代码
package com.ffyc.stream;

import java.util.Arrays; 

public class Demo3 {
    public static void main(String[] args) { 
        Integer[] array = new Integer[]{1,2,3,4,2,5}; 

        Integer result = Arrays.stream(array)
                .distinct()
                .findFirst()
                .get();
        System.out.println(result);
    }
}
运行

collect:将流中的元素倒入一个集合,Collection 或 Map

代码
package com.ffyc.stream;
 

public class Student {
    private int num;
    private String name;
    private int age;

    public Student(int num, String name, int age) {
        this.num = num;
        this.name = name;
        this.age = age;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

package com.ffyc.stream;

import java.util.ArrayList; 
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Demo4 {
    public static void main(String[] args) {
        Student s1 = new Student(001,"张三",18);
        Student s2 = new Student(002,"李四",19);
        Student s3 = new Student(003,"王五",29);
        Student s4 = new Student(004,"王麻子",21);
        Student s5 = new Student(005,"丽丽",19);

        ArrayList<Student> students = new ArrayList<>();
        students.add(s3);
        students.add(s1);
        students.add(s2);
        students.add(s5);
        students.add(s4);

        List<Student> collect = students.stream()
                .sorted((a,b)->{ //对学生对象集合进行排序，必须给定排序的规则
                    return a.getNum()-b.getNum();
                })
                .collect(Collectors.toList());
        System.out.println(collect);

        List<Student> res = students.stream()
                .filter((stu) -> {
                  return  stu.getAge()>18;
                })
                .collect(Collectors.toList());
        System.out.println(res);

        List<Integer> list = students.stream()
                .map(Student::getNum)
                .collect(Collectors.toList());
        System.out.println(list);
    }
}
运行

苏十八
关注
  • 20
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值