-
2018-06-06 11:13:14
List<Integer> numbers = new ArrayList<>(); //no.1 numbers.forEach((Integer integer) -> { System.out.println(integer); }); //no.2 numbers.forEach(integer -> { System.out.println(integer); }); //no.3 numbers.forEach(integer -> System.out.println(integer)); //no.4 numbers.forEach(System.out::println); //no.5 numbers.forEach(new MyConsumer());//基于MyConsumer类
MyConsumer类如下,主要是接口的实现 class MyConsumer implements Consumer<Integer>{ @Override public void accept(Integer integer) { System.out.println(integer); } }
更多相关内容 -
JDK8新特性
2020-01-14 10:44:01JDK8是Java升级变化最大的一个版本,JDK8引入很多新的写法,比如函数式接口、Lambda表达式、Stream函数式操作流元素集合、接口的默认方法、接口的静态方法等。 JDK8是Java升级变化最大的一个版本,JDK8引入很多新的... -
JDK8新特性——Stream.pdf
2020-08-06 08:46:20借鉴前人经验,在经过不断实践之后,将Strean流部分方法整理成适合于自身需要的文档,供大家借鉴分享。 -
jdk8新特性
2017-11-22 09:26:00jdk8新特性,百度云盘。jdk8新特性,百度云盘。jdk8新特性,百度云盘。 -
JDK8 新特性学习.rar
2020-01-19 16:31:28如果你不会JDK1.8的新特性,这部资料绝对物超所值,里面有JDK1.8新特性的入门文档,还有自己整理的性能对比等给同事学习分享笔记,看完学习稍微实践一下,就可以完成入门到上手了,纯干货,5分不贵哈。 -
JDK5,JDK8新特性.ppt .ppt
2022-01-03 12:20:05参考使用,欢迎下载 -
jdk8新特性demo
2020-01-15 15:32:51jdk8新特性演示demo,主要包含lambda表达式的使用,方法引用的使用,stream流式操作的使用等演示demo,然后就么有了 -
深入浅析JDK8新特性之Lambda表达式
2020-09-01 08:21:55Lambda表达式主要是替换了原有匿名内部类的写法,也就是简化了匿名内部类的写法。这篇文章主要介绍了JDK8新特性之Lambda表达式,非常不错感兴趣的朋友参考下吧 -
#JDK8新特性#JDK8新特性
2022-06-10 11:57:40JDK8新特性 -
jdk8新特性.zip
2019-09-29 15:44:41JDK1.8已经发布很久了,在很多企业中都已经在使用。并且Spring5、SpringBoot2.0都推荐使用JDK1.8以上版本...Java8新特性如下: Lambda表达式 函数式接口 方法引用 接口的默认方法和静态方法 Optional Streams 并行数组 -
jdk8新特性例子
2014-10-23 11:40:26Jdk8新特性例子,内容包含 接口默认方法, 函数引用, java.util.stream api 和java.time api map的新增方法等。例子采用记事本编写,下载者需自行下载jdk8安装并配置好环境,编译(javac)运行(java) -
day22_JDK8新特性.pdf
2021-11-02 11:32:36day22_JDK8新特性.pdf -
一文带你入门JDK8新特性——Lambda表达式
2020-08-18 15:13:00主要介绍了JDK8新特性——Lambda表达式的相关资料,帮助大家更好的理解和学习JAVA开发,感兴趣的朋友可以了解下 -
JDK8新特性之判空遍历写法
2020-08-25 11:49:39主要介绍了JDK8新特性之判空遍历写法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧 -
jdk8新特性以及代码示例
2016-02-06 20:46:07jdk8新特性,有兴趣的同学可以下载看看 -
JDK8核心新特性
2021-06-20 20:02:08JDK8已经发行有几年了,在该版本中推出了不少新特性,其中比较有代表的新特性有:Lambda表达式,Stream流,方法引用。在网上也有很多关于这些新特性的介绍,但个人觉得网上的很多文字对新特性的介绍是不够全面的,... -
jdk8新特性.md
2020-04-15 20:41:34jdk8相关特性使用的说明文档 -
Java JDK8新特性Lambda表达式
2022-03-14 13:38:49jdk8 自定义了简单的四个函数式接口: @FunctionalInterface public interface Predicate { //接收一个参数t,返回boolean boolean test(T t); //创建predicate实例, predicate.and(other), 结果为 predicate.test...1.Lambda表达式
Lambd表达式可以理解为一种可传递的匿名函数。它没有名称,但有参数列表、函数主体、返回类型,还有可能会抛出异常。在package java.util中有一个接口,接着创建苹果类:
@FunctionalInterface public interface Comparator<T> { int compare(T o1, T o2); ... } public class Apple { private int weight; private String color; public Apple(int weight, String color) { this.weight = weight; this.color = color; } public int getWeight() { return weight; } public void setWeight(int weight) { this.weight = weight; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } }
匿名类的表达形式:
Comparator<Apple> appleComparator = new Comparator<Apple>() { @Override public int compare(Apple o1, Apple o2) { return o1.getWeight()-o2.getWeight(); } };
Lambda表达式形式:
Comparator<Apple> appleComparator1 = (Apple apple1, Apple apple2)-> apple1.getWeight()-apple1.getWeight();
可以看到Lambda表达式更简单:
1. ()->{} 无参,{}做处理;
2.()->retrun 值; 无参,返回值;
3.(String s)->s 有参,返回值;
4.(String s)->{} 有参,做处理。
2.函数式接口
只定义一个抽象方法的接口。它就是函数式接口。@FuntionallInterface注解,表示会设计成一个函数接口,不符合规范,会编译报错。
jdk8 自定义了简单的四个函数式接口:
@FunctionalInterface public interface Predicate<T> { //接收一个参数t,返回boolean boolean test(T t); //创建predicate实例, predicate.and(other), 结果为 predicate.test(t) and other.test(t) default Predicate<T> and(Predicate<? super T> other); //创建predicate实例, predicate.or(other), 结果为 predicate.test(t) or other.test(t) default Predicate<T> or(Predicate<? super T> other); //创建predicate实例, predicate.negate() 结果为 !predicate.test(t) default Predicate<T> negate() // Predicate.isEuqal("true").test("true") static <T> Predicate<T> isEqual(Object targetRef) }
对应的测试结果:
Predicate<String> predicate1=s->Boolean.parseBoolean(s); System.out.println(predicate1.test("true")); //true System.out.println(predicate1.and(s -> Boolean.parseBoolean(s)).test("false"));//false System.out.println(predicate1.or(s -> Boolean.parseBoolean(s)).test("false"));//false System.out.println(predicate1.negate().test("true"));//false System.out.println(Predicate.isEqual("true").test("true"));//true
@FunctionalInterface public interface Consumer<T> { //接受一个参数t void accept(T t); //创建一个consumer实例, consumer.andThen(after) 结果 先运行consumer.accept(t) ,接着运行 after.accept(t) default Consumer<T> andThen(Consumer<? super T> after); }
对应的测试结果:
Consumer<String> consumer= s-> System.out.println(s+"1"); consumer.accept("1");//11 consumer.andThen(s-> System.out.println(s+"2")).accept("1");//输出11 换行12
@FunctionalInterface public interface Function<T, R> { //输入t,返回r R apply(T t); //创建一个function实例, r= function.compose(before) 的结果 t = before.apply(v); r=function.apply(t) default <V> Function<V, R> compose(Function<? super V, ? extends T> before); //创建一个function实例, r=function.andThen(after) 的结果 v = function.apply(t); r=after.apply(v) default <V> Function<T, V> andThen(Function<? super R, ? extends V> after); //t = Function.identity().apply(t) static <T> Function<T, T> identity() { return t -> t; } }
对应的测试结果:
Function<String,String> function = s-> s+"1"; System.out.println(function.apply("1"));//11 System.out.println(function.andThen(s -> s + "2").apply("1"));//112 System.out.println(function.compose(s -> s + "2").apply("1"));//121 System.out.println(Function.identity().apply("1"));//1
@FunctionalInterface public interface Supplier<T> { //返回T类型 T get(); }
对应的测试结果:
Supplier<String> supplier = ()->"1"; System.out.println(supplier.get());//1
3.方法引用
3.1 类名::静态方法名
3.2 instance::instance方法名
3.3 类名::instance方法名
3.4 类名::new
[1]: Java8 实战 java 8 in Action Mario Fusco 著 Alan Mycroft 陆明刚 劳佳 译
-
explorejdk8:JDK 8 新特性的示例代码
2021-07-02 06:59:35探索jdk8 JDK 8 新特性的示例代码。 -
jdk8新特性代码
2016-06-30 16:01:36jdk8新特性 -
jdk8 新特性之 List 排序
2020-05-10 23:02:48jdk8 -> Lambda 循环打印println -> list.forEach(System.out::println); 1、jdk8 -> 之前的排序(升序) Collections.sort(list, new Comparator<User>() { @Override public int com一、排序示例
- 升序–> 从小到大
- 降序–> 从大到小
- age --> 排序字段
- jdk8 -> Lambda 循环打印println ->
list.forEach(System.out::println)
;
1、jdk8 -> 之前的排序(升序)
Collections.sort(list, new Comparator<User>() { @Override public int compare(User o1, User o2) { return o1.getAge().compareTo(o2.getAge()); } });
2、jdk8 -> Lambda排序(升序)
// 不带参 list.sort((u1, u2) -> u1.getAge().compareTo(u2.getAge())); // 带参 list.sort((User u1, User u2) -> u1.getAge().compareTo(u2.getAge()));
3、jdk8 -> Comparator 提供的静态方法排序( 升序)
Collections.sort(list, Comparator.comparing(User::getAge));
4、jdk8 -> Comparator 提供的静态方法排序( 降序).reversed()
Collections.sort(list, Comparator.comparing(User::getAge).reversed());
5、jdk8 -> 组合排序
支持每个排序字段的结尾添加.reversed() 改为降序
// Age-升序 Name-升序 Collections.sort(list, Comparator.comparing(User::getAge).thenComparing(User::getName)); // Age-升序 Name-降序 Collections.sort(list, Comparator.comparing(User::getAge).thenComparing(User::getName).reversed()); // Age-降序 Name-升序 Collections.sort(list, Comparator.comparing(User::getAge).reversed() .thenComparing(User::getName)); // Age-降序 Name-降序 Collections.sort(list, Comparator.comparing(User::getAge).reversed() .thenComparing(User::getName).reversed());
二、完整测试代码参考
package com.ws.ldy.common.utils; import lombok.AllArgsConstructor; import lombok.Data; import java.io.Serializable; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; public class JDK8ListSort { public static void main(String[] args) { // TODO jdk8 之前的排序 System.out.println("============jdk8 之前的排序"); List<User> list = initList(); Collections.sort(list, new Comparator<User>() { @Override public int compare(User o1, User o2) { return o1.getAge().compareTo(o2.getAge()); } }); list.forEach(System.out::println); // TODO jdk8 lambda 排序-升序 System.out.println("============jdk8 lambda排序,升序排序 --> 从小到大"); list = initList(); list.sort((u1, u2) -> u1.getAge().compareTo(u2.getAge())); //不带参 带参: list.sort((User u1, User u2) -> u1.getAge().compareTo(u2.getAge())); list.forEach(System.out::println); // TODO jdk8 升序排序 System.out.println("============jdk8 升序排序 --> 从小到大,Comparator提供的静态方法"); list = initList(); Collections.sort(list, Comparator.comparing(User::getAge)); list.forEach(System.out::println); // TODO jdk8 降序排序 System.out.println("============jdk8 降序排序 --> 从大到小,Comparator提供的静态方法"); list = initList(); Collections.sort(list, Comparator.comparing(User::getAge).reversed()); list.forEach(System.out::println); System.out.println(); // TODO jdk8 组合排序 System.out.println("============jdk8 组合排序,Comparator提供的静态方法,先按年纪排序,年纪相同的按名称排序"); list = initList(); Collections.sort(list, Comparator.comparing(User::getAge).thenComparing(User::getName)); list.forEach(System.out::println); } /** * TODO 初始化List数据 * * @return java.util.List<com.ws.ldy.common.utils.JDK8ListSort.User> * @author ws * @mail 1720696548@qq.com * @date 2020/5/10 0010 22:49 */ private static List<User> initList() { List<User> list = new ArrayList<>(); list.add(new User("lisa", 23)); list.add(new User("tom", 11)); list.add(new User("john", 16)); list.add(new User("jennis", 26)); list.add(new User("tin", 26)); list.add(new User("army", 26)); list.add(new User("mack", 19)); list.add(new User("jobs", 65)); return list; } /** * TODO 测试对象 * * @author ws * @mail 1720696548@qq.com * @date 2020/5/10 0010 22:49 */ @Data @AllArgsConstructor public static class User implements Serializable { private String name; private Integer age; } }
-
JDK8新特性(二):JDK8接口增强
2020-01-03 18:25:47在JDK8之前,JDK规定接口中只能定义 ①静态常量 ②抽象方法 修饰词 interface 接口名{ 静态常量; 抽象方法; } 在JDK8之后,对接口进行了增强。我们可以在接口中定义 ①静态常量 ②抽象方法 ③默认方法 ④静态...1.接口增强
在JDK8之前,JDK规定接口中只能定义 ①静态常量 ②抽象方法
修饰词 interface 接口名{ 静态常量; 抽象方法; }
在JDK8之后,对接口进行了增强。我们可以在接口中定义 ①静态常量 ②抽象方法 ③默认方法 ④静态方法
修饰词 interface 接口名{ 静态常量; 抽象方法; 默认方法; 静态方法; }
2.为什么要对接口增强
1.为什么要引入默认方法?
实例1:我们在接口 A 中定义了个 test1() 抽象方法,现在有类 B、类 C 都实现了接口 A 。但是现在因为要接入新的需求,而这一个抽象方法明显不能够满足新需求。那么则需要在接口 A 中重新顶一个 test2() 抽象方法,此时我们发现类 B 、类 C 都因为没有实现新的抽象方法 test2() 而报错了。。。。。
实例2:JDK8 在 Map 接口中增加了 forEach 方法。按 JDK8 之前标准,定义 forEach() 方法如下所示:
public interface Map<K,V>{ ... abstract void forEach(BiConsumer<? super K, ? super V> action); }
我们通过 API 可以查询到 Map 接口的实现类如下所示:
此时,如果在 Map 接口中增加一个 forEach() 抽象方法,那么所有的这些实现类都需要来实现 forEach()方法,从而保证语法正确不报错,显然这工程量是巨大的,而且代码也会有很大的冗余。
因此,在 JDK8 时为接口新增了默认方法(default修饰),效果如下:
public interface Map<K,V>{ ... default void forEach(BiConsumer<? super K, ? super V> action){ ... } }
特性:
1.新增的默认方法实现类不必重写,可以直接使用;
2.实现类也可以根据需要重写 ---->这样就方便了接口的扩展。
2.接口静态方法
为了方便接口的扩展,JDK8 同时为接口新增了静态方法
特性:
1.接口中的静态方法,实现类既不能调用,也不能重写;(只属于接口本身)
2.只能通过接口名. (接口名+ .)的方式调用
3.默认方法、静态方法的定义
//默认方法的定义(使用 default 定义) 修饰符 interface 接口名{ 修饰符 default 返回值类型 方法名(){ 代码部分; } } //静态方法的定义(使用 static 修饰) 修饰符 interface 接口名{ 修饰符 static 返回值类型 方法名(){ 代码部分; } }
4.默认方法 和 静态方法 的区别
1.默认方法通过实例调用,静态方法通过接口名调用
2.默认方法可以被继承,实现类可以直接使用接口默认方法,也可以重写接口默认方法
3.静态方法不能被继承,实现类不能重写接口静态方法,只能使用接口名调用。
5.Demo(这很简单,Demo就省了)
谢谢
附:JDK8新特性(目录)
本目录为 JDK8新特性 学习目录,包含JDK8 新增全部特性的介绍。
如需了解,请跳转链接查看:我是跳转链接
博主写作不易,来个关注呗
求关注、求点赞,加个关注不迷路 ヾ(◍°∇°◍)ノ゙
博主不能保证写的所有知识点都正确,但是能保证纯手敲,错误也请指出,望轻喷 Thanks♪(・ω・)ノ
-
jdk8新特性之for循环
2019-03-29 11:41:21jdk8新特性之for循环 1.首先遍历一个List 方式1.一开始是这样的: 1 public static void test1(List list) { 2 for (int i = 0; i < list.size(); i++) { 3 System.out.println(list.get(i)); 4 } 5 } 方式2.... -
JDK8新特性-Map遍历比较
2018-11-05 13:11:30菜鸟教程,有很多入门教程 1、案例 ... import java.util.HashMap; import java.util.Map;...import java.util.stream.Collectors;... * JDK8新特性,stream流,Map集合遍历 * Created by Tiger o...