Java8 新特性

日期处理

在Java8之前，操作日期的话不是很方便，有些地方需要自己编写实现。在Java8中的java.time包下新增很多关于日期处理的类，通过这些类可以使开发者更便捷的操作日期，这些类都是final修饰的，并且是线程安全的。

java8新增的关于日期处理的包：

• java.time
  主要的日期处理相关的类都在这个包下
• java.time.chrono
  这个包中的类主要是对应不同国家的日历记录的方式，国际上通用的日历是2018-01-01这种，但是有些国家有自己独特的记录日历的方式，比如我们国家的农历，不过可惜的是在这个包下没有农历相关的类。
• java.time.format
  日期格式化相关的类在这个包下
• java.time.temporal
  该包下存放着不同国家记录时间的方式相关的类
• java.time.zone
  这个包下存放着设置时区相关的类，目前我们国家是在东八区。

LocalDate:只能处理日期相关的数据，不包含时间

    public static void main(String[] args) {
        //获取当前日期
        LocalDate date1 = LocalDate.now();
        System.out.println(date1);
        
        int year = date1.getYear();
        int month = date1.getMonthValue();
        int day = date1.getDayOfMonth();
        
        //日期格式化
        String date2 = date1.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日"));
        System.out.println(date2);
        
        //是否是闰年
        boolean leap = date1.isLeapYear();
        
        //判断当前月份的天数
        int len = date1.lengthOfMonth();
        
        //自定义日期方式一
        LocalDate date3 = LocalDate.parse("2017-07-11");
        //自定义日期方式二
        LocalDate date4 = LocalDate.of(2017, 7, 11);
        
        //判断日期是否相等
        if(date3.equals(date4)){
            System.out.println("日期相等");
        }
        
        //获取一周后的日期
        LocalDate date5 = date1.plus(1, ChronoUnit.WEEKS);
        System.out.println("一周后的日期：" + date5);
    }

* LocalTime：只能处理时间，不包括日期

    public static void main(String[] args) {
        //获取当前时间
        LocalTime time1 = LocalTime.now();
        //获取当前时间，不包含毫秒
        LocalTime time2 = LocalTime.now().withNano(0);
        System.out.println(time1);
        System.out.println(time2);
        
        //一小时后
        LocalTime time3 = time1.plusHours(1);
        System.out.println(time3);
        
        //自定义时间
        LocalTime time4 = LocalTime.parse("06:12:30");
        LocalTime time5 = LocalTime.of(6, 30, 12);
        
    }

* LocalDateTime:可以处理日期和时间

    public static void main(String[] args) {
        LocalDateTime date1 = LocalDateTime.now();
        System.out.println(date1);
        
        LocalDateTime date2 = LocalDateTime.of(2017, 7, 20, 13, 20, 15);
    }

* Duration和period

    public static void main(String[] args) {
        LocalDate date1 = LocalDate.of(2017, 7, 11);
        LocalDate date2 = LocalDate.of(2017, 7, 13);
        //Period处理LocalDate
        Period period = Period.between(date1, date2);
        System.out.println(period.getDays());
        
        
        LocalTime time1 = LocalTime.of(18, 20, 10);
        LocalTime time2 = LocalTime.of(18, 30, 10);
        
        Duration duration = Duration.between(time1, time2);
        System.out.println(duration.getSeconds());
    }

设定时区

通过ZoneId这个类中的of方法可以设定时区：

    //获取本地的时区时间
    ZonedDateTime now = ZonedDateTime.now();
    System.out.println(now);

    //设定时区为美国洛杉矶
    ZoneId zone = ZoneId.of("America/Los_Angeles");
    //获取指定的时区时间
    ZonedDateTime usa = ZonedDateTime.now(zone);
    System.out.println(usa);

函数式接口

jdk8中新增了函数式接口，在一个接口中只有一个抽象方法的接口被称为函数式接口，例如java.lang.Runnable，java.util.concurrent.Callable。jdk8中新增了@FunctionalInterface注解来标注一个函数式接口。

default方法

jdk8中新增了default方法，jdk8之前接口中的方法必须都是抽象的，在jdk8中允许接口中定义非抽象方法，在接口中的非抽象方法上使用default修饰即可，比如在jdk8中新增了一个函数式接口：java.util.function。java8中打破了接口中的方法必须都是抽象的这一规范，有一个好处就是可以提高程序的兼容性，在java.lang.Iterable接口中新增了forEach方法，该方法就是使用default修饰的。
在接口中定义default方法可以变相的让java支持"多继承"

自定义函数接口：

@FunctionalInterface
public interface MyInterface {
    void m1(int a, int b);

    default String m2(String s){return null;};

    default void m3(){};
}

lambda表达式格式

可以将lambda看做是一个匿名方法，lambda只能用于函数式接口

(类型 参数, 类型 参数, …, 类型 参数) -> {
代码块;

return 结果;
}

主要由这几个符合构成：
() -> {}

lambda优点：使用lambda表达式可以编写出比匿名内部类更简洁的代码

public class LambdaTest01 {

    public static void main(String[] args) {

        // 不使用lambda
        MyInterface oldType = new MyInterface() {

            @Override
            public void m1(int a, int b) {
                System.out.println(a + b);
            }

        };

        oldType.m1(10, 10);




        // 使用lambda
        MyInterface newType = (int a, int b) -> {
        System.out.println(a+b);
        };


        // 编译器都可以从上下文环境中推断出lambda表达式的参数类型,因此可以省略参数类型
/*        LambdaInterface newType = (a, b) -> {
            System.out.println(a + b);
        };*/

        newType.m1(20, 20);
    }

}

使用lambda在多线程中的写法：

    public static void main(String[] args) {

        //不使用lambda的写法
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("no lambda");
            }
        }).start();


        //lambda写法
        //因为Thread类中接收Runnable类型的对象，所以编译器会识别出lambda表达式是Runnable对象
        new Thread(() -> {System.out.println("lambda");}).start();

lambda表达式为什么只能用于函数式接口中

lambda表达式实际上就是重写了接口中的抽象方法，在函数式接口中只有一个抽象方法，此时编译器会认定重写的就是该唯一的抽象方法。
倘若一个接口中有多个抽象方法，而lambda表达式是没有匿名的，编译器就无法判断其重写的是哪个抽象方法了。

forEach方法

在jdk8中的java.lang.Iterable接口中新增了非抽象的forEach方法。可以使用该方法配合lambda来遍历集合。

    public static void main(String[] args) {

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);

        //java8之前
        for(Integer i : list){
            System.out.println(i);
        }


        // Java 8之后，在Iterator接口中新增了非抽象的forEach方法：
        list.forEach((Integer n) -> {System.out.println(n);});

        //如果在lambda表达式中只有一个参数一行语句的时候，可以简写为下面格式
        list.forEach(n -> System.out.println(n));

        // Java 8新增方法引用，方法引用由::双冒号操作符标示
        list.forEach(System.out::println);

    }

方法引用

方法引用主要是用来简写lambda表达式，有些lambda表达式里面仅仅是执行一个方法调用，这时使用方法引用可以简写lambda表达式。

    public static void main(String[] args) {
        Integer[] num = {5,8,13,6};

        //不使用lambda
        Arrays.sort(num, new Comparator<Integer>(){

            @Override
            public int compare(Integer i1, Integer i2) {

                return Integer.compare(i1, i2);
            }

        });

        //使用lambda
        Arrays.sort(num, (x,y) -> Integer.compare(x, y));

        //方法引用
        Arrays.sort(num, Integer :: compare);

    }

一共有四种类型的方法引用
静态方法引用，类名::方法名
某个对象的引用，对象变量名::方法名
特定类的任意对象的方法引用,类名::方法名
构造方法，类名::new

下面代码演示构造方法的引用，先创建一个Car类型，添加一个buy方法，为了能够使用lambda表达式，这里使用java.util.function.supplier接口，这个接口是java8新增的一个函数式接口，里面只有一个抽象的get方法。

public class Car {

    public static Car buy(Supplier<Car> s){

        //通过get方法获取传入的Car类型的对象
        return s.get();
    }
}

创建一个测试类：

/**
 * 构造方法引用
 *
 */
public class LambdaTest05 {

    public static void main(String[] args) {
        Car car = Car.buy(Car :: new);
        System.out.println(car);
    }

}

Java8新特性之Stream

stream简介

jdk8中新增stream API，需要注意的是该stream跟之前学习的IO流没有关系，这个stream主要是用来处理集合数据的，可以将其看做是一个高级迭代器。在Collection接口中新增了非抽象的stream方法来获取集合的流。使用stream后可以写出更简洁的代码来处理集合中的数据。

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

        stuList.add(new Student("刘一", 85));
        stuList.add(new Student("陈二", 90));
        stuList.add(new Student("张三", 98));
        stuList.add(new Student("李四", 88));
        stuList.add(new Student("王五", 83));
        stuList.add(new Student("赵六", 95));
        stuList.add(new Student("孙七", 87));
        stuList.add(new Student("周八", 84));
        stuList.add(new Student("吴九", 100));
        stuList.add(new Student("郑十", 95));

        //需求：列出90分以上的学生姓名，并按照分数降序排序

        //以前的写法，代码较多，每个操作都需要遍历集合
        List<Student> result1 = new ArrayList<>(10);

        //遍历集合获取分数大于90以上的学生并存放到新的List中
        for(Student s : stuList){
            if(s.getScore() >= 90){
                result1.add(s);
            }
        }

        //对List进行降序排序
        result1.sort(new Comparator<Student>(){

            @Override
            public int compare(Student s1, Student s2) {
                //降序排序
                return Integer.compare(s2.getScore(), s1.getScore());
            }

        });

        System.out.println(result1);

        //使用Stream的写法
        /*
         * 1.获取集合的stream对象
         * 2.使用filter方法完成过滤
         * 3.使用sort方法完成排序
         * 4.使用collect方法将处理好的stream对象转换为集合对象
         */
        result1 = stuList.stream()
                .filter(s -> s.getScore()>=90)
                //.sorted((s1,s2) -> Integer.compare(s2.getScore(), s1.getScore()))
                //使用Comparator中的comparing方法
                .sorted(Comparator.comparing(Student :: getScore).reversed())
                .collect(Collectors.toList());
        System.out.println(result1);
    }

map和reduce

• map用来归类，结果一般是一组数据，比如可以将list中的学生分数映射到一个新的stream中
• reduce用来计算值，结果是一个值，比如计算最高分

/**
 * map和reduce
 *
 */
public class StreamTest03 {

    public static void main(String[] args) {
        //初始化List数据同上
        List<Student> list = InitData.getStudent();

        //使用map方法获取list数据中的name
        List<String> names = list.stream()
                                    .map(Student::getName)
                                    .collect(Collectors.toList());
        System.out.println(names);

        //使用map方法获取list数据中的name的长度
        List<Integer> length = list.stream()
                                    .map(Student::getName)
                                    .map(String::length)
                                    .collect(Collectors.toList());
        System.out.println(length);

        //将每人的分数-10
        List<Integer> score = list.stream()
                .map(Student::getScore)
                .map(i -> i - 10)
                .collect(Collectors.toList());
        System.out.println(score);


        //计算学生总分
        Integer totalScore1 = list.stream()
                .map(Student::getScore)
                .reduce(0,(a,b) -> a + b);
        System.out.println(totalScore1);

        //计算学生总分，返回Optional类型的数据，改类型是java8中新增的，主要用来避免空指针异常
        Optional<Integer> totalScore2 = list.stream()
                .map(Student::getScore)
                .reduce((a,b) -> a + b);
        System.out.println(totalScore2.get());

        //计算最高分和最低分
        Optional<Integer> max = list.stream()
                                    .map(Student::getScore)
                                    .reduce(Integer::max);
        Optional<Integer> min = list.stream()
                                    .map(Student::getScore)
                                    .reduce(Integer::min);

        System.out.println(max.get());
        System.out.println(min.get());

    }

}

在java8中新增了三个原始类型流来解决这个问题：
IntStream、DoubleStream、LongStream

/**
 * 数值流
 *
 */
public class StreamTest04 {

    public static void main(String[] args) {
        List<Student> list = InitData.getStudent();

        //将stream转换为IntStream
        int totalScore = list.stream()
                                .mapToInt(Student::getScore)
                                .sum();
        System.out.println(totalScore);

        //计算平均分
        OptionalDouble avgScore = list.stream()
                            .mapToInt(Student::getScore)
                            .average();
        System.out.println(avgScore.getAsDouble());

        //生成1~100之间的数字
        IntStream num = IntStream.rangeClosed(1, 100);

        //计算1~100之间的数字中偶数的个数
        long count = IntStream.rangeClosed(1, 100)
                    .filter(n -> n%2 == 0)
                    .count();
        System.out.println(count);
    }

}

创建流

除了上面的流之外，我们还可以自己创建流。
下面代码中展示了三种创建流的方式：

   //使用Stream.of创建流
    Stream<String> str =  Stream.of("i","love","this","game");
    str.map(String::toUpperCase).forEach(System.out::println);

    //使用数组创建流
    int[] num = {2,5,9,8,6};
    IntStream intStream = Arrays.stream(num);
    int sum = intStream.sum();//求和
    System.out.println(sum);

    //由函数生成流，创建无限流
    Stream.iterate(0, n -> n+2)
            .limit(10)
            .forEach(System.out::println);

Optional简介

空指针异常是在学习和开发中最常见的问题之一，为了解决这个问题，在java8中新增了Optional类。这个类在java.util包下，使用这个类可以更好的支持函数式编程，并且可以简化以前对null的判断。

/**
 * Optional简介
 *
 */
public class OptionalTest01 {

    public static void main(String[] args)   {
        List<Student> stuList = InitData.getStudent();
        Optional<Integer> count = stuList.stream()
                .filter(s -> s.getScore()<60)
                .map(Student::getScore)
                .reduce((a,b) -> a+b);
        System.out.println(count.orElse(0));


        Map<Integer,String> map = new HashMap<>();
        map.put(1001, "篮球");
        map.put(1002, "足球");
        map.put(1003, "羽毛球");
        map.put(1004, "乒乓球");
        String sport = Optional.ofNullable(map.get(1005))
                                        .orElse("无");
        System.out.println(sport);
    }


}

遍历集合的四种方式

下面以ArrayList为例展示一下遍历集合的四种方式，首先初始化一个ArrayList并填充一些测试数据

    List<Integer> list = new ArrayList<>();

    for (int i = 0; i < 10; i++) {
        list.add(i);
    }

遍历集合方式一：使用普通for循环：

    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }

遍历集合方式二：增强for循环，底层就是迭代器：

    for (Integer i:list){
        System.out.println(i);
    }

遍历集合方式三：迭代器

    Iterator<Integer> iterator = list.iterator();
    while(iterator.hasNext()){
        Integer i = iterator.next();
        System.out.println(i);
    }

遍历集合方式四：使用Iterable接口中jdk1.8新增的default方法forEach+lambda表达式

    list.forEach((i) -> {System.out.println(i); });//普通lambda
    list.forEach(i -> System.out.println(i));//只有一行语句时可以简写的形式
    list.forEach(System.out :: println);//方法引用

四种迭代方式对比

• 普通for循环
  此种方式在遍历ArrayList时效率会高一些，因为ArrayList底层使用的是数组实现的，所以可以认为ArrayList中的元素都是有下标的，而此种普通for循环中的变量i可以快速的定位到ArrayList中的元素。
• 增强for循环和迭代器
  可以认为增强for循环是迭代器的一种简便的写法，而迭代器比较适合遍历LinkedList，因为它底层使用的是链表的数据结构。
• 使用forEach方法+lambda表达式
  如果你使用的是jdk8以上的版本，那么建议使用此种方式，该方式内部默认的使用增强for循环去遍历集合，不过在ArrayList类中重写了forEach方法，里面使用了普通的for循环去遍历。不管你使用哪一种，这种方式底层会选择最优的遍历方式

Iterable接口中的forEach方法源码：

default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

ArrayList中重写的forEach方法源码：

@Override
public void forEach(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    final int expectedModCount = modCount;
    @SuppressWarnings("unchecked")
    final E[] elementData = (E[]) this.elementData;
    final int size = this.size;
    for (int i=0; modCount == expectedModCount && i < size; i++) {
        action.accept(elementData[i]);
    }
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

因此建议使用jdk8中Iterable接口中新增的forEach方法遍历集合。