menu ChaYedan
Java基础知识(四)
441 浏览 | 2020-04-15 | 阅读时间: 约 6 分钟 | 分类: Java | 标签: Java
请注意,本文编写于 897 天前,最后修改于 831 天前,其中某些信息可能已经过时。

Lambda表达式

面向对象过分强调“必须通过对象的形式来做事情”,而函数式思想则尽量忽略面向对象的复杂语法——强调做什么,而不是以什么形式做。

本质是匿名内部类的简化书写格式

标准格式

  • 一些参数
  • 一个箭头
  • 一段代码

Lambda表达式的标准格式为:

(参数类型 参数名称) -> { 代码语句 }
格式说明
  • 小括号内的语法与传统方法参数列表一致:无参数则留空;多个参数则用逗号分隔。
  • -> 是新引入的语法格式,代表指向动作。
  • 大括号内的语法与传统方法体要求基本一致。
省略格式

省略规则

在Lambda标准格式的基础上,使用省略写法的规则为:

  1. 小括号内参数的类型可以省略;
  2. 如果小括号内有且仅有一个参,则小括号可以省略;
  3. 如果大括号内有且仅有一个语句,则无论是否有返回值,都可以省略大括号、return关键字及语句分号。
    备注:掌握这些省略规则后,请对应地回顾本章开头的多线程案例。

可推导即可省略

Lambda的前提条件

  1. 使用Lambda必须具有接口,且要求接口中有且仅有一个抽象方法。
    无论是JDK内置的 Runnable 、 Comparator 接口还是自定义的接口,只有当接口中的抽象方法存在且唯一

时,才可以使用Lambda。

  1. 使用Lambda必须具有接口作为方法参数。
    也就是方法的参数或局部变量类型必须为Lambda对应的接口类型,才能使用Lambda作为该接口的实例。

备注

有且仅有一个抽象方法的接口,称为“函数式接口”。

函数式接口

函数式接口在Java中是指:有且仅有一个抽象方法的接口

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

备注:

从应用层面来讲,Java中的Lambda可以看做是匿名内部类的简化格式,但是二者在原理上不同。

格式

只要确保接口中有且仅有一个抽象方法即可:

修饰符 interface 接口名称 {
    public abstract 返回值类型 方法名称(可选参数信息);
    // 其他非抽象方法内容
}

由于接口当中抽象方法的 public abstract 是可以省略的,所以定义一个函数式接口很简单:

public interface MyFunctionalInterface {
    void myMethod();
}

自定义函数式接口

对于刚刚定义好的 MyFunctionalInterface 函数式接口,典型使用场景就是作为方法的参数:

public class Demo07FunctionalInterface {
    // 使用自定义的函数式接口作为方法参数
    private static void doSomething(MyFunctionalInterface inter) {
    inter.myMethod(); // 调用自定义的函数式接口方法
    }
public static void main(String[] args) {
    // 调用使用函数式接口的方法
    doSomething(() -> System.out.println("Lambda执行啦!"));
    }
}

FunctionalInterface注解

@Override 注解的作用类似,Java 8中专门为函数式接口引入了一个新的注解: @FunctionalInterface 。该注
解可用于一个接口的定义上:

@FunctionalInterface
public interface MyFunctionalInterface {
    void myMethod();
}

一旦使用该注解来定义接口,编译器将会强制检查该接口是否确实有且仅有一个抽象方法,否则将会报错。不过,
即使不使用该注解,只要满足函数式接口的定义,这仍然是一个函数式接口,使用起来都一样。

常用函数式接口

JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景,它们主要在 java.util.function 包中被提供。

Consumer接口

java.util.function.Consumer<T> 接口,是消费一个数据,其数据类型由泛型参数决定。

抽象方法

accept:Consumer 接口中包含抽象方法 void accept(T t) : 消费一个指定泛型的数据

//给你一个字符串,请按照大写的方式进行消费
import java.util.function.Consumer;
public class Demo08Consumer {
public static void main(String[] args) {
    String str = "Hello World";
    //1.lambda表达式标准格式
    fun(str,(String s)->{
    System.out.println(s.toUpperCase());
    });
    //2.lambda表达式简化格式

    fun(str,s-> System.out.println(s.toUpperCase()));
    }
    /*
    定义方法,使用Consumer接口作为参数
    fun方法: 消费一个String类型的变量
    */
    public static void fun(String s,Consumer<String> con) {
    con.accept(s);
    }
}
Predicate接口

有时候我们需要对某种类型的数据进行判断,从而得到一个boolean值结果。这时可以使用java.util.function.Predicate<T> 接口。

抽象方法:test

Predicate 接口中包含一个抽象方法: boolean test(T t) 。用于条件判断的场景:

//1.练习:判断字符串长度是否大于5
//2.练习:判断字符串是否包含"H"
public class Demo09Predicate {
    private static void method(Predicate<String> predicate,String str) {
        boolean veryLong = predicate.test(str);
        System.out.println("字符串很长吗:" + veryLong);
    }
    public static void main(String[] args) {
        method(s -> s.length() > 5, "HelloWorld");
    }
}

条件判断的标准是传入的Lambda表达式逻辑,只要字符串长度大于5则认为很长。总结来说,就是用这个接口作为方法的一个参数,用lambda表达式可以直接将接口中的方法实现。

Stream流

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

获取流方式

java.util.stream.Stream<T> 是Java 8新加入的最常用的流接口。

获取一个流非常简单,有以下几种常用的方式:

  • 所有的 Collection 集合都可以通过 stream 默认方法获取流;
  • Stream 接口的静态方法 of 可以获取数组对应的流。
方式1 : 根据Collection获取流

首先, java.util.Collection 接口中加入了default方法 stream 用来获取流,所以其所有实现类均可获取流。

java.util.Collection<T> 接口

    默认方法: 必须由Collection接口的实现类(ArrayList/LinkedList/HashSet/LinkedHashSet)对象调用
        public default Stream<T> stream(): 获取Collection集合对象对应的Stream流对象
方式2: 根据数组获取流

如果使用的不是集合或映射而是数组,由于数组对象不可能添加默认方法,所以 Stream 接口中提供了静态方法of

java.util.stream.Stream<T> 接口:

    静态方法
    public static <T> Stream<T> of(T ... t): 把方法的可变参数指定的具体数据,转换成Stream流对象
        参数:
            T ... t: 可变参数   传递数组,参数列表,不传递
public class Demo05GetStream {
    public static void main(String[] args) {
        //获取List集合的Stream对象
        List<String> list = new ArrayList<>();
        Stream<String> s1 = list.stream();
        System.out.println(s1);

        //获取Set集合的Stream对象
        Set<Integer> set = new HashSet<>();
        Stream<Integer> s2 = set.stream();
        System.out.println(s2);

        Map<String,String> map = new HashMap<>();

        //Map键的Set集合
        Set<String> set2 = map.keySet();
        Stream<String> s3 = set2.stream();
        System.out.println(s3);

        //Map值的Collection集合
        Collection<String> coll = map.values();
        Stream<String> s4 = coll.stream();
        System.out.println(s4);

        //Map键值对的Set集合
        Set<Map.Entry<String, String>> set3 = map.entrySet();
        Stream<Map.Entry<String, String>> s5 = set3.stream();
        System.out.println(s5);
        System.out.println("----------");
        String[] arr = {"Hello","World","java"};
        Stream<String> s6 = Stream.of(arr);
        System.out.println(s6);

        Stream<String> s7 = Stream.of("Hello", "World", "java");
        System.out.println(s7);

    }
}

备注: of 方法的参数其实是一个可变参数,所以支持数组。

常用方法

流模型的操作很丰富,下面是一些常用的API。这些方法可以被分成两种:

  • 终结方法:返回值类型不再是 Stream 接口自身类型的方法,因此不再支持类似 StringBuilder 那样的链式调
    用。本小节中,终结方法包括 count 和 forEach 方法。
  • 非终结方法:返回值类型仍然是 Stream 接口自身类型的方法,因此支持链式调用。(除了终结方法外,其余
    方法均为非终结方法。)
forEach : 逐一处理

虽然方法名字叫 forEach ,但是与for循环中的“for-each”昵称不同,该方法并不保证元素的逐一消费动作在流中是
被有序执行的。

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

该方法接收一个 Consumer 接口函数,会将每一个流元素交给该函数进行处理。例如:

import java.util.stream.Stream;
public class Demo15StreamForEach {
public static void main(String[] args) {
    Stream<String> stream = Stream.of("大娃","二娃","三娃","四娃","五娃","六娃","七娃","爷
    爷","蛇精","蝎子精");
    //Stream<String> stream = Stream.of("张无忌", "张三丰", "周芷若");
    stream.forEach((String str)->{System.out.println(str);});
    }
}

注意,上方代码注释的原因是stream流只能被使用一次,不能循环使用

filter:过滤

可以通过 filter 方法将一个流转换成另一个子集流。方法声明:

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

该接口接收一个 Predicate 函数式接口参数(可以是一个Lambda)作为筛选条件。

基本使用

Stream流中的 filter 方法基本使用的代码如:

public class Demo16StreamFilter {
public static void main(String[] args) {
    Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
    Stream<String> result = original.filter((String s) -> {return s.startsWith("张");});
    }
}
count:统计个数

正如旧集合 Collection 当中的 size 方法一样,流提供 count 方法来数一数其中的元素个数:

public class Demo16StreamFilter {
public static void main(String[] args) {
    Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
    Stream<String> result = original.filter((String s) -> {return s.startsWith("张");});
    System.out.println(result.count()); // 2
    }
}
limit:取用前几个

limit 方法可以对流进行截取,只取用前n个。

Stream<T> limit(long maxSize):获取Stream流对象中的前n个元素,返回一个新的Stream流对象

参数是一个long型,如果集合当前长度大于参数则进行截取;否则不进行操作。

import java.util.stream.Stream;
public class Demo18StreamLimit {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream<String> result = original.limit(2);
        System.out.println(result.count()); // 2
    }
}
skip:跳过前几个

如果希望跳过前几个元素,可以使用 skip 方法获取一个截取之后的新流

Stream<T> skip(long n): 跳过Stream流对象中的前n个元素,返回一个新的Stream流对象

如果流的当前长度大于n,则跳过前n个;否则将会得到一个长度为0的空流。基本使用:

import java.util.stream.Stream;
public class Demo19StreamSkip {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream<String> result = original.skip(2);
        System.out.println(result.count()); // 1
    }
}
concat:组合

如果有两个流,希望合并成为一个流,那么可以使用 Stream 接口的静态方法 concat :

static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b): 把参数列表中的两个
Stream流对象a和b,合并成一个新的Stream流对象

备注:这是一个静态方法,与 java.lang.String 当中的 concat 方法是不同的。

该方法的基本使用代码如:

import java.util.stream.Stream;
public class Demo20StreamConcat {
    public static void main(String[] args) {
        Stream<String> streamA = Stream.of("张无忌");
        Stream<String> streamB = Stream.of("张翠山");
        Stream<String> result = Stream.concat(streamA, streamB);
    }
}
知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议

发表评论

email
web

全部评论 (暂无评论)

info 还没有任何评论,快来留言吧!