文档章节

Java 8 新特性,Lambda,方法引用,Stream,Optional

ashuo
 ashuo
发布于 07/10 09:17
字数 2080
阅读 95
收藏 25

在C++、Python等语言里都有Lambda表达式,Java 8也新增了这一特性。

在java给变量赋值是这样的:

int num=123;
String str="hello world!";
Boolean flag=str.startsWith("h");

如果你想把“一块代码”赋给一个Java变量,应该怎么做呢?

比如,我想把右边那块代码,赋给一个叫做aBlockOfCode的Java变量

aBlockOfCode=public void doSomeShit(String s){
               System.out.println(s);
             }

在Java 8之前,这个是做不到的。但是Java 8问世之后,利用Lambda特性,就可以做到了,下面我们一步步简化

 

这样,我们就成功的非常优雅的把“一块代码”赋给了一个变量。而“这块代码”,或者说“这个被赋给一个变量的函数”,就是一个Lambda表达式

 

但是这里仍然有一个问题,就是变量aBlockOfCode的类型应该是什么?

在Java 8里面,所有的Lambda的类型都是一个接口,而Lambda表达式本身,也就是”那段代码“,需要是这个接口的实现。这是我认为理解Lambda的一个关键所在,简而言之就是,Lambda表达式本身就是一个接口的实现。直接这样说可能还是有点让人困扰,我们继续看看例子。我们给上面的aBlockOfCode加上一个类型:

 

这种只有一个接口函数需要被实现的接口类型,我们叫它”函数式接口“。为了避免后来的人在这个接口中增加接口函数导致其有多个接口函数需要被实现,变成"非函数接口”,我们可以在这个上面加上一个声明@FunctionalInterface, 这样别人就无法在里面添加新的接口函数了:

@FunctionalInterface
public interface MyLambdaInterface {
	void doSomeShit(String s);
}


这样,我们就得到了一个完整的Lambda表达式声明:

public void test(){
        MyLambdaInterface aBlockOfCode= (s) -> System.out.println(s);
}

 

在Java 7之前都是这样接口的实现是这样

public class MyInterfaceImpl implements MyLambdaInterface{

	@Override
	public void doSomeShit(String s) {
		System.out.println(s);
	}
	
}

 

这两种写法本质上是等价的。但是显然,Java 8中的写法更加优雅简洁。并且,由于Lambda可以直接赋值给一个变量,我们就可以直接把Lambda作为参数传给函数, 而传统的Java必须有明确的接口实现的定义,初始化才行

public static void enact(MyLambdaInterface myLambda,String s){
		myLambda.doSomeShit(s);
}
public static void main(String[] args) {
		enact(s -> System.out.println(s) ,"myLambda");
		System.out.println("执行");
}

执行结果:

myLambda
执行

 

Lambda结合FunctionalInterface Lib, forEach, stream(),method reference等新特性可以使代码变的更加简洁!

假设Person的定义和List<Person>的值都给定

public class Person {

	private String firstName;
	
	private String lastName;
	
	private int age;

	public Person(String lastName, String firstName,int age) {
		this.lastName = lastName;
		this.firstName = firstName;
		this.age = age;
	}
    ...省略getset
}
List<Person> guiltyPersons=Arrays.asList(
				new Person("Yixing", "Zhao",25),
				new Person("Yanggui", "Li",30 ),
				new Person("Chao", "Ma", 29)
				);

现在需要你打印出guiltyPersons List里面所有LastName以"Z"开头的人的FirstName。

原生态Lambda写法:定义两个函数式接口,定义一个静态函数,调用静态函数并给参数赋值Lambda表达式。

@FunctionalInterface
public interface NameChecker {
	boolean check(Person p);
}
@FunctionalInterface
public interface Executor {
	void execute(Person p);
}
public static void checkAndExecute(List<Person> personList,NameChecker nameChecker,Executor executor ){
		for (Person person : personList) {
			if(nameChecker.check(person)){
				executor.execute(person);
			}
		}
}
public class Test {

	public static void main(String[] args) {
		enact(s -> System.out.println(s) ,"myLambda");
		System.out.println("执行");
		
		List<Person> guiltyPersons=Arrays.asList(
				new Person("Yixing", "Zhao",25),
				new Person("Yanggui", "Li",30 ),
				new Person("Chao", "Ma", 29)
				);
		
		checkAndExecute(guiltyPersons,p -> p.getFirstName().startsWith("Z") , p -> System.out.println(p.getFirstName()));
	}

执行结果:

myLambda
执行
Zhao

这个代码实际上已经比较简洁了,但是我们还可以更简洁么?

 

当然可以。在Java 8中有一个函数式接口的包,里面定义了大量可能用到的函数式接口(java.util.function (Java Platform SE 8 ))。所以,我们在这里压根都不需要定义NameChecker和Executor这两个函数式接口,直接用Java 8函数式接口包里的Predicate<T>和Consumer<T>就可以了——因为他们这一对的接口定义和NameChecker/Executor其实是一样的。

@FunctionalInterface
public interface Predicate<T> {
	boolean test(T t);
}
@FunctionalInterface
public interface Consumer<T> {
	void accept(T t);
}

第一步简化 - 利用函数式接口包:

public static void checkAndExecute(List<Person> personList,Predicate<Person> predicate,Consumer<Person> consumer){
		for (Person person : personList) {
			if(predicate.test(person)){
				consumer.accept(person);
			}
		}
}
checkAndExecute(guiltyPersons,p -> p.getFirstName().startsWith("Z") , p -> System.out.println(p.getFirstName()));

静态函数里面的for each循环其实是非常碍眼的。这里可以利用Iterable自带的forEach()来替代。forEach()本身可以接受一个Consumer<T> 参数。

第二步简化 - 用Iterable.forEach()取代foreach loop

public static void checkAndExecute(List<Person> personList,Predicate<Person> predicate,Consumer<Person> consumer){

		personList.forEach(p -> {if(predicate.test(p)) consumer.accept(p);});
}
checkAndExecute(guiltyPersons,p -> p.getFirstName().startsWith("Z") , p -> System.out.println(p.getFirstName()));

由于静态函数其实只是对List进行了一通操作,这里我们可以甩掉静态函数,直接使用stream()特性来完成。stream()的几个方法都是接受Predicate<T>,Consumer<T>等参数的(java.util.stream (Java Platform SE 8 ))。

这里解释下stream

什么是 Stream?

Stream(流)是一个来自数据源的元素队列并支持聚合操作

  • 元素是特定类型的对象,形成一个队列。 Java中的Stream并不会存储元素,而是按需计算。
  • 数据源 流的来源。 可以是集合,数组,I/O channel, 产生器generator 等。
  • 聚合操作 类似SQL语句一样的操作, 比如filter, map, reduce, find, match, sorted等。

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

  • Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道, 如同流式风格(fluent style)。 这样做可以对操作进行优化, 比如延迟执行(laziness)和短路( short-circuiting)。
  • 内部迭代: 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代, 这叫做外部迭代。 Stream提供了内部迭代的方式, 通过访问者模式(Visitor)实现。

 

第三步简化 - 利用stream()替代静态函数

public static void checkAndExecute(List<Person> personList,Predicate<Person> predicate,Consumer<Person> consumer){
		personList.stream()
							.filter(p -> p.getFirstName().startsWith("Z"))
							.forEach(p -> System.out.println(p.getFirstName()));
}

对比最开始的Lambda写法,这里已经非常非常简洁了。但是如果,我们要求变一下,变成print这个人的全部信息,及p -> System.out.println(p); 那么还可以利用方法引用通过方法的名字来指向一个方法。

方法引用可以使语言的构造更紧凑简洁,减少冗余代码。

方法引用使用一对冒号 ::

Java 中 4 种不同方法的引用

构造器引用:它的语法是Class::new,或者更一般的Class< T >::new

静态方法引用:它的语法是Class::static_method

特定类的任意对象的方法引用:它的语法是Class::method

特定对象的方法引用:它的语法是instance::method

例如:

public static void main(String[] args) {
		
		List names = new ArrayList();
        
	      names.add("Google");
	      names.add("Taobao");
	      names.add("Baidu");
	      names.add("Sina");
	        
	      names.forEach(System.out::println);
}

实例中我们将 System.out::println 方法作为静态方法来引用

第四步简化 - 如果是println(p),则可以利用方法的引用代替forEach中的Lambda表达式

personList.stream().filter(p -> p.getFirstName().startsWith("Z")).forEach(System.out::println)

 

Lambda配合Optional<T>可以使Java对于null的处理变的异常优雅

Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。

Optional 是个容器:它可以保存类型T的值,或者仅仅保存null。Optional提供很多有用的方法,这样我们就不用显式进行空值检测。

Optional 类的引入很好的解决空指针异常。

 

例如:假设我们有一个person object,对这个对象进行null判断,Java 7都是如下:

private static final Person UNKNOWN_PERSON=null;

public static Person testOptional(){
		Person person = null;
		if(person != null){
			return person;
		}else{
			return UNKNOWN_PERSON;
		}
}

Java 8 则使用Optional 特性,具体如下:

private static final Person UNKNOWN_PERSON=null;

public static Person testOptional(){
		
		Person person = null;
		// Optional.ofNullable - 允许传递为 null 参数
		Optional<Person> personOpt=Optional.ofNullable(person);
		
//		if(personOpt.isPresent()){
//			return personOpt.get();
//		}else{
//			return UNKNOWN_PERSON;
//		}
		//最后优化为最简化的
		personOpt.ifPresent(System.out::println);
		return personOpt.orElse(UNKNOWN_PERSON);
}

 

Java 8 的新特性先介绍到这里,与大家共同进步

文章参考:https://www.zhihu.com/question/20125256/answer/324121308

© 著作权归作者所有

共有 人打赏支持
ashuo
粉丝 4
博文 62
码字总数 40987
作品 0
浦东
程序员
私信 提问
加载中

评论(1)

x
xiari1990
通俗易懂,大赞
Java 11 正式发布,这 8 个逆天新特性教你写出更牛逼的代码

美国时间 09 月 25 日,Oralce 正式发布了 Java 11,这是据 Java 8 以后支持的首个长期版本。 为什么说是长期版本,看下面的官方发布的支持路线图表。 可以看出 Java 8 扩展支持到 2025 年,...

Java技术栈
09/27
0
0
Lambda 表达式有何用处?如何使用?(针对Java8)

什么是Lambda? 我们知道,对于一个Java变量,我们可以赋给其一个“值”。 如果你想把“一块代码”赋给一个Java变量,应该怎么做呢? 比如,我想把右边那块代码,赋给一个叫做aBlockOfCode的J...

亭子happy
06/06
0
0
jdk 5 到 jdk 10各个版本的新特性

jdk5 jdk10各个版本的新特性 JDK1.5新特性: 1.自动装箱与拆箱: 2.枚举 3.静态导入,如:import staticjava.lang.System.out 4.可变参数(Varargs) 5.内省(Introspector),主要用于操作J...

程序员诗人
03/21
0
0
JDK8实践--Java 8系列之Stream的基本语法详解

Stream系列: Java 8系列之Stream的基本语法详解 Java 8系列之Stream的强大工具Collector Java 8系列之重构和定制收集器 Java 8系列之Stream中万能的reduce 概述 继Java 8系列之Lambda表达式...

spinachgit
01/09
0
0
Java 9 新特性 极简介绍

1. Java 平台级模块系统 Java 9 的定义功能是一套全新的模块系统。当代码库越来越大,创建复杂,盘根错节的“意大利面条式代码”的几率呈指数级的增长。这时候就得面对两个基础的问题: 很难真...

程序员诗人
2017/09/16
0
0

没有更多内容

加载失败,请刷新页面

加载更多

RabbitMQ+PHP 教程三(Publish/Subscribe)用yii2测试通过

介绍 在前面的教程中,我们创建了一个工作队列。工作队列背后的假设是每个任务都交付给一个工作人员处理。在这一部分中,我们将做一些完全不同的事情——我们将向多个消费者发送消息。此模式...

hansonwong
23分钟前
2
0
关于JAVA你必须知道的那些事(四):单例模式和多态

好吧,今天一定要把面向对象的最后一个特性:多态,给说完。不过我们先来聊一聊设计模式,因为它很重要。 设计模式 官方的解释是,设计模式是:一套被反复使用,多数人知晓的,经过分类编目,...

拾光TM
23分钟前
1
0
ES6 系列之 Babel 是如何编译 Class 的(下)

摘要: ## 前言 在上一篇 [《 ES6 系列 Babel 是如何编译 Class 的(上)》](https://github.com/mqyqingfeng/Blog/issues/105),我们知道了 Babel 是如何编译 Class 的,这篇我们学习 Babel ...

阿里云官方博客
24分钟前
1
0
附实例!实现iframe父窗体与子窗体的通信

欢迎大家前往腾讯云+社区,获取更多腾讯海量技术实践干货哦~ 本文由前端林子发表于云+社区专栏 本文主要会介绍如何基于MessengerJS,实现iframe父窗体与子窗体间的通信,传递数据信息。同时本...

腾讯云加社区
30分钟前
1
0
JSP页面传List集合到Action中

1:JSP页面(前端用的是H-UI框架) <div class="codeView docs-example"> <table class="table table-border table-bordered table-striped"> <thead> ......

uug
34分钟前
4
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部