【Java】全面理解Java8特性

一、Java8中Interface接口

二、lambda表达式

语法格式

三、函数式接口Functional Interface

1. 作用

2. 内置函数式接(Built-in Functional Interfaces)

Predicate接口

Function

Comparator

四、Stream

1. Filter 过滤

2. Sorted 排序

3. Map 映射

4. Match 匹配

5. Collect收集

6. Statistics 统计

7. 函数式接口总结

五、日期时间

1. 格式化

2. 字符串转日期格式

3. 日期计算

4. 获取指定日期

一、Java8中Interface接口

Java8 中，接口中除了抽象方法外，还可以定义default 默认方法和 static 静态方法。

default 修饰的默认方法，属于实例方法，可以被实现类调用或重写。

调用：实现类必须 implements 接口，才能调用该接口的 default 默认方法。

                重写：实现类 implements不同接口时，接口中存在相同签名的方法(名称、参数、类型完全一致)，则实现类必须重写该方法明确方法定义;

        static 修饰的静态方法，属于类的静态方法。但它不能被子类继承，只能用 interface 接口名称调用。

二、lambda表达式

Lambda表达式本质是一个匿名函数，用于把函数作为参数，传入方法中，实现函数式编程风格。

使用 Lambda表达式可以使代码变的更加简洁紧凑。

语法格式

（parameters)->expression或(parameters)->{statements;}

    public static void main(String[] args) {List<String> list = new ArrayList<>(Arrays.asList("s","sjv","safa","safth"));// Comparator接口的匿名实现方式（传统）
//        list.sort(new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.length()-o2.length();
//            }
//        });// lambda表达式的语法规则：(参数) -> {方法实现逻辑}// 使用lambda表达式,@FunctionalInterface接口,只有一个抽象方法（无方法体）// 通过lambda表达式实现Comparator接口list.sort((s1, s2) -> {return s1.length()-s2.length();});// 通过lambda表达式实现Consumer接口list.forEach((str)->{System.out.println(str.toUpperCase());});System.out.println(list);}

三、函数式接口Functional Interface

只有一个抽象方法的接口(可以定义多个非抽象方法)。可以使用 @FunctionalInterface 接
口定义，强化语义规范。
函数式接口，也被称为SAM接口(Single Abstract Method Interfaces)。

1. 作用

基于函数式接口，可以使用Lambda 表达式进行实现，实现函数式编程。

2. 内置函数式接(Built-in Functional Interfaces)

在 Java 8中专门有一个包放函数式接口 java.util.function，该包下的所有接口都有 @FunctionalInterface 注解，提供函数式编程方式。

Predicate接口

Predicate 接口是只有一个参数的返回布尔类型值的 断言型 接口。该接口包含多种默认方法来将Predicate 组合成其他复杂的逻辑(比如:与 and，或or，非negate)。

    public static void main(String[] args) {
//        Predicate predicate = new Predicate() {
//            @Override
//            public boolean test(Object o) {
//                return false;
//            }
//        };List<String> arrayList = new ArrayList<>(Arrays.asList("Basic","QBasic","c","c++","PowerBuilder","go"));// 查找名称小于3个字符的元素Predicate<String> predicate1 = (lang)-> {if (lang.length()<=3) {return true;}return false;};// 查询前缀以“b"或”c“开头的元素Predicate<String> predicate2 = (lang)->{if (lang.toLowerCase().startsWith("b")||lang.toLowerCase().startsWith("c")){return true;}return false;};// 条件组合：形成”与“ 或 ”或“逻辑关系Predicate<String> predicate3 = predicate1.and(predicate2);Predicate<String> predicate4 = predicate1.or(predicate2);// ”非“逻辑 (取反)Predicate<String> predicate5 = predicate1.negate();  // >3arrayList.forEach((lang)->{if (predicate1.test(lang)){System.out.println(lang);}});}

Function

Function 接口接受一个参数并生成结果。默认方法可用于将多个函数链接在一起(compose，andThen)。

    public static void main(String[] args) {List<String> list = new ArrayList<>(Arrays.asList("Basic", "QBasic", "c", "c++", "PowerBuilder", "go"));// Function<参数类型,返回值类型>// 转换成大写字母形式Function<String, String> fun1 = (lang) -> {lang = lang.toUpperCase();return lang;};// 加上【】Function<String, String> fun2 = (lang) -> {lang = String.format("【%s】", lang);return lang;};// 组合Function<String, String> fun3 = fun1.andThen(fun2);  //先fun1，后fun2Function<String,String> fun4 = fun1.compose(fun2);list.forEach((lang) -> {String ret = fun3.apply(lang);System.out.println(ret);});}

Comparator

比较器接口，用于比较指定元素值的大小。 Java 8版本中，添加了多个新的 default 方法，用于比较器合并、反转等操作。

    public static void main(String[] args) {List<String> list = Arrays.asList("Basic", "QBasic", "c", "c++", "PowerBuilder", "to","go");Comparator<String> comparator1 = (lang1, lang2) -> {int ret = lang1.compareTo(lang2);if (ret ==0){return lang1.length()-lang2.length();}return ret;};Comparator<String> comparable2 = comparator1.reversed();  // 反转list.sort(comparable2);list.forEach((lang)->{System.out.println(lang);});}

四、Stream

java.util.Stream表示能应用在一组元素上一次执行的操作序列。
Stream 操作分为中间操作或者最终操作两种，最终操作返回一特定类型的计算结果，而中间操作返回 stream 本身，可以连续完成多个操作。

1. Filter 过滤

过滤通过一个 predicate 接口来过滤并只保留符合条件的元素，该操作属于中间操作。所以过滤后的结果，可以继续进行其它 stream操作(例如forEach，forEach需要一个函数来对过滤后的元素依次执行。 forEach 是一个最终操作)。

    public static void main(String[] args) {Stream<String> stream = Stream.of("Basic", "QBasic", "c", "c++", "PowerBuilder", "go", "BuilderPower");// 过滤所有小写字母内容的元素，并排序stream.filter((lang) -> {for (int i = 0; i < lang.length(); i++) {char c = lang.charAt(i);if (c > 'A' && c < 'Z') {return true;}}return false;}).sorted((c1, c2) -> {if (c1.length() == c2.length()) {return c1.compareTo(c2);} else {return c1.length() - c2.length();}}).forEach((lang) -> {System.out.println(lang);});}

2. Sorted 排序

排序是一个 中间操作，返回的是排序好后的Stream 。(不影响原数据)

    public static void main(String[] args) {Stream<String> stream = Stream.of("Basic", "QBasic", "c", "c++", "PowerBuilder", "go", "BuilderPower");// 过滤所有小写字母内容的元素，并排序stream.filter((lang) -> {for (int i = 0; i < lang.length(); i++) {char c = lang.charAt(i);if (c > 'A' && c < 'Z') {return true;}}return false;}).sorted((c1, c2) -> {if (c1.length() == c2.length()) {return c1.compareTo(c2);} else {return c1.length() - c2.length();}}).forEach((lang) -> {System.out.println(lang);});}

3. Map 映射

映射是一个中间操作，会将元素根据指定的 Function 接口来依次将元素转成另外的对象。

    public static void main(String[] args) {Stream<Integer> stream = Stream.of(10, 20, 30, 40, 50, 60);// 映射：对每一个元素进行一次处理stream.map((n) -> {return n + 1;}).forEach((n) -> {System.out.println(n);});List<String> stringList = Arrays.asList("afa", "asf", "afsa");//转换字符串为大写，降序后输出stringList.stream().map((item) -> {return item.toUpperCase();}).sorted((s1, s2) -> {return s1.compareTo(s2);}).forEach((item) -> {System.out.println(item);});}

4. Match 匹配

Stream 提供了多种匹配操作，允许检测指定的 Predicate 是否匹配整个 Stream 。所有的匹配操作都是 最终操作 ，并返回一个boolean 类型的值。

    public static void main(String[] args) {List<String> stringList = Arrays.asList("gds","asfa","das");// allMatch:所有元素是否匹配boolean bool1 = stringList.stream().allMatch((item) -> {return item.length() == 3;});System.out.println(bool1);// anyMatch:任意元素是否匹配boolean bool2 = stringList.stream().anyMatch((item) -> {return item.length() == 3;});System.out.println(bool2);}