关于java8一些常见的特性使用

在修改完善版本的工作中，难免会遇到一些不是自己写的且比较前卫的代码，不讨论好不好用，可读性强不强，既然里面已经写好了，就得先看的懂。

java8常见特性

1. optional类使用。
   通常业务类里从数据库取某个bean类型的某个具体属性，这时候就需要进行判空，不然会出现 NullPointerException，正常情况下，一层判空还没有问题，来几层嵌套的话就有点代码冗余了。
   因此optional类为了简化代码而出现~

import java.util.Optional;

public class optionalTest {
    public static void main(String[] args) {
        Person p1=getById(2);
        System.out.println("p1.getname:::"+p1.getName());
        System.out.println("p1.getage:::"+p1.getAge());
        // p1.getname:::fa
        // p1.getage:::22

        Person p2=getById(1);
        String name = Optional.ofNullable(p2).map(Person::getName).orElse(null);
        System.out.println("p2.name:::"+name);
        // p2.name:::null

        Person p3=getById(1);
        if(p3 !=null){
            System.out.println("p3.name"+p3.getName());
        }
        // 不打印

        Person p4=getById(1);
        System.out.println("p4.getname:::"+p4.getName());
        System.out.println("p4.getage:::"+p4.getAge());
        //  Exception in thread "main" java.lang.NullPointerException
    }

    public static Person getById(int id){

        if (id == 1){
            return  null;
        }else{
            Person p = new Person();
            p.setAge(22);
            p.setName("fa");
            return  p;
        }
    }
}
class Person{
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

看完上面的例子，我第一反应是可读性其实也没那么强。。，其他人看很容易看懵。要不是为了弄懂~

2.Lambda表达式
1）其实就是forEach的使用
2）（）->{}的引入

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class LambdaTest {
    public static void main(String[] args) {
        //|---list
        List<Animal> animals = new ArrayList<>();
        animals.add(new Animal("小黄",1));
        animals.add(new Animal("小蓝",2));
        animals.add(new Animal("小红",3));
        animals.add(new Animal("小白",4));

        //|--查询
        //原
        for(Animal animal : animals){
            System.out.println(animal);
        }
        System.out.println("------------------------");
        //新1
        animals.forEach(animal -> System.out.println(animal));
        //新2
        animals.forEach(System.out::println);

        System.out.println("------------------------");
        //|--删除
        //原
        for(Animal animal : animals){
            if (animal.getAge().equals(1)){
                System.out.println(animal);
            }
        }
        System.out.println("------------------------");
        //新
        System.out.println(animals.removeIf(animal->animal.getAge().equals(1)));
        animals.forEach(System.out::println);

        System.out.println("------------------------");
        //|---map
        Map<Integer,Animal> map = new HashMap<>();
        map.put(0,new Animal("小黄",1));
        map.put(1,new Animal("小蓝",2));
        map.put(2,new Animal("小红",3));
        map.put(3,new Animal("小白",4));

        //旧
        for (Map.Entry<Integer,Animal> entry : map.entrySet()){
            System.out.println("k:::"+entry.getKey()+"v:::"+entry.getValue());
        }
        System.out.println("------------------------");
        //新
        map.forEach((k,v)-> System.out.println("k:::"+k+"v:::"+v));


    }
}
class Animal{
    private String name;
    private Integer age;

    public Animal(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

3.stream流
过滤，不删除

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class StreamTest {
    public static void main(String[] args) {
        //|---list
        List<Children> childrens = new ArrayList<>();
        childrens.add(new Children("小明",11));
        childrens.add(new Children("小鸿",10));
        childrens.add(new Children("小刘",9));
        childrens.add(new Children("小音",11));

        //旧
        for (Children children : childrens){
            if (children.getAge().equals(11)){
                System.out.println("name:::"+children.getName());
            }
        }
        System.out.println("----------------------");
        //新
        childrens.stream().filter(children -> children.getAge().equals(11)).collect(Collectors.toList()).forEach(children -> System.out.println("name:::"+children.getName()));
    }
}
class Children{
    private String name;
    private Integer age;

    public Children(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Children{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

4.新增接口默认方法
一个类只能继承一个抽象类；
一个类可以继承多个接口类；
一个类不必全部实现父抽象类；
一个类必须全部实现接口类的所有方法；

Java8之后，接口增加默认方法，让接口向抽象类同化，即不必全部实现所有方法，前提方法前增加default。

interface king{
    public String getName();
    public Integer getAge();
}
public class InterfaceTest implements king{
    @Override
    public String getName() {
        return null;
    }

    @Override
    public Integer getAge() {
        return null;
    }
}
interface king2{
    default public String getName() {
        return "king2,实现了默认方法getName";
    }

    public Integer getAge();
}
class InterfaceTest2 implements king2{

//    @Override
//    public String getName(){
//        return "king2,重写了默认方法getName";
//    }

    @Override
    public Integer getAge() {
        return null;
    }

    public static void main(String[] args) {
        System.out.println(new InterfaceTest2().getName());
    }
}

转：Java8多继承接口
为解决这种多继承关系，Java8提供了下面三条规则：

类中的方法优先级最高，类或父类中声明的方法的优先级高于任何声明为默认方法的优先级。
如果第一条无法判断，那么子接口的优先级更高：方法签名相同时，优先选择拥有最具体实现的默认方法的接口， 即如果B继承了A，那么B就比A更加具体。
最后，如果还是无法判断，继承了多个接口的类必须通过显式覆盖和调用期望的方法， 显式地选择使用哪一个默认方法的实现。

5.函数式接口（没咋用到）