java8 ---Stream

作者: wudl | 来源:发表于2021-08-17 23:12 被阅读0次

Java8之Stream流（六）收集
Java 8 Stream--开发手册
Java8 学习笔记
Stream流
java8 stream lambda
JAVA8中Stream学习
Java8 Stream 流的重用
Java8 Stream 使用及其详解
Java 8 Stream 教程
Java8新特性

1. 集合的Lambda --forEach 使用

package com.wudl.java8.lambda;

import com.wudl.java8.bean.User;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @ClassName : LambaMethod
 * @Description :  Lamba 方法的使用
 * @Author :wudl
 * @Date: 2021-08-17 22:35
 */

public class LambaMethod {

    public static void main(String[] args) {

        //1.list ForEach 的输出
        LambaMethod.LambaList();
        //2.Map 的输出
        LambaMethod.LambaMap();
        //3. List 集合排序
        LambaMethod.getListSort();
    }

    public static void LambaList()
    {
        List<String> list = new ArrayList<String>();
        list.add("java");
        list.add("hive");
        list.add("Flink");

        list.forEach((num) -> {
            System.out.println(num);
        });
    }

    public static void LambaMap()
    {
        Map<String,Object> map = new HashMap<>();
        map.put("java","java-version");
        map.put("hive","hive-version");
        map.put("Flink","Flink-version");

        map.forEach((num,value) -> {
            System.out.println(num +"---"+ value);
        });
    }


}

// 输出的结果
"C:\Program Files\Java\jdk1.8.0_241\bin\java.exe" -Dvisualvm.id=4964856337000 "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 
-----------------LambaList--------------
java
hive
Flink
-----------------LambaMap--------------
hive---hive-version
java---java-version
Flink---Flink-version

1.1 集合的排序实例

package com.wudl.java8.lambda;

import com.wudl.java8.bean.User;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @ClassName : LambaMethod
 * @Description :  Lamba 方法的使用
 * @Author :wudl
 * @Date: 2021-08-17 22:35
 */

public class LambaMethod {

    public static void main(String[] args) {
        //3. List 集合排序
        LambaMethod.getListSort();
    }


    public  static  void  getListSort()
    {
        System.out.println("-----------------getListSort--------------");
        List<User> list = new ArrayList<>();
        list.add(new User("java",18));
        list.add(new User("spark",10));
        list.add(new User("doris",15));
        list.add(new User("flink",20));

        list.sort((key1,value1) ->
            key1.getAge() - value1.getAge()
        );

        list.forEach(value1 ->{
            System.out.println(value1);
        });
    }
}
// 输入的结果
-----------------getListSort--------------
User(name=spark, age=10)
User(name=doris, age=15)
User(name=java, age=18)
User(name=flink, age=20)

Process finished with exit code 0

2.Java8 的Stream 的使用

    java8 引入的流主要是针对集合的操作： 类似Sql 查询数据库

功能 :Stream ：非常方便精简的形式遍历集合实现过滤、排序等。

Stram 操作.png

2.1 Stream 流的创建方式

1. parallelStream为并行流采用多线程执行
2.Stream采用单线程执行
3.parallelStream效率比Stream要高。

  List<User> userEntities = new ArrayList<>();
        userEntities.add(new User("mayikt", 20));
        userEntities.add(new User("meite", 28));
        userEntities.add(new User("zhangsan", 35));
        userEntities.add(new User("xiaowei", 16));
        userEntities.add(new User("xiaowei", 16));

        userEntities.stream();
        Stream<User> userStream = userEntities.parallelStream();

2.2 将创建的流转化为Set 集合并且打印出来

package com.wudl.java8.stream;

import com.wudl.java8.bean.User;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @ClassName : UserStream
 * @Description : Stream  的使用
 * @Author :wudl
 * @Date: 2021-08-17 22:59
 */

public class UseStream {

    public static void main(String[] args) {
    //
        UseStream.StreamToSet();
    }

    /**
     * 流的创建
     * @return
     */
    public static Stream<User> CreateStream()
    {
        List<User> userEntities = new ArrayList<>();
        userEntities.add(new User("mayikt", 20));
        userEntities.add(new User("meite", 28));
        userEntities.add(new User("zhangsan", 35));
        userEntities.add(new User("xiaowei", 16));
        userEntities.add(new User("xiaowei", 16));

        userEntities.stream();
        Stream<User> userStream = userEntities.parallelStream();
        return userStream;
    }

    /**
     * 将lIST 转为流 在通过流转化为Set 集合
     */
    public static void StreamToSet()
    {
        Stream<User> userStream = UseStream.CreateStream();
        Set<User> userSet = userStream.collect(Collectors.toSet());
        System.out.println("----------------StreamToSet---------------");
        System.out.println(userSet);
    }
}

// 打印结果
Connected to the target VM, address: '127.0.0.1:52982', transport: 'socket'
----------------StreamToSet---------------
[User(name=meite, age=28), User(name=zhangsan, age=35), User(name=xiaowei, age=16), User(name=mayikt, age=20)]


Process finished with exit code 0

** 后期追加*

1.将list 转为流，在通过流转化为map 集合

   /**
     * 1.将list 转为流， 在通过流转化为map 集合
     */
    public static void StreamToMap() {
        Stream<User> userStream = UseStream.CreateStream();
        Map<String, User> userMap = userStream.collect(Collectors.toMap(new Function<User, String>() {
                   @Override
                   public String apply(User userEntity) {
                       return userEntity.getName();
                   }
               }, new Function<User, User>() {

                   @Override
                   public User apply(User User) {
                       return User;
                   }
               }
        ));
        userMap.forEach(new BiConsumer<String, User>() {
            @Override
            public void accept(String s, User user) {
                System.out.println(s + "====" + user.toString());
            }
        });
    }

2.通过流就和 resuce

 /**
     * 2.通过流就和 resuce
     */
    public static void StreamToReduceToSum() {
        Stream<Integer> stream = Stream.of(1, 2, 5, 6, 8);
        // 第一种求和实现
//        Optional<Integer> reduce = stream.reduce((a1, a2) -> a1 + a2);
        // 第二种求和实现
        Optional<Integer> reduce = stream.reduce(new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer o, Integer o2) {
                return o + o2;
            }
        });
        System.out.println(reduce);
    }

3.通过流求出两个流的最大值和最小值 max 和 min


    /**
     * 3.通过流求出两个流的最大值和最小值  max  和 min
     */
    public static void StreamMaxAndMin() {
        // 求最小值
        Stream<User> userStream = UseStream.CreateStream();
        Optional<User> max = userStream.max((a1, a2) -> {
            return a1.getAge() - a2.getAge();
        });
        System.out.println("max---" + max);

        // 求最小值
        Stream<User> userStreamMin = UseStream.CreateStream();
        Optional<User> min = userStreamMin.min((a1, a2) -> {
            return a1.getAge() - a2.getAge();
        });
        System.out.println("min--" + min);
    }

4. Match 元素返回true 和false

4.1 anyMatch表示，判断的条件里，任意一个元素成功，返回true
4.2 allMatch表示，判断条件里的元素，所有的都是，返回true
4.3 noneMatch跟allMatch相反，判断条件里的元素，所有的都不是，返回true

 /**
     * 4. 根据流匹配一个值 返回  true or false
     *      anyMatch表示，判断的条件里，任意一个元素成功，返回true
     *      allMatch表示，判断条件里的元素，所有的都是，返回true
     *      noneMatch跟allMatch相反，判断条件里的元素，所有的都不是，返回true
     */
    public static void StreamMatch() {
        Stream<User> userStream = UseStream.CreateStream();
        boolean b = userStream.noneMatch(new Predicate<User>() {
            @Override
            public boolean test(User user) {
                return user.getAge() > 50;
            }
        });

        //  5. allMatch  全匹配
        Stream<User> userStream2 = UseStream.CreateStream();
        boolean flink = userStream2.allMatch(new Predicate<User>() {
            @Override
            public boolean test(User user) {
                return user.getAge()<20;
            }
        });
        System.out.println("allMatch--"+flink);

        System.out.println(b);
    }

6. 流的循环


    /**
     *  6. 流的循环
     */
    public static void MyStreamFor()
    {
        Stream<User> userStream = UseStream.CreateStream();
        userStream.forEach(new Consumer<User>() {
            @Override
            public void accept(User user) {
                System.out.println(user.getAge() +"--"+user.getName());
            }
        });

        Stream<User> userStreamForeach = UseStream.CreateStream();
        userStreamForeach.forEach((user ->{
            System.out.println("2--"+user.getAge() +"--"+user.getName());
        }));

    }

7.Stream过滤器

    /**
     *  7.Stream过滤器
     */
    public  static void StreamFilter()
    {
        Stream<User> userStream = UseStream.CreateStream();
        Stream<User> flink = userStream.filter(new Predicate<User>() {
            @Override
            public boolean test(User user) {
                return user.getAge() > 20;
            }
        }).filter(new Predicate<User>() {
            @Override
            public boolean test(User user) {
                return user.getName().equals("Flink");
            }
        });
        flink.forEach(user ->{
            System.out.println(user.toString());
        });
    }

8.流的排序

 /**
     *  8.流的排序
     */

    public static  void StreamTOSort()
    {
        List<User> userEntities = new ArrayList<>();
        userEntities.add(new User("mayikt", 20));
        userEntities.add(new User("meite", 28));
        userEntities.add(new User("zhangsan", 35));
        userEntities.add(new User("xiaowei", 16));
        userEntities.add(new User("Flink", 22));
        userEntities.add(new User("hdfs", 18));
        List<User> collect = userEntities.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());
        collect.forEach(new Consumer<User>() {
            @Override
            public void accept(User user) {
                System.out.println(user.toString());
            }
        });
    }

9. Stream Skip 和Limit


    /**
     *  9. Stream Skip  和Limit
     */
    public static void StreamLimitAndSkip()
    {
        List<User> userEntities = new ArrayList<>();
        userEntities.add(new User("mayikt", 20));
        userEntities.add(new User("meite", 28));
        userEntities.add(new User("zhangsan", 35));
        userEntities.add(new User("xiaowei", 16));
        userEntities.add(new User("Flink", 22));
        userEntities.add(new User("hdfs", 18));

        Stream<User> stream = userEntities.stream();
        stream.skip(2).limit(3).forEach(u ->{
            System.out.println(u.toString());
        });

    }

Java8之Stream流（六）收集
Java8之Stream流（一）基础体验 Java8之Stream流（二）关键知识点 Java8之Stream...
Java 8 Stream--开发手册
什么是Java8 Stream，为什么需要Stream？ Stream是Java8一大亮点，它与 java.io ...
Java8 学习笔记
@(in action系列)[java8, lambda, stream] Java8 学习 java8 能高效的...
Stream流
Stream流 java8新特性 Stream定义 A sequence of elements supporti...
java8 stream lambda
记录Java8的stream操作，供自己复习。创建Stream Employee类创建stream方法 for...
JAVA8中Stream学习
JAVA8中Stream学习最近看了下Stream的api： Stream用户操作Collection族的数据，...
Java8 Stream 流的重用
Java8 Stream 已经被操作或关闭引言在 java8 中，Stream 不能被重用，一旦它被使用或使用...
Java8 Stream 使用及其详解
一、什么是Stream 二、Java7和Java8 聚合操作的区别。三、Stream 总览四、Stream 的...
Java 8 Stream 教程
本文采用实例驱动的方式，对JAVA8的stream API进行一个深入的介绍。虽然JAVA8中的stream AP...
Java8新特性
一、Lambda案例案例1 案例2 二、Stream接口 Stream介绍 Stream在Java8中被定义为泛...

java8 ---Stream

1. 集合的Lambda --forEach 使用

1.1 集合的排序实例

2.Java8 的Stream 的使用

2.1 Stream 流的创建方式

2.2 将创建的流转化为Set 集合并且打印出来

** 后期追加*

1.将list 转为流，在通过流转化为map 集合

2.通过流就和 resuce

3.通过流求出两个流的最大值和最小值 max 和 min

4. Match 元素返回true 和false

6. 流的循环

7.Stream过滤器

8.流的排序

9. Stream Skip 和Limit

相关文章

Java8之Stream流（六）收集

Java 8 Stream--开发手册

Java8 学习笔记

Stream流

java8 stream lambda

JAVA8中Stream学习

Java8 Stream 流的重用

Java8 Stream 使用及其详解

Java 8 Stream 教程

Java8新特性

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

java8 ---Stream

1. 集合的Lambda --forEach 使用

1.1 集合的排序实例

2.Java8 的Stream 的使用

2.1 Stream 流的创建方式

2.2 将创建的流转化为Set 集合并且打印出来

************************************** 后期追加*************************************

1.将list 转为流， 在通过流转化为map 集合

2.通过流就和 resuce

3.通过流求出两个流的最大值和最小值 max 和 min

4. Match 元素返回true 和false

6. 流的循环

7.Stream过滤器

8.流的排序

9. Stream Skip 和Limit

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

** 后期追加*

1.将list 转为流，在通过流转化为map 集合