集美大学 计算机 郑如滨

教学博客

  博客园 :: 首页 :: 博问 :: 闪存 :: 新随笔 :: 联系 :: 订阅 订阅 :: 管理 ::

1.Lambda表达式与接口之间的关系

只要Lambda表达式的声明形式与接口相一致,在很多情况下都可以替换接口。见如下代码

Thread t1 = new Thread(new Runnable() {
    public void run() {
        System.out.println("hi");
    }
});
t1.start();

Thread t2 = new Thread(() -> System.out.println("hi"));
t2.start();

t1与t2完成相同的功能。t2中的Lambda表达式() -> System.out.println("hi")Runnable接口中的方法public abstract void run();的形式一样:

  1. 没有返回值。
  2. 没有传入参数。

下面一个例子中

String[] arr = {"111","22","3"};
Arrays.sort(arr,new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return o1.length()-o2.length();
    }
});

Arrays.sort(arr, (o1,o2)->o1.length()-o2.length());

(o1,o2)->o1.length()-o2.length()的形式与Compartor中public int compare(String o1, String o2) 形式也一样:

  1. 两个入参。
  2. 一个返回值,且返回值为int类型。

2.Lambda表达式、匿名内部类与this

Lambda表达式在用法上看起来很像匿名内部类,但其并不是匿名内部类。比如,在以下代码中,在Lambda表达式中不能获得this。

Thread t1 = new Thread(new Runnable() {
    public void run() {
         System.out.println(this);//打印匿名内部类
    }
});
t1.start();

Thread t2 = new Thread(()->{
    //System.out.println(this);//无法编译通过
});
t2.start();

观察如下代码,会发现Lambda表达式中的this与所处环境有关,在这里this是对外部对象的引用。

class Foo{
    Runnable r1 =  ()->{
       System.out.println(this);
    };
    Runnable r2 =  ()->{
        System.out.println(this);
     };
    
    void test(){
        r1.run();
        r2.run();
    }
}
//测试代码如下
Foo foo = new Foo();
System.out.println(foo);
foo.test();

从输出可以看出,输出了三个对象实际上是同一个对象。

Foo@87aac27
Foo@87aac27
Foo@87aac27

3. 标准函数式接口与方法引用

3.1 函数式接口

Java8中为Iterable引入了默认实现方法default void forEach(Consumer<? super T> action)。用法如下:

List<String> strs = Arrays.asList("1","222","33");  //List接口间接继承了Iterable接口,所以strs也会有forEach方法。
strs.forEach(e->System.out.println(e)); //将strs中的每个元素迭代输出

为什么可以将Lambda表达式e->System.out.println(e)作为Consumer<? super T> action类型的参数。
先看一下Consumer的代码

@FunctionalInterface
public interface Consumer<T> {
     void accept(T t);
     //其他代码
}

可以看到void accept(T t)e->System.out.println(e)形式上是一致的,所以可以将该Lambda表达式作为输入参数。
注意:这里使用了@FunctionalInterface标注该结构为函数式接口。也可以自己创建函数式接口。但要注意函数接口只能有一个抽象方法
如下代码可以通过:

@FunctionalInterface
interface MyFuncInterface{
	void test();
}

但如下代码却无法编译通过

@FunctionalInterface
interface MyFuncInterface{
	void test();
	void test1();
}

JDK中大量使用了几个常用的标准函数接口。如下所示:

public interface Consumer<T> {//无返回值,消费传入的T。可接受e->System.out.println(e)或System.out::println
    void accept(T t);
    //其他代码
}
public interface Function<T, R> {//将t转化为r。可接受e->Integer.parseInt或Integer::parseInt,将String类型转化为int
    R apply(T t);
    //其他代码
}
public interface Predicate<T> {//根据传入t判断真假。可接受x->x>3或String::equals(与传入String对象比较,返回True或False)
    boolean test(T t);
    //其他代码
}
public interface Supplier<T> {//无输入参数,直接获取T。可接受()->Arrays.asList("1","2","3"}或
    T get();
}

3.2 方法引用

前面出现的System.out::println就是方法引用。下面的代码中,strs.forEach的入参类型为Consumer<? super T> action
前面已经提到可以使用e->System.out.println(e)作为入参,同时我们知道System.out.println方法签名中返回值为void、
无入参也符合要求,所以我们可以使用System.out::println来替代e->System.out.println(e)。注意:要使用::来引用相关
的方法。
···
List strs = Arrays.asList("1","222","33");
strs.forEach(e->System.out.println(e));
strs.forEach(System.out::println);
···
方法引用不仅可以引用jdk中已有类的方法,还可以引用自定义类的相关方法。比如:

class Foo{
	<T> void myPrintX(T t) { //必须创建Foo对象才能对非static进行方法引用
		System.out.println("x="+t);
	}
	
	static <T> void myPrint(T t) {
		System.out.println("element="+t);
	}
}


//测试代码
List<String> strs = Arrays.asList("1","222","33");
strs.forEach(Foo::myPrint);
strs.forEach(new Foo()::myPrintX);

输出结果为

element=1
element=222
element=33
x=1
x=222
x=33

4.Lambda、方法引用、标准函数接口与Stream

从Java 8起,可以将集合中数据放入流并进行管道式操作。
管道式操作包含3部分:

  1. 数据源(集合、数组等)
  2. 0个或多个中间操作(filter、map等)
  3. 终端操作(forEach、collect、average, sum, min, max, and count)。

中间操作产生的还是流,那么通过filter得到的流还可以继续进行filter。
终端操作产生的就不是流了(可能是一个List、Map或int等),对一个流进行终端操作后,就不能在进行任何其他中间操作。
对一个流一旦进行完终端操作,就不能再进行中间操作,运行如下代码

List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream1 = intList.stream().filter(e->e>3);
stream1.forEach(System.out::println);
Stream<Integer> stream2 = stream1.filter(e->e>4);
stream2.forEach(System.out::println);

会提示stream has already been operated upon or closed

4.1 stream的的filter、map方法与Predicate、Function接口

Predicate接口(boolean test(T t))的作用是根据传入参数t判断真假。
Function接口(R apply(T t);)的作用是将T类型的t转换成R类型。
观察如下代码:

List<String> strs = Arrays.asList("1","222", null, "33");
Stream<Integer> stream = strs.stream().filter(e -> e != null).map(Integer::parseInt);
stream.forEach(e -> System.out.println(1 + e));

输出

2
223
34

其中strs.stream().filter(e->e!=null)的filter方法声明如下Stream<T> filter(Predicate<? super T> predicate);,即这里需要一个
Predicate<? super T> predicate类型的参数。前面可以看到Predicate接口中的方法为boolean test(T t);,即接受一个t返回
boolean值。e->e!=null符合这样的要求。
strs.stream().filter(e->e!=null).map(Integer::parseInt);中的map方法声明如下
Stream<R> map(Function<? super T, ? extends R> mapper)
即这里需要一个Function<? super T, ? extends R> mapper)类型的参数。前面可以看到Function接口中的方法为R apply(T t);
即接受一个类型为T的元素,将其转换为元素R。在这里实际上就是将String类型元素转化成int类型元素。Integer::parseInt刚好
符合这种要求。

4.2 Optional中map方法与Function接口

从刚才的例子中,我们可以看Function接口的作用可以将一个类型的转换成另外一个类型。比如

Student s1 = new Student("zhang san");
String name = s1.getName(); //对应的方法引用是Student::getName()

中Student::getName()相当于Student类型转换成String类型。
如下代码中,一个Course有很多Student(stuList),每个Student有都可以getName()。现在想要获取该Course中某个学生的姓名。
以往的代码如果使用course.getStuList().get(i).getName()来获取某个学生的姓名,看起来代码风格固然流畅,然而却没有正确处理:
course1为null,get(i)为null,getName为null的情况。那么必须在整个处理过程编写大量的判断null的代码。
可以使用Optional进行改进,即保持了流畅的编码风格,又可以正确处理null。
以下代码中:Optional.ofNullable方法可以将给定值转化为Optional类型(可包含代表给定值的Optional对象,也可包含代表null的Optional对象)

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
class Student{
	private String name;

	public String getName() {
		return name;
	}

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

	public Student(String name) {
		this.name = name;
	}
	
}
class Course{//课程
	private String name;
	private List<Student> stuList;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void addStudent(Student... stus) {
		for (Student student : stus) {
			stuList.add(student);
		}	
	}
	public Student getStu(int i) {
		return stuList.get(i);
	}
	public List<Student> getStuList() {
		return stuList;
	}
	
	public Course(String name) {
		this.name = name;
		stuList = new ArrayList<>();
	}
	
}

public class TestOptional {
	public static void main(String[] args) {
		Course course = new Course("数学");
		Student s0 = new Student("s1");
		Student s1 = new Student(null);
		Student s2 = null;
		course.addStudent(s0, s1, s2);
		String result = findStudent(course, 0);// orElse,当处理过程中过程中有一个null时,即返回orElse中的值
		System.out.println("均不为空情况下姓名为:" + result);
		result = findStudent(course, 1);
		System.out.println("student的name为null的情况:" + result);
		result = findStudent(course, 2);
		System.out.println("student为null的情况:" + result);
		Course courseNull = null;
		result = findStudent(courseNull, 3);
		System.out.println("course为null的情况:" + result);
	}

	private static String findStudent(Course course, int i) {
		Optional<Course> courseNullable = Optional.ofNullable(course);
		String result = courseNullable.map(e -> e.getStu(i)).map(Student::getName).orElse("查询不到");
		return result;
	}
}

注意:

  1. Optional的map方法入参为Function类型,所以map(e->e.getStu(0))map(Student::getName)形式均可执行。
  2. Optional的map方法返回值为Optional类型,所以可以以链式风格map(e->e.getStu(2)).map(Student::getName)流畅的编写对应代码。
  3. 该例子中不考虑stuList为null的情况,因为只要创建了Course,默认就创建了stuList。
  4. 这里没有对不同种的null情况(student为null,course为null)进行处理,返回的结果统一是查询不到,会造成理解上的混淆。

4.3 stream的mapToInt方法与ToIntFunction函数式接口

List<String> strs = Arrays.asList("1", "222", null, "33");
IntStream intStream = strs1.stream().filter(e -> e != null).mapToInt(e -> e.length());
intStream.forEach(System.out::println);

mapToInt(e -> e.length())的mapToInt方法参数类型为ToIntFunction<? super T> mapper,查询源代码ToIntFunction包含方法
int applyAsInt(T value);,即需要一个方法接受T类型输入参数,然后将其转化为int。在这里,e -> e.length()起到了这个作用。
代码的作用就是要将求得流中每个非null的字符串的长度,然后放入intStream中。

4.4 stream的reduce方法与BinaryOperator函数式接口

int[] arr = {1,2,3,4,5};
int x = 0;
for (int i = 0; i < arr.length; i++) {
    x = x + arr[i];
}
System.out.println(x);

这段代码每回从数组中取出一个元素,然后与前一个元素相加。最后求的所有元素值的和。这类操作经常使用,可以使用stream中的
reduce方法来简化实现。

List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> intStream1 = intList.stream();
Optional<Integer> result = intStream1.reduce((a, b) -> a + b);
Integer integer = result.get();
System.out.println(integer);// 15

intStream1的reduce方法入参为BinaryOperator其继承自接口BiFunction,内有一方法R apply(T t, U u);,将传入参t与u进行运算,
然后返回一个结果。(a,b)->a+b就满足如此行事,其中a最开始为流中第1个元素,b为第2个元素,a+b以后再赋给a,然后b为第3个元
素,依次类推。
reduce方法还有另外一种形式,可以指定初始值,如下述代码指定迭代开始的初始值为10,即a开始为10,b为流中第1个元素 。然后
将a+b放入a,b为流中第2个元素,然后依次类推。

Integer x = intList.stream().reduce(10, (a, b) -> a + b);
System.out.println(x);

输出

25

其中的reduce(10, (a, b) -> a + b)类型为T reduce(T identity, BinaryOperator<T> accumulator);,可以看到该方法的返回值由identity的类型决定,
在这里由10来决定,即返回值类型应为Integer。

4.4 使用Supplier接口生成流

Supplier接口(提供者)的定义如下

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

可以看到,其通过get方法返回一个对象。我们可以将Supplier当作一个生成某个对象的工厂。
为了对流进行一些管道操作的实验,且因为流不能反复操作,我们需要不断生成内部元素完全相同的流。
如下代码中,通过Supplier<Stream<Integer>> factory = () -> Stream.of(1, 2, 3, 4, 5);声明Supplier类型变量
factory,通过该factory的get方法就可以不断生成流,实际上就是不断调用() -> Stream.of(1, 2, 3, 4, 5);。而
这段() -> Stream.of(1, 2, 3, 4, 5);Lambda表达式形式上是与Supplier标准函数式接口是一致:无入参,有一个返回值。

Supplier<Stream<Integer>> factory = () -> Stream.of(1, 2, 3, 4, 5);
Stream<Integer> stream1 = factory.get();
Stream<Integer> stream2 = factory.get();
System.out.println(stream1 == stream2); // false

4.5 流的扁平化-flatmap

如何抽取二维数组Integer[][] arr1 = {{1,2},{2,3}}每个元素(排除掉重复的元素),即将1、2、3抽取出来?
可以使用flatmap方法。

Integer[][] arr1 = {{1,2},{2,3}};
Stream<Integer[]> t1 = Arrays.stream(arr1);//流中每个元素是一行(一维数组)
Stream<Integer> flatMap = t1.flatMap(Arrays::stream);//扁平化处理后,流中的每一个元素是一个Integer
flatMap.distinct().forEach(System.out::println); //distinct()排除掉重复的元素

不过这种方法对基本类型数组,如int[][]就不起作用。不知道为何?
更多参考资料见:

结论

本文使用了几个例子展示了Java 8中常用函数式接口在流的管道操作中的应用,Lambda表达式、方法引用与函数式接口之间的关系。希望大家以后在使用流的管道操作时,可以知其然也知其所以然。

参考资料:

Java学习笔记(第8版) 林信良
Java Tutorial中的Lambda ExpressionsAggregate Operations
Java 8 Stream Tutorial

posted on 2018-11-24 13:11  zhrb  阅读(521)  评论(0编辑  收藏  举报