Java基础学习08--JDK1.8特性

1.Lambda表达式

Lambda表达式时特殊的匿名内部类，语法更简洁。它允许把函数作为一个方法的参数(函数作为方法参数传递)，将代码像数据一样传递。

package com.example.jdk8;

import java.util.Comparator;
import java.util.TreeSet;

public class demo01 {
    // Lambda表达式
    public static void main(String[] args) {
        // 1.线程
        Runnable runnable = new Runnable() {

            @Override
            public void run() {
                System.out.println("使用匿名内部类");
            }
        };
        new Thread(runnable).start();

        Runnable runnable1 = () -> System.out.println("使用Lambda表达式");
        new Thread(runnable1).start();

        // 2.比较器
        Comparator<String> com = new Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        };

        TreeSet<String> treeSet = new TreeSet<>(com);

        TreeSet<String> treeSet2 = new TreeSet<String>((o1, o2) -> o1.length() - o2.length());
    }
}

2.函数式接口

如果一个接口只有一个抽象方法，则该接口称为函数式接口，只有函数式接口可以使用Lambda表达式。

package com.example.jdk8;

import java.util.Comparator;
import java.util.TreeSet;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class demo02 {

    public static void main(String[] args) {
        Usb mouse = new Usb() {

            @Override
            public void service() {
                // TODO Auto-generated method stub
                System.out.println("默认实现接口");
            }
        };
        mouse.service();

        Usb fan = () -> System.out.println("Lambda表达式实现接口");
        fan.service();

        // 常见函数式接口

        // 1.消费型，参数T，返回值void
        Consumer<Integer> consumer = (i) -> System.out.println("Lambda表达式实现接口");

        // 2.供给型，参数无，返回T
        Supplier<Integer> supplier = () -> {
            return Integer.valueOf(100);
        };

        // 3.函数型，参数T，返回值R
        Function<Integer, String> function = (i) -> {
            return i.toString();
        };

        // 4.断言，输入T，返回boolean
        Predicate<Integer> predicate = (i) -> i > 10;
    }
}

3.方法引用

对象::实例方法

类::静态方法

类::实例方法

类::new

package com.example.jdk8;

import java.util.Comparator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

public class demo03 {
    public static void main(String[] args) {
        // 1.对象::实例方法
        Consumer<String> consumer = s -> System.out.println(s);
        consumer.accept("hello");

        // println()是一个输入参数，无返回值的方法
        // consumer2是一个输入参数，无返回值的方法
        // 这两个方法的形式一致，就可以使用"方法引用"的简写形式
        Consumer<String> consumer2 = System.out::println;
        consumer2.accept("world");

        // 2.类::静态方法
        Comparator<Integer> com = (o1, o2) -> Integer.compare(o1, o2);
        Comparator<Integer> com2 = Integer::compare;

        // 3.类::实例方法
        Function<Employee, String> function = e -> e.getName();
        Function<Employee, String> function2 = Employee::getName;

        // 4.类::new
        Supplier<Employee> supplier = () -> new Employee();
        Supplier<Employee> supplier2 = Employee::new;
    }
}

4.Stream流

流中保存对集合或数组数据的操作。

(1)Stream自己不会存储元素。

(2)Stream不会改变源对象，相反，他们会返回一个持有结果的新Stream。

(3)Stream操作时延迟执行的。

使用步骤：创建，中间操作，终止操作。

4.1创建

package com.example.jdk8;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class demo04 {

    public static void main(String[] args) {
        // 创建Stream
        // (1)Collection对象中的stream(方法)和parallelStream()方法创建流
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");

        // 串行流
        Stream stream = arrayList.stream();
        stream.forEach(s -> System.out.println(s));

        // 并行流，使用多线程，打印顺序可能不固定
        Stream stream1 = arrayList.parallelStream();
        stream1.forEach(System.out::println);

        // (2)Array工具类的stram()方法
        String[] arr = { "aaa", "bbb", "ccc" };
        Stream<String> stream2 = Arrays.stream(arr);
        stream2.forEach(System.out::println);

        // (3)stream接口中的of方法 iterate、generate
        Stream<Integer> stream3 = Stream.of(10, 20, 30);
        stream3.forEach(System.out::println);

        // 迭代流
        System.out.println("--------迭代流-----------");
        Stream<Integer> iterate = Stream.iterate(0, x -> x + 2);
        iterate.limit(10).forEach(System.out::println);
        System.out.println("--------生成流-----------");
        Stream<Integer> generate = Stream.generate(() -> new Random().nextInt(100));
        generate.limit(10).forEach(System.out::println);

        // (4)IntStream,LongStream,DoubleStream的of，range，rangeClosed
        IntStream stream4 = IntStream.of(100, 200, 300);
        stream4.forEach(System.out::println);
    }
}

4.2中间操作

package com.example.jdk8;

import java.util.ArrayList;

public class demo05 {
    public static void main(String[] args) {
        ArrayList<Employee> list = new ArrayList<>();
        list.add(new Employee("1", 1));
        list.add(new Employee("2", 2));
        list.add(new Employee("3", 3));
        list.add(new Employee("4", 4));
        list.add(new Employee("5", 5));
        list.add(new Employee("4", 4));
        // 中间操作：
        // 1 filter过滤
        System.out.println("-----------filter--------------");
        list.stream().filter(e -> e.getAmount() > 3).forEach(System.out::println);

        // 2 limit限制
        System.out.println("-----------limit--------------");
        list.stream().limit(2).forEach(System.out::println);

        // 3 skip跳过
        System.out.println("-----------skip--------------");
        list.stream().skip(2).forEach(System.out::println);

        // 4 distinct去重
        // 需要override hashcode()和equals()
        System.out.println("-----------distinct--------------");
        list.stream().distinct().forEach(System.out::println);

        // 5 sorted排序
        System.out.println("-----------sorted--------------");
        list.stream().sorted((o1, o2) -> Integer.compare(o1.getAmount(), o2.getAmount())).forEach(System.out::println);

        // 中间操作2 map
        System.out.println("-----------map--------------");
        list.stream().map(e -> e.getName()).forEach(System.out::println);

        // 中间操作3 parallel 采用多线程
        System.out.println("-----------parallel--------------");
        list.parallelStream().forEach(System.out::println);
    }
}

4.3终止操作

forEach、min、max、count、reduce、collect

package com.example.jdk8;

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

public class demo06 {

    public static void main(String[] args) {
        ArrayList<Employee> list = new ArrayList<>();
        list.add(new Employee("1", 1));
        list.add(new Employee("2", 2));
        list.add(new Employee("3", 3));
        list.add(new Employee("4", 4));
        list.add(new Employee("5", 5));

        // forEach 终止操作
        System.out.println("--------------forEach--------------");
        list.stream().filter(e -> e.getAmount() > 2).forEach(System.out::println);

        // min/max/count 终止操作
        System.out.println("--------------min--------------");
        Optional<Employee> min = list.stream().min((e1, e2) -> Integer.compare(e1.getAmount(), e2.getAmount()));
        System.out.println(min.get());

        // reduce 终止操作
        System.out.println("--------------reduce--------------");
        Optional<Integer> sum = list.stream().map(e -> e.getAmount()).reduce((x, y) -> x + y);
        System.out.println(sum.get());

        // collect 终止操作
        System.out.println("--------------collect--------------");
        List<String> lists = list.stream().map(e -> e.getName()).collect(Collectors.toList());
        for (String s : lists) {
            System.out.println(s);
        }
    }
}

5.新日期时间API

SimpleDateFormat类是线程不安全的，DateTimeFormatter类是JDK1.8新增的，线程安全。

package com.example.jdk8;

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

import org.springframework.format.annotation.DateTimeFormat;

public class demo07 {
    public static void main(String[] args) {
        // LocalDate LocalTime LocalDateTime
        // 创建日期时间
        LocalDateTime ldt = LocalDateTime.now();
        LocalDateTime ldt2 = LocalDateTime.of(2021, 2, 1, 15, 54);

        System.out.println(ldt);
        System.out.println(ldt2.getMonth());

        // 2增加/减少时间
        LocalDateTime plusDays = ldt2.plusDays(2);
        System.out.println(plusDays);

        // Instant 时间戳
        Instant instant = Instant.now();
        // Instant.ofEpochMilli(1612166319268L);

        System.out.println(instant);
        System.out.println(instant.toEpochMilli());

        Instant instant2 = instant.plusSeconds(10);
        System.out.println(Duration.between(instant, instant2).toMillis());

        // ZoneId时区
        Set<String> sets = ZoneId.getAvailableZoneIds();
        for (String s : sets) {
            System.out.println(s);
        }
        System.out.println("当前时区");
        System.out.println(ZoneId.systemDefault());// Asia/Shanghai

        // Date Instant LocalDateTime 几种日期类型转换
        // Date -> Instant -> LocalDateTime
        Date date = new Date();
        Instant inst = date.toInstant();
        LocalDateTime ldt3 = LocalDateTime.ofInstant(inst, ZoneId.systemDefault());
        System.out.println(ldt3);

        // LocalDateTime -> Instant -> Date
        Instant inst2 = ldt3.atZone(ZoneId.systemDefault()).toInstant();
        Date from = date.from(inst2);
        System.out.println(from);

        // DateTimeFormat
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // 时间格式化成字符串
        System.out.println(dtf.format(LocalDateTime.now()));

        // 字符串转换为时间
        LocalDateTime ldt4 = LocalDateTime.parse("2021-02-01 16:10:02", dtf);
        System.out.println(ldt4);
    }
}