JDK1.8部分新特性（Lambda表达式、线程安全的DateTimeFormatter、时区(ZoneId)、时间戳(Instant)）

Lambda表达式：

一个接口中只有一个抽象方法基本的Lambda使用

package lambda;

/**
 * lamda练习
 * lambda表达式其实是匿名内部类的简化
 * @author : li
 * @date : 2021-06-10 18:35
 */
public class LambdaPractice {
    public static void main(String[] args) {
        /*接口和抽象类不能被实例化 下面是匿名内部类*/
        A1 a1 = new A1() {
            @Override
            public void m1() {
                System.out.println("HelloWorld");
            }

            @Override
            public void m2() {
                System.out.println("你好");
            }
        };
        a1.m1();
        a1.m2();

        /**
         * lamda表达式只适用于接口中只有一个抽象方法
         */
        /*A1 a2 = () -> System.out.println("HelloWorld");
        a2.m1();*/


        // 测试有参的lambda表达式
        B1 b2 = (age) -> System.out.println(age);
        b2.m1(22);

        /**
         * 测试有返回值的
         */
        C1 c1 = (stature) -> stature;
        System.out.println("stature身高"+c1.m1(170));

        D1 d1 = (age,name) -> {
            return name;
        };
        System.out.println(d1.name(21, "张三"));
    }


    /**
     * 接口中方法默认被public abstract 修饰
     * 接口中成员变量默认被public static final修饰
     * @FunctionalInterface 这个注解作用在接口上表明这个接口是一个函数式接口 里面只能有一个抽象方法  有两个的话就报错
     */
    interface A1{
        /**
         * 测试没有参数的
         */
        void m1();
        /**
         * 测试有抽象两个方法lamda表达式还能不能用
         */
        void m2();
    }

    @FunctionalInterface
    interface B1{
        /**
         * 测试有参数的
         * @param age 年龄
         */
        void m1(int age);
    }

    @FunctionalInterface
    interface C1{
        /**
         * 测试有返回值的
         * @param stature 身高
         * @return 返回身高
         */
        int m1(int stature);
    }

    interface D1{
        /**
         * 测试有多个返回值的
         * @param age 年龄
         * @param name 姓名
         * @return
         */
        String name(int age,String name);
    }
}

在集合中的使用

package lambda;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 练习
 * @author : li
 * @date : 2021-06-12 16:41
 */
public class Lambdapractice002 {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("小米");
        strings.add("华为");
        strings.add("三星");
        strings.add("apple");
        strings.add("apple");
        Stream<String> stream = strings.stream();
//        stream.forEach(s -> System.out.println(s) );
//        stream.forEach(System.out::println);
        System.out.println("------stream输出打印集合-----");
        strings.stream().forEach(System.out::println);
        System.out.println("-----stream去重----");
        System.out.println(strings.stream().distinct().collect(Collectors.toList()));
        System.out.println("------放到set集合去重------");
        HashSet hashSet = new HashSet(strings);
        hashSet.stream().forEach(System.out::println);

        ArrayList<Students> list = new ArrayList<>();
        list.add(new Students("张三",20));
        list.add(new Students("李四",25));
        list.add(new Students("王五",30));
        list.add(new Students("王五",30));
        list.add(new Students("孙六",45));
        System.out.println("----stream设置条件----");
        System.out.println(list.stream().filter(s -> s.getAge() > 20).collect(Collectors.toList()));
        System.out.println("--------集合泛型是实体类 stream去重(在实体类中需要重写HashCode和equals方法)---------");
        list.stream().distinct().forEach(System.out::println);
        System.out.println("-----排序------");
        /*降序排列  e2.getAge(), e1.getAge()  e1  e2  位置*/
        list.stream().sorted((e1,e2) -> Integer.compare(e2.getAge(), e1.getAge())).forEach(System.out::println);
        /*升序排列  两种方式*/
        // list.stream().sorted((e1,e2) -> Integer.compare(e1.getAge(), e2.getAge())).forEach(System.out::println);
        // list.stream().sorted(Comparator.comparingInt(Students::getAge)).forEach(System.out::println);
        System.out.println("------------stream   limit用法--------");
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("------------stream   skip(跳过)用法--------");
        list.stream().skip(4).forEach(s -> System.out.println(s));
        System.out.println("----转map取某个字段----");
        list.stream().map(s -> s.getName()).forEach(System.out::println);
        System.out.println("-----parallel 采用多线程  -----");
        list.stream().parallel().forEach(System.out::println);

		System.out.println("---------终止操作 min(根据某个字段取最小的)---------");
        // Optional<Students> min = list.stream().min((e1, e2) -> Double.compare(e1.getAge(), e2.getAge()));
        Optional<Students> min = list.stream().min(Comparator.comparingInt(Students::getAge));
        System.out.println(min);
        System.out.println("---------终止操作 min(根据某个字段取最大的)---------");
        Optional<Students> max = list.stream().max(Comparator.comparingInt(Students::getAge));
        System.out.println(max);

        System.out.println("------count 取集合中的个数------");
        long count = list.stream().count();
        System.out.println(count);

        System.out.println("----reduce 计算某列的总和----");
        Optional<Integer> reduce = list.stream().map(s -> s.getAge()).reduce((x, y) -> x + y);
        System.out.println(reduce.get());

        System.out.println("----collect  取某个字段封装成一个集合----");
        List<String> nameList = list.stream().map(s -> s.getName()).collect(Collectors.toList());
        nameList.forEach(System.out::println);

    }
    static class Students{
       public Students() {
        }

        public Students(String name, int age) {
            this.name = name;
            this.age = age;
        }

        private String name;
        private int age;

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

        public String getName() {
            return name;
        }

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

        public int getAge() {
            return age;
        }

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

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Students students = (Students) o;
            return age == students.age && name.equals(students.name);
        }

        @Override
        public int hashCode() {
            return Objects.hash(name, age);
        }
    }
}

时区(ZoneId)、时间戳(Instant)、以及Date、Instant、LocalDateTime之间的相互转换

package lambda;

import java.time.Duration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;
import java.util.Set;

/**
 * DateAndInstantPractice
 * @author : li
 * @date : 2021-06-16 20:42
 */
public class DateAndInstantPractice {
    public static void main(String[] args) {
        // 创建Instant； 时间戳
        Instant now = Instant.now();
        // 打印当前时间 相差8个小时
        System.out.println("当前时间--------"+now);
        // 添加10秒
        Instant plusSeconds = now.plusSeconds(10);
        // 打印添加10秒后与当前时间的差 toMillis输出的是毫秒
        System.out.println(Duration.between(now, plusSeconds).toMillis());
        // ZoneId 时区
        Set<String> availableZoneIds = ZoneId.getAvailableZoneIds();
        availableZoneIds.stream().forEach(System.out::println);
        // 打印当前的时区
        System.out.println(ZoneId.systemDefault());

		LocalDateTime nowDate = LocalDateTime.now();
        System.out.println("获取年==="+nowDate.getYear());
        System.out.println("获取月==="+nowDate.getMonthValue());
        System.out.println("获取分钟==="+nowDate.getMinute());
        LocalDateTime plusDays = nowDate.plusDays(2);
        System.out.println("增加两天==="+plusDays);
        LocalDateTime minusMonths = nowDate.minusMonths(1);
        System.out.println("减少一个月==="+minusMonths);

        System.out.println("-----Date转Instant转LocalDateTime------");
        System.out.println("-----Date转Instant---有八个小时的误差---");
        Date date = new Date();
        Instant instant = date.toInstant();
        System.out.println("-----Date转Instant------"+instant);
        System.out.println("-----Instant转LocalDateTime---没有时间上的误差---");
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
        System.out.println("-----Instant转LocalDateTime------"+localDateTime);

        // LocalDateTime转Instant转Date
        System.out.println("-----LocalDateTime转Instant-----");
        Instant toInstant = localDateTime.atZone(ZoneId.systemDefault()).toInstant();
        System.out.println("LocalDateTime转Instant"+toInstant);
        System.out.println("Instant转Date");
        Date date1 = Date.from(toInstant);
        System.out.println(date1);

    }
}

时间格式化DateTimeFormatter的使用

package lambda;

import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;

/**
 * DateTimeFormatter的使用
 * @author : li
 * @date : 2021-06-16 21:57
 */
public class DateTimeForMatter {
    public static void main(String[] args) {
        Date date = new Date();
        // SimpleDateFormat 线程不安全
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format1 = simpleDateFormat.format(date);
        System.out.println(format1);
        // DateTimeFormatter 线程安全
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String format = dateTimeFormatter.format(LocalDateTime.now());
        System.out.println(format);
        // 把字符串解析成时间
        LocalDateTime parse = LocalDateTime.parse("2021-05-22 10:25:15", dateTimeFormatter);
        System.out.println(parse);
    }
}

常用的操作

public class OftenUse {
    public static void main(String[] args) {
        // 初始化一批值
        List<User> userList = IntStream.rangeClosed(0, 20).mapToObj(i -> new User(i, "name/" + i, i)).collect(Collectors.toList());
//        System.out.println(userList);
        // 对象中的某个字段求和
        List<User> list = new ArrayList<>();
        list.add(new User(1, "张三", 20));
        list.add(new User(1, "李四", 10));
        list.add(new User(3, "王五", 30));
        list.add(new User(4, "老刘", 22));
        list.add(new User(5, "王六", 22));
        list.add(new User(5, "王六", 55));
        int sum = list.stream().map(User::getAge).collect(Collectors.toList()).stream()
                .map(age -> Objects.isNull(age) ? 0 : age).mapToInt(age -> age).sum();
        System.out.println(sum);

        // 获取年龄中最大最小、平均、总和、数量
        IntSummaryStatistics intSummaryStatistics = list.stream().map(User::getAge).collect(Collectors.toList()).stream()
                .map(age -> Objects.isNull(age) ? 0 : age).mapToInt(age -> age).summaryStatistics();
        System.out.println(intSummaryStatistics.getSum());
        System.out.println(intSummaryStatistics.getMin());
        System.out.println(intSummaryStatistics.getMax());
        System.out.println(intSummaryStatistics.getAverage());
        System.out.println(intSummaryStatistics.getCount());
        System.out.println("----");
        IntSummaryStatistics statistics = Stream.of(1, 2, 3, 4).mapToInt(num -> num).summaryStatistics();
        System.out.println(statistics.getSum());
        System.out.println(statistics.getMin());
        System.out.println(statistics.getMax());
        System.out.println(statistics.getAverage());
        System.out.println(statistics.getCount());
        System.out.println("|||||");
        // 求和
        Integer reduce = Stream.of(1, 2, 3, 4).reduce(1, Integer::sum);
        System.out.println(reduce);
        System.out.println(";;;;;;");
        // 统统年龄的最大最小、平均、总和、数量
        Map<Integer, IntSummaryStatistics> summaryStatisticsMap = list.stream().collect(Collectors.groupingBy(User::getAge, Collectors.summarizingInt(User::getId)));
        System.out.println(summaryStatisticsMap);
        System.out.println("///");
        // 相同年龄的姓名
        Map<Integer, String> collect = list.stream().collect(Collectors.groupingBy(User::getAge, Collectors.mapping(User::getName, Collectors.joining(","))));
        System.out.println(collect);
    }
}