java8的相关特性

1,为什么要介绍java8的相关特性?

因为现在的企业大部分已经从java7向java8开始迈进了,用java8的公司越来越多了,java8中的一些知识还是需要了解一些的;

java8具有以下特点:

速度更快（底层的数据结构做了一些更新和改动，垃圾回收机制内存结构做了一些改动）
代码更少（增加了新的语法 Lambda 表达式）
强大的 StreamAPI
便于并行
最大化减少空指针异常（Optional 容器类）

 主要内容:
1、Lambda 表达式
2、函数式接口
3、方法引用与构造器引用
4、StreamAPI
5、接口中的默认方法与静态方法
6、新时间日期 API
7、其他新特性

一,Lambda表达式

什么是lambda表达式?

Lambda 表达式是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的
代码风格，使得 Java 语言表达能力得到了提升。Java8 中引入了一个新的操作符”->”该操作符称为箭头操作符或 Lambda 操作符，箭头操作符将 Lambda 表达式拆分为两部分：
左侧：Lambda 表达式的参数列表。对应接口中抽象方法的参数列表。右侧：Lambda 表达式中所需要执行的功能，即 Lambda 体。对应接口中抽象方法的实现。

Lambda  表达式的基础语法

public class Java8Test {

    /*
    无参数,无返回值
    * */
    @Test
    public void test01(){
        Runnable r=new Runnable() {
            @Override
            public void run() {
                System.out.println("liuqingfeng");
            }
        };
        r.run();

        System.out.println("****************");
        Runnable r2= () -> System.out.println("hello lambda!");
        r2.run();
    }

//有一个参数,无返回值
    @Test
    public void test02(){
        Consumer<String> con=(t) -> System.out.println(t);
        con.accept("1");
    }

    //只有一个参数，小括号可以省略不写
    @Test
    public void test03(){
        Consumer<String> con= t -> System.out.println(t);
        con.accept("2");
    }

    //有两个以上的参数 ，有返回值 ， 并且Lambda体中有多条语句
    @Test
    public void test04(){
        Comparator<Integer> com=(x,y) ->{
            System.out.println("hello world");
            Integer a=Integer.compare(x,y);
            System.out.println(a);
            return a;
        };

        int i = com.compare(8, 4);
        System.out.println(i);
    }


    //若Lambda体中只有一条语句，return  和大括号都可以省略不写
    @Test
    public void test05(){
        Comparator<Integer>  com = (x,y) -> Integer.compare(x,y);
        System.out.println(com.compare(1,2));
    }

    //Lambda 表达式的参数列表的数据类型可以省略不写，因为 JVM 编译器通过上下文推断出
    //数据类型，即“类型推断”
    @Test
    public void test06(){
        Comparator<Integer> com = (Integer x, Integer y) -> Integer.compare(x, y);
        show(new HashMap<>());// jdk1.8 以后
    }
    public void show(Map<String, Integer> map) {
    }

    //使用函数式接口
    @Test
    public void test7() {
        Integer result = operation(100, (x) -> x * x);
        System.out.println(result);
        result = operation(200, (y) -> y - 100);
        System.out.println(result);
    }
    public Integer operation(Integer num, MyFunction<Integer> mf) {
        return mf.getValue(num);
    }
    @FunctionalInterface
    public interface MyFunction<T> {
        public T getValue(T o);
    }


}

 

二,四大内置核心函数式接口

   public class test8_02 {
        /*
         * Consumer<T> 消费型接口
         * void accept(T t);
         */
        @Test
        public  void test01(){
            happy(10000,(m)->System.out.println("杜立宏要去大保健"));
        }
        public void happy(double money, Consumer<Double> con){
            con.accept(money);
        }

        //供给型接口
        @Test
         public void test02(){
            List<Integer> numlist=getNumList(10,()->(int)(Math.random()*100));
            System.out.println(numlist.toString());
        }

        public List<Integer> getNumList(int num,Supplier<Integer> sup){
            List<Integer> list=new ArrayList<>();

            for(int i=0;i<num;i++){
                    list.add(sup.get());
            }
            return list;
        }

        //函数型接口
        @Test
        public void test03(){
            String newStr=strHandler(" shsxt ",(str)->str.trim());
            System.out.println(newStr);
            System.out.println("**********************");
            newStr=strHandler("bjsxt",(str)->str.substring(1,3));
            System.out.println(newStr);
        }



        public String strHandler(String str, Function<String,String> fun){
            return fun.apply(str);
        }

        //断言型接口
        @Test
        public void test04(){
            List<String> list= Arrays.asList("hello","world","123","ok","God");
           list= stringFilter(list,(str)->str.length()>3);
           System.out.println(list.toString());
        }
        public List<String> stringFilter(List<String> list, Predicate<String> pre){
            List<String> li=new ArrayList<>();
            for(String str:list){
                if(pre.test(str)){
                    li.add(str);
                }
            }
            return li;
        }