stream与函数式接口

最新推荐文章于 2022-11-24 18:08:08 发布
最新推荐文章于 2022-11-24 18:08:08 发布
阅读量156 收藏
点赞数
分类专栏： Java基础 文章标签： Java基础 stream流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37572877/article/details/101148430
版权

title: stream与函数式接口
date: 2019-07-24 14:03:02
categories:

  • java基础
    tags:

1. 思维导图

思维导图

2. Stream 与函数式接口

2.1. 获取流

  • 所有的 Collection 集合都可以通过 stream 默认方法获取流
  • Stream 接口的静态方法 of 可以获取数组对应的流
  • Map 不是集合类型，需要根据 key, value, entry 分别获取相应的流

2.2. 流的方法

2.2.1. forEach

  • void forEach(Consumer<? super T> action);

2.2.2. filter

  • Stream filter(Predicate<? super T> predicate);

2.2.3. map

将流中的元素映射到另一个流中，通常是用来转换成另一个类型

  • Stream map(Function<? super T, ? extends R> mapper);

2.2.4. count

  • long count();

2.2.5. limit

  • Stream limit(long maxSize);

2.2.6. skip

  • Stream skip(long n);

2.2.7. concat

  • static Stream concat(Stream<? extends T> a, Stream<? extends T> b)

2.3. collect 的使用

2.3.1. 转换为 list

  • collect.()

2.3.2. 转换为 map

传入 key, value 即可

  • public static <T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper,
    Function<? super T,? extends U> valueMapper)
  • 例如：Stream.concat(one.stream(), two.stream()).collect(Collectors.toMap(s -> s, s -> new Person(s)));

2.4. 流的方法练习

package javaBase.Stream;

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

/**
 * @author jhmarryme.cn
 * @date 2019/7/24 11:21
 */
public class StreamAndFunctionalInterface {


    /**
     * 测试流的各种方法结合常用函数式接口的使用
     * @param args
     */
    public static void main(String[] args) {
        ArrayList<String> one = new ArrayList<>();

        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石中玉");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");

        //第二支队伍
        ArrayList<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");



//        1. 第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
        one.stream().filter(s -> s.length() == 3).collect(Collectors.toList()).forEach(s -> System.out.println(s));
        System.out.println("------------");

//        2. 第一个队伍筛选之后只要前3个人；存储到一个新集合中。
        one.stream().limit(3).collect(Collectors.toList()).forEach(s -> System.out.println(s));
        System.out.println("------------");

//        3. 第二个队伍只要姓张的成员姓名；存储到一个新集合中。
        two.stream().filter(s -> s.startsWith("张")).collect(Collectors.toList()).forEach(s -> System.out.println(s));
        System.out.println("------------");

//        4. 第二个队伍筛选之后不要前2个人；存储到一个新集合中。
        two.stream().skip(2).collect(Collectors.toList()).forEach(s -> System.out.println(s));
        System.out.println("------------");

//        5. 将两个队伍合并为一个队伍；存储到一个新集合中。
        Stream<String> stream = Stream.concat(one.stream(), two.stream());
//        stream.collect(Collectors.toList()).forEach(s -> System.out.println(s));
        System.out.println("------------");

//        6. 根据姓名创建`Person`对象；存储到一个新集合中。
//        7. 打印整个队伍的Person对象信息。
        stream.map(s -> {
            return new Person(s);
        }).collect(Collectors.toList()).forEach(person -> System.out.println(person.toString()));


        //8. 补充, 将list映射为map
        final Map<String, Person> map = Stream.concat(one.stream(), two.stream()).collect(Collectors.toMap(s -> s, s -> new Person(s)));
        final Set<Map.Entry<String, Person>> entries = map.entrySet();
        for (Map.Entry<String, Person> entry : entries) {
            System.out.print(entry.getKey());
            System.out.println(" : " + entry.getValue().toString());
        }


        //将int数组转换为list
        int[] arr = {1,2,3,2,2,2,5,4,2};


        //boxed装箱
        final List<Integer> collect = Arrays.stream(arr).boxed().collect(Collectors.toList());
        final Iterator<Integer> iterator = collect.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next() +  " ");
        }

        //将list转换为int[], 因为int不是包装类型, 需要做转换
        final int[] array = collect.stream().mapToInt(Integer::intValue).toArray();
        for (int i : array) {
            System.out.print(i + " ");
        }

    }


}

2.5. 函数式接口

有且仅有一个抽象方法的接口

2.5.1. Supplier

生产一个数据

  • T get()

2.5.2. Consumer

是消费一个数据

  • void accept(T t)
  • 默认方法：andThen

2.5.3. Predicate

对某种类型的数据进行判断

  • boolean test(T t)
  • 默认方法：and or negate

2.5.4. Function<T,R>

根据一个类型的数据得到另一个类型的数据

  • R apply(T t)
  • 默认方法：andThen

2.6. 函数式接口方法练习

2.6.1. 比较器

package javaBase.functionalInterface.functionalInterfaceDemo;

import java.util.Arrays;

/**
 * 通过lambda表达式 作为比较器
 * @author jhmarryme.cn
 * @date 2019/7/22 9:43
 */
public class LambdaForComparatorDemo {

    public static void main(String[] args) {
        String[] array = { "abc", "ab", "abcd" };
        System.out.println(Arrays.toString(array));
        Arrays.sort(array, (a, b) -> {
        return a.length() - b.length();
    });
        System.out.println(Arrays.toString(array));

    }
}

2.6.2. consumer

package javaBase.functionalInterface.functionalInterfaceDemo;

import java.util.function.Consumer;

/**
 * 测试Consumer接口
 * 消费一个指定泛型的数据, 无返回值
 * 可通过andThen组合操作
 * @author jhmarryme.cn
 * @date 2019/7/22 11:21
 */
public class LambdaForConsumerDemo {

    public static void consumerString(String[] info, Consumer<String> con1, Consumer<String> con2, Consumer<String> con3){

        for (String s : info) {
            con1.andThen(con2).andThen(con3).accept(s);
        }

    }

    public static void main(String[] args) {

        String[] array = { "迪丽热巴,女, 14", "古力娜扎,女, 12", "马尔扎哈,男, 121" };

        consumerString(array,
                s -> System.out.print("姓名: " + s.split(",")[0]),
                s -> System.out.print("性别: " + s.split(",")[1]),
                s -> System.out.println("年龄: " + s.split(",")[2])
                );
    }
}

2.6.3. supplier

package javaBase.functionalInterface.functionalInterfaceDemo;

import java.util.function.Supplier;

/**
 * 测试Supplier接口
 * 包含一个无参的方法, 用来获取一个泛型参数指定类型的对象数据
 * @author jhmarryme.cn
 * @date 2019/7/22 9:52
 */
public class LambdaForSupplierDemo {

    public static void main(String[] args) {
        /*String msgA = "Hello";
        String msgB = "World";

        System.out.println(getString(() -> msgA + msgB));*/

        int arr[] = {2,3,4,52,333,23};

        System.out.println(getMax(() -> {

            int max = arr[0];
            for (int i : arr) {
                max = i > max ? i : max;
            }
            return max;
        }));
    }


    public static int getMax(Supplier<Integer> integerSupplier){
        return integerSupplier.get();
    }



    public static String getString(Supplier<String> stringSupplier){
        return stringSupplier.get();
    }



}

2.6.4. function

package javaBase.functionalInterface.functionalInterfaceDemo;

import java.util.function.Function;

/**
 * 通过函数式结构练习function接口
 * 根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件
 * @author jhmarryme.cn
 * @date 2019/7/22 13:15
 */
public class LambdaForFunctionDemo {


    /**
     * 根据接口的泛型
     * apply方法中参数类型为String, 返回Integer
     * @param integerFunction
     */
    public static void method(Function<String, Integer> integerFunction){

        final Integer apply = integerFunction.apply("5");
        System.out.println(apply + 20);
    }


    /**
     * 在前一个function的基础上再进行处理
     * 第二个function的第一个泛型必须为前一个function的后一个泛型
     * 相当于前一个的结果为Integer, 后一个就必须用Integer接收
     * @param f1
     * @param f2
     */
    public static void methood(Function<String, Integer> f1, Function<Integer, Integer> f2){

        final Integer apply = f1.andThen(f2).apply("1");
        System.out.println(apply);
    }

    /**
     * 截取数字部分, 得到的结果加上100返回
     * @param str
     * @param f1
     * @param f2
     * @return
     */
    public static Integer getAgeNum(String str, Function<String, Integer> f1, Function<Integer, Integer> f2){
        return f1.andThen(f2).apply(str);
    }


    public static void main(String[] args) {
//        method((s) -> Integer.parseInt(s));

//        methood(s -> Integer.parseInt(s)+1, i -> i = ((int)Math.pow(i, 10)));
        String str = "赵丽颖,20";
        final Integer ageNum = getAgeNum(str,
                s -> Integer.parseInt(s.split(",")[1]),
                i -> i = i + 100
        );

        System.out.println(ageNum);
    }
}

2.6.5. predicate

package javaBase.functionalInterface.functionalInterfaceDemo;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

/**
 * 通过函数式接口练习predicate相关的方法
 * 对泛型指定数据类型进行判断, 得到一个布尔值.
 * 包含与或非and, or, negate
 * @author jhmarryme.cn
 * @date 2019/7/22 12:54
 */
public class LambdaForPredicateDemo {

    public static Boolean method( Predicate<String> stringPredicate){
        return stringPredicate.test("helloWorld");
    }

    public static void method(Predicate<String> p1, Predicate<String> p2){

        final boolean helloWorld = p1.or(p2).test("HelloWorld");
        System.out.println(helloWorld);

    }



    public static ArrayList<String> filterString(String[] arr, Predicate<String> stringPredicate){

        final ArrayList<String> list = new ArrayList<>();

        for (String s : arr) {
            if (stringPredicate.test(s)) {
                list.add(s);
            }
        }
        return list;
    }



    public static void main(String[] args) {

        /*System.out.println(method(s -> {
            return s.length() > 5;
        }));
*/

//        method(s -> s.contains("el"), s -> s.length() > 10);



        /**
         * 筛选条件:
         * 必须为女生；
         * 姓名为4个字。
         */
        String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
        final ArrayList<String> arrayList = filterString(array, s -> {

            return s.split(",")[1].equals("女") && s.split(",")[0].length() == 4;

        });
        for (String s : arrayList) {
            System.out.println(s);
        }


    }
}

2.6.6. lambda延迟加载

package javaBase.functionalInterface.DelayForLambda;

import static javaBase.functionalInterface.DelayForLambda.MessageBuilder.MAX_NUM;

/**
 * 测试lambda表达式的延迟执行
 * 优化性能, 在不符合条件时, 不会执行lambda的内容
 * @author jhmarryme.cn
 * @date 2019/7/22 9:32
 */
public class DelayForLambdaDemo {

    public static void log(int level, MessageBuilder builder){
        if (level == 1) {
            System.out.println(builder.messageBuilder());
        }
    }


    public static void main(String[] args) {
        String msgA = "Hello";
        String msgB = "World";
        String msgC = "Java";
        //这里的拼接字符串 在条件不成立时不会执行
        log(1, () -> msgA + msgB + msgC );
    }
}


package javaBase.functionalInterface.DelayForLambda;

/**
 * @author jhmarryme.cn
 * @date 2019/7/22 9:33
 */

@FunctionalInterface
public interface MessageBuilder {

    int MAX_NUM = 97;
    /**
     * 测试lambda延迟加载
     * @return
     */
    String messageBuilder();
}
jhmarriedme
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
day14-函数式接口&Stream
06-10
day14-函数式接口&Stream
day14-函数式接口&Stream流1
08-04
【函数式接口与Java Stream流】 函数式接口是Java 8引入的重要概念，它为Java提供了函数式编程的支持。函数式接口是指具有一个抽象方法的接口。这种接口可以被Lambda表达式所代表，使得我们可以将行为作为参数传递...
函数式接口&Stream流
HYJ940228的博客
08-15 189
1.函数式接口 1.1函数式接口概述【理解】 概念 有且仅有一个抽象方法的接口 如何检测一个接口是不是函数式接口 @FunctionalInterface 放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败 注意事项 我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接...
玩转Java8的 Stream 之函数式接口
Java知音
05-24 665
作者：liteskywww.jianshu.com/p/2338cabc59e1函数式接口是伴随着Stream的诞生而出现的，Java8Stream 作为函数式编程的一种具体实现，开发者...
Stream 和函数式接口的基础讲解
庄周de蝴蝶的博客
02-19 804
前言 关于 Stream 和函数式接口的基础概念的文章已经有很多，相信很多小伙伴也在实际工作中进行使用体验了。但是关于函数式接口的使用，部分小伙伴可能接触的比较少，其实我们经常使用的 map、filter 等方法内部就使用了函数式接口的知识： // 以下两个接口截取自 Java8 源码中的定义, 这里的 Function<? super T, ? extends R> // 和 Predicate<? super T> 就属于函数式接口方面的知识 <R> Stream&
函数式接口Stream类
听闻
12-29 417
一、Stream概述 1.1 关于流的简介 Java8是一个非常成功的版本，新增的Stream，配合同版本出现的Lambda，为我们操作集合提供了极大的便利。 ​ Stream 是 Java8 中处理集合的关键抽象概念，它可以指定我们希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来执行并行操作。 ​ Stream将要处理的元素集合看做一种流，在流的过程中，借助
详解JAVA8 函数式接口
08-18
在本文中，我们将详细介绍JAVA8 函数式接口的相关知识点，包括四大核心函数式接口和其他函数式接口，并提供了相应的代码示例。 四大核心函数式接口： 1. Consumer接口：消费型接口，无返回值。它的主要用途是对...
Java 8新特性 内建函数式接口详解
09-01
例如，可以使用`Stream` API结合这些函数式接口来实现过滤、映射和聚合操作。 此外，Java 8还提供了一些其他内置的函数式接口，如`BiFunction`（接受两个参数并返回一个结果）、`Runnable`（无参数无返回的行动）...
【java初学】函数式接口和Stream
九离的博客
04-05 240
文章目录函数式接口和Stream1. 函数式接口1.1 函数式接口概述1.2 常用函数式接口1.3 比较器函数式接口1.4 消费函数式接口 Consumer1.5 生产者接口 Supplier1.6 转换数据类型接口 Function1.7 判断接口 Predicate2. Stream流式操作2.1 先体验后讲解2.2 Stream流式思想2.3 Stream流对象2.4 filter 过滤2.5 Map映射2.6 sorted排序方法2.7 limit 和 skip2.8 foreach 和 count
Stream流的使用函数式接口
weixin_47120348的博客
01-20 421
认识函数式接口 @FunctionalInterface public interface Lamdbatest { Integer getdouble(Integer s); } Lamdba表达式 lamdba可以实现函数式接口创建出一个对象， lamdba允许把一个函数作为一个方法的参数，或是将一个方法赋值给一个属性 -实现类实现接口 public class impllamdba implements Lamdbatest { @Override public I.
stream流及函数式接口
qq_42862808的博客
05-24 584
Stream流 Stream流可以看做流水线,把原始数据转换为流进行一系列加工,最后收集的过程,特点: 1 . 不是数据结构，不会保存数据。 2. 不会修改原来的数据源，它会将操作后的数据保存到另外一个对象中。 3. 惰性求值，流在中间处理过程中，只是对操作进行了记录，并不会立即执行，需要等到执行终止操作的时候才会进行实际的计算。 常用的Stream流方法 名称 作用 方法种类 limit 截取指定个数 非终结方法 skip 跳过指定个数 非终结方法 filter 对流进行过滤 筛
Java：Stream三部曲（一）：函数式接口的理解与常用示例（Runnable、Comparator、Callable、Consumer、Predicate、Supplier、Function）
whx6666666的博客
11-24 2345
Stream流处理器入门第一步——函数式接口。本文主要包含关于函数式接口的简略基础概念、个人学习过程中的一些理解以及对当前JDK中内置的主要函数式接口的用法解析（包括Runnable、Comparator、Callable、Consumer、Predicate、Supplier、Function）。
函数式接口与Stream流的用法
zouyouxiu的博客
12-29 745
文章目录函数式接口与Stream流的用法1.函数式接口1.1 常用函数式接口2.Stream流1.1 获取流1.2 常用方法 函数式接口与Stream流的用法 1.函数式接口 函数接口在java中是指：有且仅有一个抽象方法的接口。函数式接口，即适用于函数式编程场景使用。而java中的函数式编程体现的就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象...
玩转Java8Stream（二）——函数式接口
这个时代，作为程序员可能要学习小程序
11-26 344
点击上方的终端研发部，右上角选择“设为星标”作者：litesky链接：https://www.jianshu.com/p/2338cabc59e1前言函数式接口是伴随着Stream的诞生...
常用函数式接口及Stream流
qq_42573597的博客
04-25 228
1、常用函数式接口 1.1Supplier接口 ​ 功能 ​ 生产型接口,接口的泛型指定成什么类型,就生产什么类型的数据（提供函数式接口，方便使用Lambda进行简化代码） ​ 抽象方法 ​ T get() ​ 生产指定类型的数据 package com.itfenghua02; import java.util.function.Supplier; public ...
java基础-8 函数式编程
QYmufeng的博客
11-04 265
函数式接口 函数式接口概述 函数式接口作为方法的参数 public class Test { public static void main(String[] args) { //匿名内部类 startThread(new Runnable() { @Override pu...
JAVA-接口中定义抽象方法及使用{笔记}
QL_DIANDIAN的博客
09-27 7789
接口的定义 在接口中定义抽象方法的时候 （抽象方法的一般格式;public abstract 返回值类型 方法名（）；） (1)但是在接口中抽象方法，修饰符必须是两个固定的关键字 public abstract (2)其中public abstract 可以省略 (3)方法的三要素可以随意更改 public interface Myinterface { //以下都可以 public abstract void method(); public void method1(); abstract
Stream方法使用
xxpxxpoo8的专栏
06-14 1699
stream
stream流函数式接口
最新发布
09-14
在 Stream API 中，常用的函数式接口有 Predicate、Function、Consumer、Supplier 等，它们可以通过 Lambda 表达式或方法引用来创建，并可以与流操作相结合使用，实现各种数据处理操作。 希望这个回答能够解决你对 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值