Java8特性接口的改变LambaStream时间API

接口的改变

  1. 接口中可以定义 static方法default方法,并且这两个方法都可以有方法体;
  2. static方法属于接口,default方法属于实例;
  3. static方法不会被继承,静态变量会被继承;
  4. 如果一个类实现了多个接口,并且这些接口相互之间没有继承关系,同时存在相同的默认方法,会报错:不相关默认配置;
  5. 如果一个类实现了多个接口,并且这些接口相互之间存在继承关系,同时存在相同的默认方法,默认方法会被子接口覆盖;
  6. 如果遇到有多个继承并且有相同的默认方法,实现类可以通过特殊语法指定要访问哪个接口的方法:在实现类中重写默认方法,然后通过以下语法:接口名.super.默认方法名;同理,这个规则也适应于接口;
  7. 如果一个接口只有一个抽象方法,那么这个接口属于函数式接口
  8. 如果一个接口使用@FunctionalInterface注解修饰,那么这个接口有且只有一个抽象方法(对static方法和default方法没有限制);
  9. 在接口里面可以使用default方法来实现父接口的抽象方法;
public interface TsInface01 {
    static void staticMethod(){
        System.out.println("我是 TsInface01 接口中的static方法: staticMethod");
    }
    default void default1(){
        System.out.println("我是 TsInface01 接口中的default方法: default1");
    }
}

public interface TsInface02 extends TsInface01{
    static void staticMethod(){
        System.out.println("我是 TsInface02 接口中的static方法: staticMethod");
    }
}

public interface TsInface03 {
    static void staticMethod(){
        System.out.println("我是 TsInface03 接口中的static方法: staticMethod");
    }

    default void default1(){
        System.out.println("我是 TsInface03 接口中的default方法: default1");
    }

}

public class Test01 implements TsInface01, TsInface02 {
    public static void main(String[] args) {
        Test01 t01 = new Test01();
        t01.default1();
    }

    @Override
    public void default1(){
        TsInface02.super.default1();
    }
}

Lamba

函数式接口,该接口中只能由一个抽象方法,可以使用@FunctionalInterface注解修饰某个接口有且仅有一个抽象方法。

@FunctionalInterface
public interface TsInface04 {
    void getName(String firstName);

    default void getMoney() {
        System.out.println("默认方法就是这么任性");
    }

    static void main(String[] args) {
        System.out.println("自从接口可以由静态方法,可以写main函数,作为程序的入口");
    }
}

使用:参数 + 规则 + 方法体 如果使用局部变量,局部变量必须是final类型

public class Test02 implements TsInface01, TsInface02 {
    public static void main(String[] args) {
        Test02 t02 = new Test02();

        // 参数 + 规则 + 方法体
        TsInface04 ts04 = (fisrtName) -> {
            return fisrtName + "bbbbbb";
        };

        // 只有一个参数的时候,参数中的那个括号可以省略
        TsInface04 ts05 = fisrtName -> {
            return fisrtName + "bbbbbb";
        };

        // 只有一句话的方法体,大括号 和 return 也可以省略
        TsInface04 ts06 = fisrtName -> fisrtName + "bbbbbb";
        
        System.out.println(ts04.getName("全写"));
        System.out.println(ts05.getName("简写"));
        System.out.println(ts06.getName("简简写"));
    }
}

方法引用

import java.util.HashMap;
import java.util.Map;

@FunctionalInterface
interface TsInface05 {
    String getName(String firstName);
    default void getMoney() {}
}

@FunctionalInterface
interface TsInface06 {
    Map<String, String> getName(Map<String,String> map, String firstName);
}

@FunctionalInterface
interface TsInface07 {
    void getName(Map<String,String> map, String firstName);
}

public class Test03 {
    public Test03(){

    }
    public Test03(Map<String,String> map, String firstName){
        map.put("NAME", firstName);
        System.out.println(map.get("NAME"));
    }

    public static void main(String[] args) {
        Test03 test03 = new Test03();

        // 引用实例的方法
        TsInface05 t501 = test03::getName1;
        t501.getName("引用实例的方法");

        // 引用类的方法
        TsInface05 t502 = Test03::getName2;
        t501.getName("引用类的方法");

        // 引用类实例方法
        Map<String, String> map = new HashMap<>(16);
        TsInface06 t601 = Test03::getName3;
        t601.getName(map, "引用类实例方法");

        // 引用构造方法
        TsInface07 t701 = Test03::new;
        t701.getName(map, "引用构造方法");
    }


    // 实例方法
    public String getName1(String str) {
        System.out.println(str);
        return str;
    }

    // 类方法
    public static String getName2(String str) {
        System.out.println(str);
        return str;
    }

    // 类实例方法
    public static Map<String, String> getName3(Map<String, String> map, String str) {
        map.put("NAME", str);
        System.out.println(map.get("NAME"));
        return map;
    }
}

Stream

Stream详解

Stream生成

  • 从 Collection 和 数组 Collection.stream() Collection.parallelStream() Arrays.stream(T array) or Stream.of()
  • 从 BufferedReader java.io.BufferedReader.lines()
  • 静态工厂 java.util.stream.IntStream.range() java.nio.file.Files.walk()
  • 自己构建 java.util.Spliterator
  • 其它 Random.ints() BitSet.stream() Pattern.splitAsStream(java.lang.CharSequence) JarFile.stream()
// 1. Individual values
Stream stream = Stream.of("a", "b", "c");
// 2. Arrays
String [] strArray = new String[] {"a", "b", "c"};
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
// 3. Collections
List<String> list = Arrays.asList(strArray);
stream = list.stream();

Stream操作

流的操作类型分为三种:

  • Intermediate:一个流可以后面跟随零个或多个 intermediate 操作。其目的主要是打开流,做出某种程度的数据映射/过滤,然后返回一个新的流,交给下一个操作使用。这类操作都是惰性化的(lazy),就是说,仅仅调用到这类方法,并没有真正开始流的遍历。主要方法有:map(mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered
  • Terminal:一个流只能有一个 terminal 操作,当这个操作执行后,流就被使用“光”了,无法再被操作。所以这必定是流的最后一个操作。Terminal 操作的执行,才会真正开始流的遍历,并且会生成一个结果,或者一个 side effect。主要方法有:forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator
  • short-circuiting:主要应用于:对于一个intermediate操作,如果它接受的是一个无限大(infinite/unbounded)的Stream,但返回一个有限的新 Stream;对于一个 erminal操作,如果它接受的是一个无限大的Stream,但能在有限的时间计算出结果。主要方法有:anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit

在对于一个 Stream 进行多次转换操作(Intermediate 操作),每次都对 Stream 的每个元素进行转换,而且是执行多次,这样时间复杂度就是 N(转换次数)个 for 循环里把所有操作都做掉的总和吗?其实不是这样的,转换操作都是 lazy 的,多个转换操作只会在 Terminal 操作的时候融合起来,一次循环完成。我们可以这样简单的理解,Stream 里有个操作函数的集合,每次转换操作就是把转换函数放入这个集合中,在 Terminal 操作的时候循环 Stream 对应的集合,然后对每个元素执行所有的函数。

int sum = widgets.stream()
.filter(w -> w.getColor() == RED)
.mapToInt(w -> w.getWeight())
.sum();

stream() 获取当前小物件的 source,filter 和 mapToInt 为 intermediate 操作,进行数据筛选和转换,最后一个 sum() 为 terminal 操作,对符合条件的全部小物件作重量求和。

自定义Stream

生成 10 个随机整数

Random seed = new Random();
Supplier<Integer> random = seed::nextInt;
Stream.generate(random).limit(10).forEach(System.out::println);
//Another way
IntStream.generate(() -> (int) (System.nanoTime() % 100)).
limit(10).forEach(System.out::println);

Stream.generate() 还接受自己实现的 Supplier

Stream.generate(new PersonSupplier()).
limit(10).
forEach(p -> System.out.println(p.getName() + ", " + p.getAge()));

private class PersonSupplier implements Supplier<Person> {
    private int index = 0;
    private Random random = new Random();

    @Override
    public Person get() {
        return new Person(index++, "StormTestUser" + index, random.nextInt(100));
    }
}

时间API

  • LocalDate
  • LocalTime
  • LocalDateTime
  • DateTimeFormatter
  • ZonedDateTime
package com.hand.sxy.java8.intface;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

public class Test04 {
    public static void main(String[] args) {
        LocalDate d1 = LocalDate.now();
        System.out.println(d1.toString());

        LocalTime d2 = LocalTime.now();
        System.out.println(d2.toString());

        LocalDateTime d3 = LocalDateTime.now();
        System.out.println(d3.toString());

        DateTimeFormatter f = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        d3 = LocalDateTime.parse("2018-09-19 11:23:22", f);
        System.out.println(d3.toString());

        ZonedDateTime zd = ZonedDateTime.now();
        zd.format(f);
        System.out.println(zd.toString());
    }
}

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏郭耀华‘s Blog

Java String 类

字符串广泛应用 在Java 编程中,在 Java 中字符串属于对象,Java 提供了 String 类来创建和操作字符串。 ---- 创建字符串 创建字符串最简...

37112
来自专栏彭湖湾的编程世界

【javascript】您好, 您要的ECMAScript6速记套餐到了 (一)

【前言】本文“严重参考” 自阮一峰老师写的ES6文档,在此我郑重感谢他沉默无声的帮助 总结一下ES6为 javascript中的 对象/数组/函数 这JS三巨头...

1917
来自专栏柠檬先生

Python 基础 高阶函数

python 把函数作为参数   如果传入abs 作为参数     def add(x,y,y):       return f(x) + f(y)     a...

2979
来自专栏积累沉淀

Python快速学习第六天

第六天: 面向对象 1. 面向对象的特点——多态,封装,继承  对象:包括特性和方法,特性只是作为对象的一部分变量,而方法则是存储在对象内的函数。 (1)多态—...

1907
来自专栏coding for love

JS原生引用类型解析2-Array类型

(注1:如果有问题欢迎留言探讨,一起学习!转载请注明出处,喜欢可以点个赞哦!) (注2:更多内容请查看我的目录。)

1192
来自专栏xingoo, 一个梦想做发明家的程序员

Kruskal算法

同样是求最小生成树,kruskal适合从边的角度出发,因此适合稀疏图。而prim算法从点的角度出发,适合稠密图。 时间复杂度为O(eloge)。因为外层循环了e...

2545
来自专栏好好学java的技术栈

5分钟理解String的&#39;+&#39;的性能及原理

实验二可以很明显地看出,编译器在编译时产生的字节码已经将 "a" + "b" 优化成了 "ab",同理多个字符串的相加也会被优化处理,需要注意的是字符串常量相加...

932
来自专栏曾大稳的博客

c语法进阶

不管是基本数据类型还是结构体,c都是值传递,和java不同的是,java基本数据类型是值传递,对象是引用传递。所以在c当中一般都是指针传递

1592
来自专栏xiaoxi666的专栏

【模板小程序】2~62位非负数任意进制转换

  对于负数,有小伙伴说可以直接将符号丢弃,按照整数进行进位转换,最后再将负号补回来,我认为这种做法是不对的。

942
来自专栏移动端开发

Swift 内存管理详解

Swift内存管理: Swift 和 OC 用的都是ARC的内存管理机制,它们通过 ARC 可以很好的管理对象的回收,大部分的时候,程序猿无需关心 Swift...

2319

扫码关注云+社区

领取腾讯云代金券