关于java:Java8新特性

Java8新个性
接口中默认办法润饰为一般办法#
在jdk8之前，interface之中能够定义变量和办法，变量必须是public、static、final的，办法必须是public、abstract的，因为这些修饰符都是默认的。

接口定义办法：public 形象办法须要子类实现

接口定义变量：public、static、final

在JDK 1.8开始反对应用static和default 润饰能够写办法体，不须要子类重写。

办法：

一般办法能够有办法体

形象办法没有办法体须要子类实现重写。

案例

public interface JDK8Interface {

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

}
子类实现接口

public class JDK8InterfaceImpl implements JDK8Interface {

/** 子类实现接口 没有强制要求重写default和static办法* */@Overridepublic 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 {

void  get();default void add() {}String toString();

}
常见例如Runnable接口

image-20211018221019469

办法调用

public static void main(String[] args) {    ((MyFunctionalInterface) () -> System.out.println()).get();}

Lambda根底语法#
()--参数列表
-> 分隔
{} 办法体
(函数接口的参数列表不须要写类型须要定义参数名称)->{办法体}

无参办法调用#
@FunctionalInterface
public interface MyFunctionalInterface {

void  get();

}

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<String> arrayList=new ArrayList<>();    arrayList.add("111");    arrayList.add("222");    arrayList.add("333");

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

    arrayList.forEach(s->{        System.out.println(s);    });}

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;}@Overridepublic String toString() {    return "UserEntity{" +            "name='" + name + '\'' +            ", age=" + age +            '}';}

}
public static void main(String[] args) {

    ArrayList<UserEntity> 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<UserEntity>() {        @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<UserEntity> 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<UserEntity> stream=userEntities.stream();    Set<UserEntity> 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<UserEntity> 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汇合只有key  list转换map的时候须要指定key value，key=username  value=user对象    * */    Stream<UserEntity> stream=userEntities.stream();    Map<String,UserEntity> collect = stream.collect(Collectors.toMap(new Function<UserEntity,String>() {        @Override        public String apply(UserEntity o) {            return o.getName();        }    }, new Function<UserEntity, UserEntity>() {        @Override        public UserEntity apply(UserEntity usrentity) {            return usrentity;        }    }));    //精简版    collect.forEach(new BiConsumer<String, UserEntity>() {        @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<Integer> integerStream=Stream.of(5,6,7,8);    Optional<Integer> reduce = integerStream.reduce(new BinaryOperator<Integer>() {        @Override        public Integer apply(Integer integer, Integer integer2) {            return integer + integer2;        }    });    System.out.println(reduce);    ArrayList<UserEntity> 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<UserEntity> sum=userEntities.stream().reduce(new BinaryOperator<UserEntity>() {        @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<UserEntity> 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<UserEntity> stream=userEntities.stream();    Optional<UserEntity> min = stream.min(new Comparator<UserEntity>() {        @Override        public int compare(UserEntity o1, UserEntity o2) {            return o1.getAge() - o2.getAge();        }    });    System.out.println(min.get());    //简化版    Optional<UserEntity> 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<UserEntity> 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<UserEntity> stream=userEntities.stream();    boolean b = stream.anyMatch(new Predicate<UserEntity>() {        @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<UserEntity> 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<UserEntity> stream=userEntities.stream();    stream.forEach((userEntity -> System.out.println(userEntity)));}

Stream filter过滤器#

public static void main(String[] args) {    ArrayList<UserEntity> 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<UserEntity> stream=userEntities.stream();    stream.filter(new Predicate<UserEntity>() {        @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<UserEntity> 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<UserEntity> stream = userEntities.stream();    stream.skip(2).limit(2).forEach((userEntity -> System.out.println(userEntity)));}

stream 综合案例#
public static void main(String[] args) {

    ArrayList<UserEntity> 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<UserEntity> 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();

}public  void 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<String,Integer> function=new Function<String, Integer>() {        @Override        public Integer apply(String s) {            return s.length();        }    };    //精简版    Function<String,Integer> 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<Integer> a = Optional.ofNullable(a1);    System.out.println(a.isPresent());//true    Optional<String> 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<Integer> a = Optional.ofNullable(a1);//判断是否等于16boolean present = a.filter(new Predicate<Integer>() {    @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<String> 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<UserEntity>() {        @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<String> s1 = Optional.ofNullable(userEntity)            .map((s) -> s.getName())            .map((s) -> s.toLowerCase());    return s1.get();}

}