关于java8的学习（一）

作者: 威宸 | 来源:发表于2020-08-06 22:08 被阅读0次

Java 8 新特性

官网java8介绍地址
 菜鸟教程关于java8的介绍

Java 8 里面加了很多的新特性，在这里我们只讨论一些常用和实际可能用的到的特性，其他的特性，感兴趣的人可以去官网研究下。

总的来说，常用的特性主要有：

Lambda表达式 ——允许把函数作为一个方法的参数
方法引用 ——方法引用提供了非常有用的语法，可以直接引用已有的Java类或对象（实例）的方法和构造器。与lambda联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码
默认方法 ——默认方法就是一个在接口里面有了一个实现的方法（为Lambda所推出的特性，java8之前接口不能拥有实现方法）
Stream API ——新添加的Stream API（java.util.stream）把真正的函数式编程风格引入到java中
Date Time API ——加强对日期与时间的处理（LocalDateTime，LocalDate，LocalTime）
Optional ——Optional类已成为Java8类库的一部分，用来解决空指针异常
Base64 ——Java8中,Base64编码已经成为Java类库标准。Java8内置了Base64的编码器和解码器

Lambda 表达式

Lambda 允许把函数作为一个方法的参数（可以参考js）

Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

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

语法

    (parameters, parameters) -> expressions
    (parameters) -> { statements; }

如何了解Lambda表达式

通过这段时间上网上找资料、看视频、翻官方文档，我发现我们可以通过这个脉络去了解和使用Lambda表达式：匿名内部类->函数式接口->Lambda表达式

内部类->匿名内部类

内部类：将一个类的定义放在另一个类的定义内部，就是内部类。其优点为可以访问外部类中的资源，就是属性、方法等；缺点破坏代码结构，简单的说就是丑。

匿名内部类：顾名思义就是没有名字的内部类；通常为直接初始化一个接口，并初始化时将接口的方法实现。（我在写android的时候倒是经常遇到）

这里我们通过一个官方内部类的示例改写下来了解下：

package com.education.java8;

/**
 * @author weichen
 * @description: 匿名内部类实例
 * @create 2020-04-23 13:47
 * @from https://docs.oracle.com/javase/tutorial/java/javaOO/anonymousclasses.html
 */
public class HelloWorldAnonymousClasses {

    // 申明一个接口
    interface HelloWorld {
        void greet();
        void greetSomeone(String someone);
    }

    interface HelloWorldLambda {
        void greet();
    }

    // 定义一个方法
    public void sayHello() {
        // 方法内部类实现了HelloWorld接口
        class EnglishGreeting implements HelloWorld {

            String name = "world";
            @Override
            public void greet() {
                greetSomeone("world");
            }

            @Override
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hello " + name);
            }
        }

        HelloWorld englishGreeting = new EnglishGreeting();

        // 匿名内部类实现
        HelloWorld frenchGreeting = new HelloWorld() {
            String name = "tout le monde";
            @Override
            public void greet() {
                greetSomeone("tout le monde");
            }

            @Override
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Salut " + name);
            }
        };

        // 匿名内部类实现
        HelloWorld spanishGreeting = new HelloWorld() {
            String name = "mundo";
            @Override
            public void greet() {
                greetSomeone("mundo");
            }

            @Override
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hola," + name);
            }
        };
        
        // 匿名内部类实现
        HelloWorld chineseGreeting1 = new HelloWorld() {
            String name = "世界";
            @Override
            public void greet() {
                greetSomeone("世界");
            }

            @Override
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("你好 " + name);
            }
        };
        // 匿名内部类实现
//        HelloWorldLambda chineseGreeting2 = new HelloWorldLambda() {
//            @Override
//            public void greet() {
//                System.out.println("你好 世界");
//            }
//        };
        HelloWorldLambda chineseGreeting2 = () -> System.out.println("你好 世界");
        englishGreeting.greet();
        frenchGreeting.greetSomeone("Fred");
        spanishGreeting.greet();
        chineseGreeting1.greet();
        chineseGreeting2.greet();
    }

    public static void main(String... args) {
        HelloWorldAnonymousClasses myApp = new HelloWorldAnonymousClasses();
        myApp.sayHello();
    }
}

输出：

Hello world
Salut Fred
Hola,mundo
你好 世界
你好 世界

获取上面的例子在实际中没啥卵用，这里再给出个线程相关的例子：

package com.education.java8;

/**
 * @author weichen
 * @description: 创建Runnable接口的实现类，重写run方法，设置线程任务
 * @create 2020-04-24 14:39
 */
public class RunnableImpl implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "被创建了");
    }

    public static void main(String[] args) {
        RunnableImpl runnable = new RunnableImpl();
        Thread t = new Thread(runnable);
        t.start();

        // 简化代码，使用匿名内部类
        Runnable runnable1 = new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "被创建了");
            }
        };
        new Thread(runnable1).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "被创建了");
            }
        }).start();

        new Thread(() -> System.out.println(Thread.currentThread().getName() + "被创建了")).start();
    }
}

输出：

Thread-0被创建了
Thread-1被创建了
Thread-2被创建了
Thread-3被创建了

上面的例子中，我们发现对于有且仅有一个抽象方法的接口，我们可以使用lambda表达式，而大于一个的接口只能继续使用匿名内部类的方法。这里就衍生出了函数式接口的概念。

函数式接口

函数式接口就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

首先，我们来定义一个函数式接口：

/**
 * @author weichen
 * @description: 函数式接口，注意：只包含一个抽象方法,或多个default修饰的默认方法
 * @create 2020-05-12 22:17
 */
@FunctionalInterface
public interface FunctionService {
    void test();

    default void printString(String msg) {
        System.out.println(msg);
    }
}

在java8后，可以通过@FunctionalInterface注解来定义函数式接口，其实在该注解源码的注释里已经给出了详细的说明：

/**
 * An informative annotation type used to indicate that an interface
 * type declaration is intended to be a <i>functional interface</i> as
 * defined by the Java Language Specification.
 *
 * 一种信息性注释类型，用于指示接口类型声明是由Java语言规范定义的<i>函数接口</i>
 *
 * Conceptually, a functional interface has exactly one abstract
 * method.  Since {@linkplain java.lang.reflect.Method#isDefault()
 * default methods} have an implementation, they are not abstract.  If
 * an interface declares an abstract method overriding one of the
 * public methods of {@code java.lang.Object}, that also does
 * <em>not</em> count toward the interface's abstract method count
 * since any implementation of the interface will have an
 * implementation from {@code java.lang.Object} or elsewhere.
 *
 * 从概念上讲，函数接口只有一个抽象方法。因为{@linkplain
 * java.lang.reflect.Method#isDefault（）default
 * methods}有一个实现，所以它们不是抽象的。如果一个接口声明了一个抽象方法重写{@
 * ode java.lang.Object}的一个公共方法，那么它也会对接口的抽象方法计数进行<em>
 * 不是<em>计数，因为接口的任何实现都将具有来自{@code
 * java.lang.Object}或其他地方的实现。
 *
 * <p>Note that instances of functional interfaces can be created with
 * lambda expressions, method references, or constructor references.
 * 
 * <p>注意，函数接口的实例可以使用lambda表达式、方法引用或构造函数引用创建。
 *
 * <p>If a type is annotated with this annotation type, compilers are
 * required to generate an error message unless:
 * 
 * <p>如果使用此注解类型对类型进行注解，则编译器生成错误消息，那么需要注意的是：
 *
 * <ul>
 * <li> The type is an interface type and not an annotation type, enum, or
 * class.
 * <li> The annotated type satisfies the requirements of a functional interface.
 * </ul>
 *
 * <ul><li>类型是接口类型，而不是注解类型、枚举或类。<li>带注解的类型满足函数式接口的要求。</ul>
 *
 * <p>However, the compiler will treat any interface meeting the
 * definition of a functional interface as a functional interface
 * regardless of whether or not a {@code FunctionalInterface}
 * annotation is present on the interface declaration.
 *
 * <p>但是，无论接口声明中是否存在{@code-functionainterface}注解，编译器都会将满足函数接口定义的任何接口视为函数接口。
 *
 * @jls 4.3.2. The Class Object
 * @jls 9.8 Functional Interfaces
 * @jls 9.4.3 Interface Method Body
 * @since 1.8
 */
@Documented // 可被javadoc导出
@Retention(RetentionPolicy.RUNTIME)// 运行时注解
@Target(ElementType.TYPE)// 参数类型type
public @interface FunctionalInterface {}

注：在java8中如果你的接口符合函数式接口的定义，编译器默认是将其编译为函数式接口，在上面的注释中已经有体现。

其实在java8之前，接口是只能包含抽象方法，然而在8之后添加了一种默认方法。默认方法使得8之后的代码完美的与之前的版本相兼容。

函数式接口在java里实际上仍然是对象。

使用Lambda表达式

forEach -> Consumer

java中对一个数组遍历有几种方法。java8之前有 for->i, 增强型遍历for->Object,迭代器遍历等，java8后多出个forEach,及外部遍历和内部遍历。

forEach的内部其实也是使用迭代器遍历的,注意forEach中不好对元素进行删除和新增会报ConcurrentModificationException异常，但可以修改属性。

关于java8的学习（一）

Java 8 新特性

Lambda 表达式

语法

如何了解Lambda表达式

内部类->匿名内部类

函数式接口

使用Lambda表达式

forEach -> Consumer

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读