Java8新特性

以下内容均来自菜鸟教程：http://www.runoob.com

• Lambda 表达式

package com.buwei;

/**
 * Lambda表达式，也成为闭包
 * Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中）
 * 语法格式：
 *      (parameters) -> expression
 *      (parameters) -> {statements}
 * 重要特性：
 *      可选类型声明：不需要声明参数类型，编译器会用手一识别参数值
 *      可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号
 *      可选的大括号：如果主体包含了一个语句，就不需要使用大括号
 *      可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，
 *                     大括号需要指明表达式返回了一个数值
 * 注意点：
 *      Lambda表达式主要用来定义行内执行的方法类型接口
 *      Lambda表达式免去了使用匿名方法的麻烦，并且基于Java简单但是强大的函数化的编程能力
 * 变量作用域：
 *      Lambda表达式只能引用标记了final的外部局部变量
 *      就是说不能再Lambda内部修改定义在域外的局部变量，否则会编译错误
 * 可以直接在Lambda表达式中访问外层的局部变量
 * Lambda表达式的局部变量可以不用声明为final，但是必须不可被后面的代码修改
 * Lambda表达式中不允许声明一个局部变量同名的参数或者局部变量
 * @author buwei
 * @date 2018/12/8 19:16
 */
public class LambdaDemo {
    static final String salutation = "HELLO";
    public static void main(String[] args) {
        LambdaDemo lambdaDemo = new LambdaDemo();
        // 需要声明类型
        MathOperation addition = (int a, int b) -> a + b;
        // 不用声明类型
        MathOperation subtraction = (a, b) -> a - b;
        // 大括号中的返回语句
        MathOperation multiplication = (int a, int b) -> {
            return a * b;
        };
        // 没有大括号及返回语句
        MathOperation division = (int a, int b) -> a / b;
        System.out.println("10 + 5 = " + lambdaDemo.operate(10, 5, addition));
        System.out.println("10 - 5 = " + lambdaDemo.operate(10, 5, subtraction));
        System.out.println("10 * 5 = " + lambdaDemo.operate(10, 5, multiplication));
        System.out.println("10 / 5 = " + lambdaDemo.operate(10, 5, division));

        // 不用括号
        GreetingService greetingService1 = message -> System.out.println("hello " + message);
        // 用括号
        GreetingService greetingService2 = (message) -> System.out.println("hello "+message);

        greetingService1.sayMessage("Google");
        greetingService2.sayMessage("baidu");

        // 引用外部的局部变量
        GreetingService greetingService3 = message -> System.out.println(salutation + message);
        greetingService3.sayMessage("cnblogs");
    }

    /**
     * 定义一个接口，在main方法中实现
     */
    public interface MathOperation {
        /**
         * 抽象方法
         * @param a 参数1
         * @param b 参数2
         * @return  返回值
         */
        int operation(int a, int b);
    }

    /**
     * 定义一个接口，在main方法中实现
     */
    public interface GreetingService {
        /**
         * 抽象方法
         * @param message 字符串
         */
        void sayMessage(String message);
    }

    /**
     * 定义私有方法，执行上面两个接口中的执行方法
     * @param a 参数1
     * @param b 参数2
     * @param mathOperation 抽象接口的实现类
     * @return 返回值
     */
    private int operate(int a, int b, MathOperation mathOperation) {
        return mathOperation.operation(a, b);
    }
}

• 方法引用

package com.buwei;

import java.util.ArrayList;
import java.util.List;

/**
 * 方法引用：通过方法的名字来指向一个方法
 *      使语言的构造更紧凑简洁，减少冗余代码
 *      方法引用使用一对冒号 ：：
 * 四种引用方法：
 *      构造器引用：Class::new
 *      静态方法引用：Class::static_method
 *      特定类的任意对象的方法引用：Class::method
 *      特定对象的方法引用：instance::method
 * @author buwei
 * @date 2018/12/8 20:05
 */
public class MethodReferencesDemo {

    public static void main(String[] args) {
        List<String> names = new ArrayList<String>();

        names.add("Google");
        names.add("Runoob");
        names.add("Taobao");
        names.add("Baidu");
        names.add("Sina");

        names.forEach(System.out::println);

    }
}

• 函数式接口

package com.buwei;

/**
 * 函数式接口：就是有且仅有一个抽象方法，但是可以有多个费抽象方法
 * 函数式接口可以被隐式的转换为Lambda表达式
 * Lambda表达式和方法引用(实际上也可认为是Lambda表达式)上
 * 下面写在一起只是为了更好的展现案例
 * @author buwei
 * @date 2018/12/8 20:16
 */
public class FunctionalInterfaceDemo {
    /**
     * 定义一个函数式接口
     * @FunctionalInterface 注解主要是为了检测编译级错误
     * 函数式接口中允许定义静态方法：Java8中的新特性
     */
    @FunctionalInterface
    interface GreetingService {
        /**
         * 随便创建的一个抽象方法
         * @param message 随便创建的一个参数
         */
        void sayMessage(String message);

        /**
         * 随便定义一个静态方法做例子
         */
        static void printHello(){
            System.out.println("hello");
        }
    }

    public static void main(String[] args) {
        GreetingService greetingService = message -> System.out.println("hello" + message);
        greetingService.sayMessage("java");
    }

}

• 默认方法

package com.buwei;


/**
 * 默认方法：就是接口可以有实现方法，二期不需要实现类去实现其方法
 *          只需要在方法名前加上default关键字即可
 * 语法：
 *      public interface DefaultMethod{
 *           default void print(){
 *              sout(" 这是一个默认方法")
 *          }
 *      }
 *  优点：当需要修改接口是，需要修改全部实现该接口的类，
 *          解决办法是在接口中添加新的方法及实现
 *  静态默认方法：接口可以声明（并且可以提供实现）静态方法
 * @author buwei
 * @date 2018/12/8 20:29
 */
public interface DefaultMethodDemo {

    default void testDefault(){
        System.out.println("这是一个接口中的默认方法");
    }

    static void testStatic(){
        System.out.println("这是一个接口中的静态方法");
    }
}

• Optional 类

package com.buwei;

import java.util.Optional;

/**
 * Optional类是一个可以为null的容器对象
 *      如果值存在则isPresent()方法会返回true
 *      调用get()方法会返回该对象
 * Optional是个容器，他可以保存类型T的值
 *      或者仅仅保存null值。Optional提供很多有哦用的方法
 *      这样我们就不用显式进行空值检测
 * Optional类的引入很好的解决空指针异常
 * @author buwei
 * @date 2018/12/8 20:44
 */
public class OptionalDemo {

    public static void main(String[] args) {
        OptionalDemo optionalDemo = new OptionalDemo();
        Integer a = null;
        Integer b = 0;

        // optional.ofNullable - 允许传递为null参数
        Optional<Integer> a1 = Optional.ofNullable(a);

        // optional.of - 如果传递的参数是null,抛出异常NullPointerException
        Optional<Integer> b1 = Optional.of(b);
        System.out.println(optionalDemo.sun(a1, b1));

    }

    private Integer sun(Optional<Integer> a, Optional<Integer> b){
        // Optional.isPresent() - 判断值是否存在
        System.out.println("第一个参数值是否存在："+a.isPresent());
        System.out.println("第二个参数值是否存在："+b.isPresent());

        // Optional.orElse() - 如果值存在，返回它，否则返回默认值
        Integer a2 = a.orElse(0);
        System.out.println(a2);

        // Optional.get() - 获取值，值需要存在
        Integer b2 = b.get();
        return a2 + b2;
    }
}

• 新的日期时间 API

package com.buwei;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;

/**
 * Date-Time API来加强对日期与时间的处理
 *      Java.util.Date：
 *          非线程安全的
 *          与java.sql.Date混乱
 *              util包下的同时包含日期和时间
 *              sql包下的仅包含日期
 *          时区处理麻烦：没有时区支持
 * Java8在Java.time包下提供了很多新的API，以下为两个比较重要的API：
 *      Local(本地) - 简化了时间的处理，没有时区的问题
 *      Zoned(时区) - 通过制定的时区处理日期时间
 * @author buwei
 * @date 2018/12/8 20:59
 */
public class NewDate {

    public static void main(String[] args) {
        NewDate newDate = new NewDate();
        newDate.testLocalDateTime();

    }

    public void  testLocalDateTime(){
        // 获取当前时间日期
        LocalDateTime currentTime = LocalDateTime.now();
        System.out.println("当前时间：" + currentTime);

        LocalDate date1 = currentTime.toLocalDate();
        System.out.println("date1:" + date1);

        Month month = currentTime.getMonth();
        int day = currentTime.getDayOfMonth();
        int second = currentTime.getSecond();

        System.out.println(month + "月：" + day + ",日：" + second + ",秒");

        LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2012);
        System.out.println("date2" + date2);

        // 12 december 2014
        LocalDate date3 = LocalDate.of(2014, Month.DECEMBER, 12);
        System.out.println("date3: " + date3);

        // 22 小时 15 分钟
        LocalTime date4 = LocalTime.of(22, 15);
        System.out.println("date4: " + date4);

        // 解析字符串
        LocalTime date5 = LocalTime.parse("20:15:30");
        System.out.println("date5: " + date5);
    }
}

• 只贴出了自己有些理解的部分，后续再补充。。。。