函数式接口与Stream流的用法

最新推荐文章于 2023-02-17 09:57:53 发布

邹优秀

最新推荐文章于 2023-02-17 09:57:53 发布

阅读量751

点赞数 2

分类专栏： java 文章标签： java stream lambda

本文链接：https://blog.csdn.net/weixin_44792004/article/details/103757832

版权

java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

函数式接口与Stream流的用法

函数式接口与Stream流的用法

1.函数式接口

函数接口在java中是指：有且仅有一个抽象方法的接口。函数式接口，即适用于函数式编程场景使用。而java中的函数式编程体现的就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，java中的Lambda才能顺利的推导。

样式：

@FunctionalInterface//用于约束函数式接口的格式
修饰符 interface 接口名称 { 
	public abstract 返回值类型 方法名称(可选参数信息); 
	// 其他非抽象方法内容 
}
@FunctionalInterface:与@Override注解作用相似，java8中专门为函数式接口引入的注解，作用就是判断这个接口是否是一个函数式接口，不加@FunctionalInterface注解也不影响，只要接口中只有一个抽象方法，那么就是函数式接口。

以下简单介绍一下常用的函数式接口用法，主要为了下面的Stream流方法中的函数式接口

1.1 常用函数式接口

Supplier 生产型接口

抽象方法：T get() : 返回一个T类型的对象

 public static void main(String[] args) {
        String s = "aa";
        System.out.println(getString(() -> s));
    }

    private static String getString(Supplier<String> function) {
        return function.get();
    }

Consumer 消费型接口

抽象方法:void accept(T t) : 使用传入的T类型的对象 t

  public static void main(String[] args) {
        consume(s -> System.out.println(s));
    }

    private static void consume(Consumer<String> function) {
        function.accept("aa");
    }

Predicate 判断型接口

抽象方法: boolean test(T t) : 判断传入的对象t是否满足某种条件

 public static void main(String[] args) {
        judge(s-> s.equals("aa"));
    }
    
    private static void judge(Predicate<String> predicate) {
        boolean flag = predicate.test("aa");
    }

Function<T,R> 转换型接口把T类型的对象转换成R类型的对象

抽象方法:R apply(T t) : 把传入的T类型的对象 t ，转换成 R类型的结果返回

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

    private static void toInteger(Function<String, Integer> function) {
        Integer aa = function.apply("666");
    }

2.Stream流

在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。

当需要对多个元素进行操作（特别是多步操作）的时候，考虑到性能及便利性，我们应该首先拼好一个“模型”步骤

方案，然后再按照方案去执行它，流式思想类似于工厂车间的“生产流水线。

在这里插入图片描述

这张图中展示了过滤、映射、跳过、计数等多步操作，这是一种集合元素的处理方案，而方案就是一种“函数模型”。图中的每一个方框都是一个“流”，调用指定的方法，可以从一个流模型转换为另一个流模型。而最右侧的数字 3是最终结果。

这里的 filter 、 map 、 skip 都是在对函数模型进行操作，集合元素并没有真正被处理。只有当终结方法 count 执行的时候，整个模型才会按照指定策略执行操作。而这得益于Lambda的延迟执行特性。

Lambda延迟加载特性，可以优化操作：

普通方式拼接字符串：

 public static void get(int i, String s) {
        if (i == 1) {
            System.out.println(s);
        }
    }
    public static void main(String[] args) {
        String a = "a";
        String b = "b";
        String c = "c";
        get(1,a+b+c);
    }
不管怎么样都会进行字符串拼接

使用Lambda拼接字符串：

定义一个函数接口

@FunctionalInterface 
public interface StringAppend { 
	String append(); 
}

 public static void get(int i, StringAppend stringAppend) {
        if (i == 1) {
            String append = stringAppend.append();
            System.out.println(append);
        }
    }

    public static void main(String[] args) {
        String a = "a";
        String b = "b";
        String c = "c";
        get(1, () -> {
            System.out.println("执行了");//检验是否在条件不满足的情况下执行了字符串拼接
            return a + b + c;
        });
    }
当为1的时候，控制台输出：执行了
当不为1的时候，控制台为空
使用Lambda可以延迟加载，并且使用匿名内部类也是可行的，但是匿名内部类会创建对象的class文件，浪费性能，所以使用Lambda效率更高。

总结：有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。而Lambda表达式是延迟执行的，这正好可以作为解决方案，提升性能。在一些业务中可以使用Lambda的延迟加载特性进行优化。

备注：“Stream流”其实是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素（或其地址值）。

Stream（流）是一个来自数据源的元素队列

元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
数据源的来源。可以是集合，数组等。

和以前的Collection操作不同， Stream操作还有两个基础的特征：

Pipelining: 中间操作都会返回流对象本身。这样多个操作可以串联成一个管道，如同流式风格。这样做可以对操作进行优化，比如延迟执行和短路。
内部迭代：以前对集合遍历都是通过Iterator或者增强for的方式, 显式的在集合外部进行迭代，这叫做外部迭代。 Stream提供了内部迭代的方式，流可以直接调用遍历方法。

当使用一个流的时候，通常包括三个基本步骤：获取一个数据源（source）→ 数据转换→执行操作获取想要的结

果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以

像链条一样排列，变成一个管道。

1.1 获取流

java.util.stream.Stream是java8新加入的最常用的流接口。获取流的方法非常简单，有以下几种最常用的方式：

所有的Collection集合都可以通过stream默认方法获取流
Stream接口的静态方法of可以获取数组对应的流

更多用法可以查看jdk8 api文档。

demo：

public static void main(String[] args) {
    //根据Collection获取流
    ArrayList<String> list = new ArrayList<>();
    Stream<String> stream = list.stream();
    HashSet<String> set = new HashSet<>();
    Stream<String> stream1 = set.stream();

    //根据Map获取流
    //Map接口不是 Collection 的子接口,且其K-V数据结构不符合流元素的单一特征，所以获取对应的流 需要分key、value或entry等情况
    HashMap<String, String> map = new HashMap<>();
    Stream<String> stream2 = map.keySet().stream();
    Stream<String> stream3 = map.values().stream();
    Stream<Map.Entry<String, String>> stream4 = map.entrySet().stream();

    //根据数组获取流
    int [] arr={1,2,3,4,5,6};
    //of方法的参数是一个可变参数，所以支持数组
    Stream<int[]> arr1 = Stream.of(arr);
}

1.2 常用方法

流模型的操作非常丰富，这里演示一些常用的API。这些方法可以被分为俩种：

延迟方法：返回值类型仍然是Stream接口自身类型的方法，因此支持链式调用。(除了终结方法，其他均为延迟方法)。
终结方法：返回值类型不再是Stream接口自身的方法，因此不再支持类似StringBuilder那样的链式调用(也就是不可以在继续对流进行操作)，本次demo中count和forEach方法为终结方法。

demo：

注意：以下方法中的函数式接口可以看上面的函数接口中具体作用

延迟方法：

Stream filter(Predicate<? super T> predicate)：传入过滤的规则，给数组或集合中的元素进行过滤

public static void main(String[] args) {
    Stream<String> stream = Stream.of("10", "12", "18");
    Stream<String> stringStream = stream.filter(s -> "10".equals(s));
    stringStream.forEach(s -> System.out.println(s));
}

结果：10

Stream map(Function<? super T, ? extends R> mapper)：把集合中的元素类型转换成另一种类型

public static void main(String[] args) {
    Stream<String> stream = Stream.of("10", "12", "18");
    Stream<Integer> result = stream.map(s -> Integer.parseInt(s));
}

Stream limit(long maxSize)：截取数组或集合前maxSize个元素

public static void main(String[] args) {
    Stream<String> stream = Stream.of("10", "12", "18");
    Stream<String> limit = stream.limit(1);
    limit.forEach(s -> System.out.println(s));
}

结果：10

Stream skip(long n)：跳过数组或集合前n个元素若n>集合的长度,那么生成的新Stream 是空的

public static void main(String[] args) {
    Stream<String> stream = Stream.of("10", "12", "18");
    Stream<String> skip = stream.skip(1);
    skip.forEach(s -> System.out.println(s));
}

结果：12
	 18

static Stream concat(Stream<? extends T> a, Stream<? extends T> b)：把stream流1和stream流2合并成一个新Stream流

public static void main(String[] args) {
    Stream<String> stream1 = Stream.of("10", "12");
    Stream<String> stream2 = Stream.of("13");
    Stream.concat(stream1,stream2).forEach(s -> System.out.println(s));
}

结果：10
	 12
	 13

终结方法

void forEach(Consumer<? super T> action) ：传入你要对Stream流中的数据进行的操作,并在foreach方法内循环stream流

public static void main(String[] args) {
    Stream.of(1,2,3,4).forEach(s-> System.out.println(s));
}
结果：1
	 2
	 3
	 4

long count()：统计stream流中数据的个数

public static void main(String[] args) {
    Stream<String> stream = Stream.of("10", "12","14");
    long count = stream.count();
    System.out.println(count);
}

结果：3

注意：

流只能操作单列集合和数组；双列集合可以拆成单列集合并被Stream流操作
从一个车间到另一个车间，原来的Stream对象就不可以继续使用

邹优秀

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
函数式接口与Stream流的用法

文章目录函数式接口与Stream流的用法1.函数式接口1.1 常用函数式接口2.Stream流1.1 获取流1.2 常用方法函数式接口与Stream流的用法1.函数式接口函数接口在java中是指：有且仅有一个抽象方法的接口。函数式接口，即适用于函数式编程场景使用。而java中的函数式编程体现的就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象...
复制链接

扫一扫