Java8新特性

Java8新特性
接口中默认方法修饰为普通方法#
在jdk8之前,interface之中可以定义变量和方法,变量必须是public、static、final的,方法必须是public、abstract的,由于这些修饰符都是默认的。
接口定义方法:public 抽象方法 需要子类实现
接口定义变量:public、static、final
在JDK 1.8开始 支持使用static和default 修饰 可以写方法体,不需要子类重写。
方法:
普通方法 可以有方法体
抽象方法 没有方法体需要子类实现 重写。
案例
public interface JDK8Interface {

/* * 默认就是public abstractJDK7之前不能有方法体 * */ void add(); /* * jdk8 提供默认实现 * */ default voidget() { System.out.println("default方法可以写方法体"); }static void getStaticOrder() { System.out.println("静态方法可以写方法体"); }

}
子类实现接口
public class JDK8InterfaceImpl implements JDK8Interface {
/* * 子类实现接口 没有强制要求重写default和static方法 * */ @Override public void add() { System.out.println("add方法"); }

}
方法调用
public class Test01 {
public static void main(String[] args) { JDK8Interface jdk8Interface=new JDK8InterfaceImpl(); jdk8Interface.add(); jdk8Interface.get(); JDK8Interface.getStaticOrder(); }

}
image-20211018202027296
Lambda表达式#
是一个匿名函数,简化我们调用匿名函数的过程
Lambda好处: 简化我们匿名内部类的调用。
Lambda+方法引入 代码变得更加精简。
public static void main(String[] args) { //使用匿名内部类的方式调用

// new OrderService(){
// @Override
// public void addOrder() {
// System.out.println("addorder");
// }
// }.addOrder();
((OrderService) () -> System.out.println("addorder")).addOrder();

// new Thread(new Runnable() {
// @Override
// public void run() {
// System.out.println(Thread.currentThread().getName()+"运行");
// }
// }).start();
new Thread(() -> System.out.println(Thread.currentThread().getName()+"运行")).start(); }

Lambda表达式的规范#
使用Lambda表达式 依赖于函数接口
在接口中只能够允许有一个抽象方法
在函数接口中定义object类中方法
使用默认或者静态方法
@FunctionalInterface 表示该接口为函数接口
Java中使用Lambda表达式的规范,必须是为函数接口
函数接口的定义:在该接口中只能存在一个抽象方法,该接口称作为函数接口
@FunctionalInterface
public interface MyFunctionalInterface {
voidget(); default void add() {} String toString();

}
常见例如Runnable接口
image-20211018221019469
方法调用
public static void main(String[] args) { ((MyFunctionalInterface) () -> System.out.println()).get(); }

Lambda基础语法#
()--参数列表
-> 分隔
{} 方法体
(函数接口的参数列表 不需要写类型 需要定义参数名称)->{方法体}
无参方法调用#
@FunctionalInterface
public interface MyFunctionalInterface {
voidget();

}
MyFunctionalInterface myFunctionalInterface= ()->{
System.out.println("使用lambda表达式");

};
有参带返回值调用#
@FunctionalInterface
public interface YouFunctionalInterface {
String get(int i,int j);

}
public static void main(String[] args) { YouFunctionalInterface youFunctionalInter=(i, j)->{ return i+"--"+j; }; System.out.println(youFunctionalInter.get(1, 1)); }

精简版#
public static void main(String[] args) {
//无参方法原始版本 MyFunctionalInterface functionalInterface=()->{ System.out.println(""); }; functionalInterface.get(); //精简版1 ((MyFunctionalInterface)()->{ System.out.println(""); }).get(); //精简版2 在方法体只有一条语句的时候,不需要写大括号了 MyFunctionalInterface functionalInterface2=()-> System.out.println(""); //最终精简版3 ((MyFunctionalInterface)()-> System.out.println("")).get(); //有参方法 YouFunctionalInterface youFunctionalInterface=(int i,int j)->{ return ""; }; String s = youFunctionalInterface.get(2, 3); //精简版1 YouFunctionalInterface youFunctionalInterface1=( i, j)->{ return ""; }; //精简版2 YouFunctionalInterface youFunctionalInterface2=(i, j)-> i+"--"+j; String s1 = youFunctionalInterface1.get(2, 3); //最终精简版3 String s2 = ((YouFunctionalInterface) (i, j) -> i + "--" + j).get(1, 2); System.out.println(s2); }

Lambda实战案例#
Foreach#
public static void main(String[] args) { ArrayList arrayList=new ArrayList<>(); arrayList.add("111"); arrayList.add("222"); arrayList.add("333");

// arrayList.forEach(new Consumer() {
// @Override
// public void accept(String s) {
// System.out.println(s);
// }
// });
arrayList.forEach(s->{ System.out.println(s); }); }

【Java8新特性】Lambda集合排序#
public class UserEntity {
private String name; private Integer age; public UserEntity(String name, Integer age) { this.name = name; this.age = age; }public String getName() { return name; }public Integer getAge() { return age; }@Override public String toString() { return "UserEntity{" + "name='" + name + '\'' + ", age=" + age + '}'; }

}
public static void main(String[] args) {
ArrayList userlists = new ArrayList<>(); userlists.add(new UserEntity("aa", 22)); userlists.add(new UserEntity("bb", 18)); userlists.add(new UserEntity("cc", 36)); userlists.sort(new Comparator() { @Override public int compare(UserEntity o1, UserEntity o2) { return o1.getAge()- o2.getAge(); } }); //精简遍历 userlists.forEach(s-> System.out.println(s)); //精简排序 userlists.sort((o1, o2) -> o1.getAge()- o2.getAge()); }

Java 8 stream流#
Stream 是JDK1.8 中处理集合的关键抽象概念,Lambda 和 Stream 是JDK1.8新增的函数式编程最有亮点的特性了,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作,就类似于使用SQL执行的数据库查询。Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。Stream API可以极大提高Java程序员的生产力,让程序员写出高效率、干净、简洁的代码
这种风格将要处理的元素集合看作一种流, 流在管道中传输, 并且可以在管道的节点上进行处理, 比如筛选, 排序,聚合等
img
Stream :非常方便精简的形式遍历集合实现 过滤、排序等
Stream创建方式#
parallelStream为并行流采用多线程执行
Stream采用单线程执行
parallelStream效率比Stream要高
Stream将list转换为set#
public static void main(String[] args) {
ArrayList userEntities = new ArrayList<>(); userEntities.add(new UserEntity("aa", 20)); userEntities.add(new UserEntity("bb", 28)); userEntities.add(new UserEntity("cc", 35)); userEntities.add(new UserEntity("dd", 16)); Stream stream=userEntities.stream(); Set collect = stream.collect(Collectors.toSet()); collect.forEach(s-> System.out.println(s)); }

set集合底层依赖于map 集合,map集合底层基于equals和hashcode比较防止重复
Stream将list转换为map#
public static void main(String[] args) {
ArrayList userEntities = new ArrayList<>(); userEntities.add(new UserEntity("aa", 20)); userEntities.add(new UserEntity("bb", 28)); userEntities.add(new UserEntity("cc", 35)); userEntities.add(new UserEntity("dd", 16)); /* * list集合只有keylist转换map的时候需要指定key value,key=usernamevalue=https://www.it610.com/article/user对象 * */ Stream stream=userEntities.stream(); Map collect = stream.collect(Collectors.toMap(new Function() { @Override public String apply(UserEntity o) { return o.getName(); } }, new Function() { @Override public UserEntity apply(UserEntity usrentity) { return usrentity; } })); //精简版 collect.forEach(new BiConsumer() { @Override public void accept(String s, UserEntity userEntity) { System.out.println(s+","+userEntity); } }); //最终精简版 collect.forEach((BiConsumer)(s,userEntity)->System.out.println(s+","+userEntity)); }

Stream将Reduce 求和#
public static void main(String[] args) {
Stream integerStream=Stream.of(5,6,7,8); Optional reduce = integerStream.reduce(new BinaryOperator() { @Override public Integer apply(Integer integer, Integer integer2) { return integer + integer2; } }); System.out.println(reduce); ArrayList userEntities = new ArrayList<>(); userEntities.add(new UserEntity("aa", 20)); userEntities.add(new UserEntity("bb", 28)); userEntities.add(new UserEntity("cc", 35)); userEntities.add(new UserEntity("dd", 16)); Optional sum=userEntities.stream().reduce(new BinaryOperator() { @Override public UserEntity apply(UserEntity userEntity, UserEntity userEntity2) { UserEntity userEntity1=new UserEntity("sum",userEntity.getAge()+userEntity2.getAge()); return userEntity1; } }); System.out.println(sum); }

Stream求最大最小#
public static void main(String[] args) { ArrayList userEntities = new ArrayList<>(); userEntities.add(new UserEntity("aa", 20)); userEntities.add(new UserEntity("bb", 28)); userEntities.add(new UserEntity("cc", 35)); userEntities.add(new UserEntity("dd", 16)); Stream stream=userEntities.stream(); Optional min = stream.min(new Comparator() { @Override public int compare(UserEntity o1, UserEntity o2) { return o1.getAge() - o2.getAge(); } }); System.out.println(min.get()); //简化版 Optional min1 = stream.min((o1, o2) -> o1.getAge() - o2.getAge()); System.out.println(min1.get()); }

Stream Match 匹配#
anyMatch表示,判断的条件里,任意一个元素成功,返回true
allMatch表示,判断条件里的元素,所有的都是,返回true
noneMatch跟allMatch相反,判断条件里的元素,所有的都不是,返回true
public static void main(String[] args) {
ArrayList userEntities = new ArrayList<>(); userEntities.add(new UserEntity("aa", 20)); userEntities.add(new UserEntity("bb", 28)); userEntities.add(new UserEntity("cc", 35)); userEntities.add(new UserEntity("dd", 16)); Stream stream=userEntities.stream(); boolean b = stream.anyMatch(new Predicate() { @Override public boolean test(UserEntity userEntity) { return "aa".equals(userEntity.getName()); } }); System.out.println(b); //简化版 boolean b1 = stream.anyMatch((userEntity) -> "aa".equals(userEntity.getName())); System.out.println(b1); }

Stream for循环#
public static void main(String[] args) { ArrayList userEntities = new ArrayList<>(); userEntities.add(new UserEntity("aa", 20)); userEntities.add(new UserEntity("bb", 28)); userEntities.add(new UserEntity("cc", 35)); userEntities.add(new UserEntity("dd", 16)); Stream stream=userEntities.stream(); stream.forEach((userEntity -> System.out.println(userEntity))); }

Stream filter过滤器#
public static void main(String[] args) { ArrayList userEntities = new ArrayList<>(); userEntities.add(new UserEntity("aa", 20)); userEntities.add(new UserEntity("bb", 28)); userEntities.add(new UserEntity("cc", 35)); userEntities.add(new UserEntity("dd", 16)); Stream stream=userEntities.stream(); stream.filter(new Predicate() { @Override public boolean test(UserEntity userEntity) { return "aa".equals(userEntity.getName()) && userEntity.getAge() >= 18; } }).forEach((userEntity -> System.out.println(userEntity))); //精简版 stream.filter((userEntity)->"aa".equals(userEntity.getName()) && userEntity.getAge() >= 18) .forEach((userEntity -> System.out.println(userEntity) )); }

Stream limit和skip#
Limit 从头开始获取
Skip 就是跳过
public static void main(String[] args) { ArrayList userEntities = new ArrayList<>(); userEntities.add(new UserEntity("aa", 20)); userEntities.add(new UserEntity("bb", 28)); userEntities.add(new UserEntity("cc", 35)); userEntities.add(new UserEntity("dd", 16)); Stream stream = userEntities.stream(); stream.skip(2).limit(2).forEach((userEntity -> System.out.println(userEntity))); }

stream 综合案例#
public static void main(String[] args) {
ArrayList userEntities = new ArrayList<>(); userEntities.add(new UserEntity("mayikt", 20)); userEntities.add(new UserEntity("meite", 28)); userEntities.add(new UserEntity("zhangsan", 35)); userEntities.add(new UserEntity("xiaowei", 16)); userEntities.add(new UserEntity("mayikt_list", 109)); userEntities.add(new UserEntity("mayikt_zhangsan", 110)); userEntities.add(new UserEntity("lisi", 109)); userEntities.add(new UserEntity("mayikt", 100)); userEntities.add(new UserEntity("mayikt", 60)); Stream stream=userEntities.stream(); stream.sorted((o1,o2)->o1.getAge()-o2.getAge()) .filter((userEntity -> "mayikt".equals(userEntity.getName()))) .limit(3) .forEach((userEntity)-> System.out.println(userEntity)); }

并行流与串行流区别#
串行流:单线程的方式操作; 数据量比较少的时候。
并行流:多线程方式操作;数据量比较大的时候
原理:Fork join 将一个大的任务拆分n多个小的子任务并行执行,最后在统计结果,有可能会非常消耗cpu的资源,确实可以提高效率。
注意:数据量比较少的情况下,不要使用并行流
方法引用#
什么是方法引入
方法引入:需要结合lambda表达式能够让代码变得更加精简
静态方法引入: 类名::(静态)方法名称
对象方法引入 类名:: 实例方法名称
实例方法引入 new对象 对象实例::方法引入
构造函数引入 类名::new
需要遵循一个规范:
方法引入 方法参数列表、返回类型与函数接口参数列表与返回类型必须要保持一致。
静态方法引入#
/*
  • 静态方法引入
  • */
    public class Test01 {
    public static void main(String[] args) {
    MyFunctionalInterface myFunctionalInterface = () -> { /*引入getStaticMethod方法*/ Test01.getStaticMethod(); }; myFunctionalInterface.get(); // 使用方法引入调用方法 必须满足:方法引入的方法必须和函数接口中的方法参数列表/返回值一定保持一致。 MyFunctionalInterface messageInterface = Test01::getStaticMethod; messageInterface.get();

    }
    public static void getStaticMethod() {
    System.out.println("我是 getMethod");

    }
    }
    实例对象方法引入#
    public class Test02 {
    public static void main(String[] args) {
    Test02 test02=new Test02(); MyFunctionalInterface myFunctionalInterface = () -> { /*引入getStaticMethod方法*/ test02.getStaticMethod(); }; myFunctionalInterface.get(); // 精简版 MyFunctionalInterface messageInterface = test02::getStaticMethod; messageInterface.get();

} publicvoid getStaticMethod() { System.out.println("我是 getMethod2"); }

}
构造函数引入#
public static void main(String[] args) { UserInterface userInterface=new UserInterface() { @Override public UserEntity getUser() { return new UserEntity(); } }; //精简版 UserInterface userInterface3=UserEntity::new; userInterface2.getUser(); }

对象方法引入
public class Test04 {
public static void main(String[] args) { Myservice myservice=new Myservice() { @Override public String get(Test04 test04) { return test04.objGet(); } }; Myservice myservice1=(Test04-> Test04.objGet()); //精简版传入Test04 返回string值 Myservice myservice2=Test04::objGet; Function function=new Function() { @Override public Integer apply(String s) { return s.length(); } }; //精简版 Function function2=String::length; System.out.println(function2.apply("dfdf")); }

@FunctionalInterface
public interface Myservice {
String get(Test04 userEntity);

}
JDK8Optional#
Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。
Optional 是个容器:它可以保存类型T的值,或者仅仅保存null。Optional提供很多有用的方法,这样我们就不用显式进行空值检测。
Optional 类的引入很好的解决空指针异常。
判断参数是否为空#
ofNullable(可以传递一个空对象)
Of(不可以传递空对象)
public static void main(String[] args) { String username=null; Integer a1 = 1; Optional a = Optional.ofNullable(a1); System.out.println(a.isPresent()); //trueOptional username1 = Optional.ofNullable(username); System.out.println(username1.isPresent()); //false }

isPresent表示结果返回是否为空, true 不为空,返回 false 为空
参数为空可以设定默认值#
public static void main(String[] args) { Integer a1 = null; Integer a = Optional.ofNullable(a1).orElse(10); System.out.println(a); //10 }

参数实现过滤#
public static void main(String[] args) {
Integer a1 = 16; Optional a = Optional.ofNullable(a1); //判断是否等于16 boolean present = a.filter(new Predicate() { @Override public boolean test(Integer integer) { return integer.equals(16); } }).isPresent(); System.out.println(present); //trueboolean isPresent = a.filter(a2 -> a2==17).isPresent(); System.out.println(isPresent); //false

}
与Lambda表达式结合使用,优化代码#
优化方案1#
public static void main(String[] args) { // 优化前 String name = "meite"; if (name != null) { System.out.println(name); } //优化后 Optional name2 = Optional.ofNullable(name); // 当value 不为空时,则不会调用 name2.ifPresent(s -> System.out.println(s)); name2.ifPresent(System.out::print); }

优化方案2#
public class Test05 {
private static UserEntity userEntity = null; public static void main(String[] args) { UserEntity userEntity = Test05.getOrder(); System.out.println(userEntity); } public static UserEntity getOrder() { // 优化前 if (userEntity == null) { return createOrder(); } return userEntity; //优化1 return Optional.ofNullable(Test05.userEntity).orElseGet(new Supplier() { @Override public UserEntity get() { return createOrder(); } }); //优化2 return Optional.ofNullable(Test05.userEntity).orElseGet(()-> { Test05.userEntity =createOrder(); return Test05.userEntity; }); //精简版 return Optional.ofNullable(Test05.userEntity).orElseGet(() -> createOrder()); }private static UserEntity createOrder() { return new UserEntity("ylc", 12); }

}
优化方案3#
public class Test06 {
public static void main(String[] args) {String orderName = Test06.getOrderName(); System.out.println(orderName); } public static String getOrderName() { // 优化前写法: UserEntity userEntity = new UserEntity("123456", 19); if (userEntity != null) { String userEntityName = userEntity.getName(); if (userEntityName != null) { return userEntityName.toLowerCase(); } } //优化后 Optional s1 = Optional.ofNullable(userEntity) .map((s) -> s.getName()) .map((s) -> s.toLowerCase()); return s1.get(); }

}

    推荐阅读