长生的梦呓


  • 归档
  • 算法
  • 基础
  • 关于

  • 分类
  • 日志
  • Servlet
  • Archive
  • 数据结构
  • IO 流

  • 标签
  • 友链
  • MyBatis
  • About
  • Spring 5
  • Java SE
  • Java EE
  • Algorithms
  • 新特性
  • 位运算技巧

  • 搜索
内网穿透 项目实战 数据库 MySQL 安卓踩坑 开发工具 设计模式 Enum 枚举 Linux MyBatis-plus JSON IDEA Transactions AOP IO 流 DP IoC 与 DI 位运算技巧 工具类 学习技巧 Git JDK 排序 Spring Boot Spring MVC Spring Framework MyBatis Log4J Regex Jsoup JDBC 数据结构 递推 递归 算法 Servlet与JSP 小难 中等 简单

【JDK 8 新特性】 推导Lambda简化过程

发表于 2020-03-28 | 17 | 阅读次数 310

前言

该文章记录了多线程用Lambda简化的过程(这里就不多赘述Lambda 的作用了)。

推荐将 二、示例 中的代码粘贴运行感受一下。

一、Lambda简化过程

1.外部类

多线程的创建有三种方式(继承Thread、实现Runnable接口、实现Callable接口)。这里我们实现Runnable接口。

/**
 * 推导 Lambda 表达式,简化多线程
 * @author ChangSheng
 * @date 2020-02-17
 */
public class Lambda简化过程 {
    public static void main(String[] args) {
        // 启动PrintThread线程
        new Thread(new PrintThread()).start();
    }
}
// 外部类实现
class PrintThread implements Runnable {
    @Override
    public void run() {
        System.out.println("PrintThread类打印字符。");
    }
}

2.静态内部类

内部类只有在外部类使用时,才会加载编译。

public class Lambda简化过程 {
    // 静态内部类
    static class PrintThread implements Runnable {
        @Override
        public void run() {
            System.out.println("PrintThread类打印字符。");
        }
    }
    public static void main(String[] args) {
        // 启动PrintThread多线程
        new Thread(new PrintThread()).start();
    }
}

3.局部内部类

将静态移入main方法,作为局部内部类。

public class Lambda简化过程 {
    public static void main(String[] args) {
        // 局部内部类
        class PrintThread implements Runnable {
            @Override
            public void run() {
                System.out.println("PrintThread类打印字符。");
            }
        }
        // 启动PrintThread多线程
        new Thread(new PrintThread()).start();
    }
}

4.匿名内部类

这里将PrintThread类名字去掉了,成为了匿名内部类。

匿名内部类,必须借助父类或接口。

public class Lambda简化过程 {
    public static void main(String[] args) {
        // 匿名内部类,必须借助父类或接口。
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println("PrintThread类打印字符。");
            }
        }).start();
    }
}

5.JDK 8 Lambda表达式

JDK 8 的Lambda表达式将上面匿名内部类接口名,和方法名简化了。

现在只需要关注run()方法中的语句。{}中写原本run()方法中的语句,加上花括号可以写多条语句(一条语句时可以不加花括号{})。

public class Lambda简化过程 {
    public static void main(String[] args) {
        // Lambda 表达式({}中可以写多条语句)
        new Thread(() -> {
            System.out.println("PrintThread类打印字符。");
        }).start();
        // 如果只有一句话,Lambda 表达式也可以写成这样
        new Thread(() -> System.out.println("PrintThread类打印字符。")).start();
    }
}

二、示例

1.接口方法无参数

以下代码可以直接复制到IDE中运行。

/**
 * Lambda示例,推导IPrint接口
 *
 * @author ChangSheng
 * @date 2020-02-17
 */
public class Lambda示例 {
    // 2.静态内部类
    static class PrintSome2 implements IPrint {
        @Override
        public void print() {
            System.out.println("PrintSome2.b.静态内部类");
        }
    }
    public static void main(String[] args) {
        // 3.局部内部类
        class PrintSome3 implements IPrint {
            @Override
            public void print() {
                System.out.println("PrintSome3.c.局部内部类");
            }
        }

        // a.外部类
        IPrint p1 = new PrintSome1();
        p1.print();
        // b.静态内部类
        IPrint p2 = new PrintSome2();
        p2.print();
        // c.局部内部类
        IPrint p3 = new PrintSome3();
        p3.print();
        // d.匿名内部类
        IPrint p4 = new IPrint() {
            @Override
            public void print() {
                System.out.println("PrintSome4.d.匿名内部类");
            }
        };
        p4.print();
        // e.Lambda表达式(注意,使用Lambda表达式时,需要有类型IPrint )
        IPrint p5 = () -> {
            System.out.println("PrintSome5.e.Lambda表达式");
        };
        p5.print();
        // e.Lambda表达式(只有一条语句时去掉{})
        IPrint p6 = () ->  System.out.println("PrintSome6.f.Lambda表达(一条语句省去花括号{})");
        p6.print();
    }
}

interface IPrint {
    // 该接口的无参方法。(注意,我们需要保证接口只有一个未实现方法,否则Lambda无法推导)
    // 无返回值(打印一句话)
    void print();
}

// 1.外部类
class PrintSome1 implements IPrint {
    @Override
    public void print() {
        System.out.println("PrintSome1.a.外部类");
    }
}

2.接口方法有参数

/**
 * Lambda示例,推导IPrint接口
 *
 * @author ChangSheng
 * @date 2020-02-17
 */
public class Lambda示例 {
    // 2.静态内部类
    static class PrintSome2 implements IPrint {
        @Override
        public void print(String v) {
            System.out.println("PrintSome2."+v);
        }
    }

    public static void main(String[] args) {
        // 3.局部内部类
        class PrintSome3 implements IPrint {
            @Override
            public void print(String v) {
                System.out.println("PrintSome3."+v);
            }
        }

        // a.外部类
        IPrint p1 = new PrintSome1();
        p1.print("a.外部类");
        // b.静态内部类
        IPrint p2 = new PrintSome2();
        p2.print("b.静态内部类");
        // c.局部内部类
        IPrint p3 = new PrintSome3();
        p3.print("c.局部内部类");
        // d.匿名内部类
        IPrint p4 = new IPrint() {
            @Override
            public void print(String v) {
                System.out.println("PrintSome4."+v);
            }
        };
        p4.print("d.匿名内部类");
        // e.Lambda表达式
        IPrint p5 = (String v) -> System.out.println("PrintSome5."+v);
        p5.print("e.Lambda表达式");
        // f.Lambda表达式(可以省略类型)
        IPrint p6 = (v) -> System.out.println("PrintSome6."+v);
        p6.print("f.Lambda表达式(省略类型)");
        // g.Lambda表达式(只有一个参数时,可以省略括号)
        IPrint p7 = v -> System.out.println("PrintSome7."+v);
        p7.print("g.Lambda表达式(省略括号)");
    }
}

interface IPrint {
    // 该接口的有参方法。(注意,我们需要保证接口只有一个未实现方法,否则Lambda无法推导,v代表value)
    // 无返回值(打印一句话 + 传入的值v)
    void print(String v);
}

// 1.外部类
class PrintSome1 implements IPrint {
    @Override
    public void print(String v) {
        System.out.println("PrintSome1." + v);
    }
}

3.接口方法有参数有返回值


/**
 * Lambda示例,推导IPrint接口
 *
 * @author ChangSheng
 * @date 2020-02-17
 */
public class Lambda示例 {
    // 2.静态内部类
    static class PrintSome2 implements IPrint {
        @Override
        public String print(String v1, String v2) {
            return v1+v2;
        }
    }

    public static void main(String[] args) {
        // 3.局部内部类
        class PrintSome3 implements IPrint {
            @Override
            public String print(String v1, String v2) {
                return v1+v2;
            }
        }

        // a.外部类
        IPrint p1 = new PrintSome1();
        String print1 = p1.print("PrintSome1.", "a.外部类");
        System.out.println(print1);
        // b.静态内部类
        IPrint p2 = new PrintSome2();
        String print2 = p2.print("PrintSome2.", "b.静态内部类");
        System.out.println(print2);
        // c.局部内部类
        IPrint p3 = new PrintSome3();
        String print3 = p3.print("PrintSome3.", "c.局部内部类");
        System.out.println(print3);
        // d.匿名内部类
        IPrint p4 = new IPrint() {
            @Override
            public String print(String v1, String v2) {
                return v1+v2;
            }
        };
        String print4 = p4.print("PrintSome4.", "d.匿名内部类");
        System.out.println(print4);
        // e.Lambda表达式(省略return)
        IPrint p5 = (String v1, String v2) -> v1+v2;
        String print5 = p5.print("PrintSome5.", "e.Lambda表达式");
        System.out.println(print5);
        // f.Lambda表达式(省略return,也可以省略类型)
        IPrint p6 = (v1, v2) -> v1+v2;
        String print6 = p6.print("PrintSome6.", "f.Lambda表达式(省略类型)");
        System.out.println(print6);
    }
}

interface IPrint {
    // 该接口的有参方法。(注意,我们需要保证接口只有一个未实现方法,否则Lambda无法推导,v代表value)
    // 有返回值(返回v1+v2)
    String print(String v1, String v2);
}

// 1.外部类
class PrintSome1 implements IPrint {
    @Override
    public String print(String v1, String v2) {
        return v1+v2;
    }
}
  • 本文作者: 长生的梦呓
  • 本文链接: https://shengjava.com/archives/jdk8新特性推导lambda简化过程
  • 版权声明: 本博客所有文章除特别声明外,均采用CC BY-NC-SA 3.0 许可协议。转载请注明出处!
# 内网穿透 # 项目实战 # 数据库 # MySQL # 安卓踩坑 # 开发工具 # 设计模式 # Enum # 枚举 # Linux # MyBatis-plus # JSON # IDEA # Transactions # AOP # IO 流 # DP # IoC 与 DI # 位运算技巧 # 工具类 # 学习技巧 # Git # JDK # 排序 # Spring Boot # Spring MVC # Spring Framework # MyBatis # Log4J # Regex # Jsoup # JDBC # 数据结构 # 递推 # 递归 # 算法 # Servlet与JSP # 小难 # 中等 # 简单
【MyBatis】(1)简单使用
【JDK】JDK 5 到 13 新特性
  • 文章目录
  • 站点概览
长生的梦呓

长生的梦呓

110 日志
39 分类
40 标签
RSS
E-mail CSDN
Creative Commons
Links
  • CSDN 地址
  • waltz26
  • Ryan Wang's Blog
  • JohnNiang's Blog
  • 廖雪峰
  • 菜鸟教程
© 2021 长生的梦呓
浙ICP备20005262号-1