jdk8 - jdk9 知识学习 (整理中) day01

最新推荐文章于 2024-05-28 23:41:13 发布
最新推荐文章于 2024-05-28 23:41:13 发布
阅读量144 收藏
点赞数
文章标签： jdk8 jdk9
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39501136/article/details/101946969
版权

参考传智视频，整理中。。。

课程介绍

  1. 重点讲解java8 和java9当中的新特性
  2. 课程定位：
    适合有一定java编程经验的同学，渴望了解最新java前沿技术的同学,快速入门
  3. 课程内容：
    day01 lambda表达式，函数式接口、接口更新
    day02 方法引用、常用函数式接口
    day03 Stream流式处理api、模块化

java发展历程

版本号年份/代号新特性(部分举例)
1.01996年
1.11997年JDBC
1.21998年 / Playground（运动场）集合、字符串池
1.32000年 / Kestrel（美洲红隼）JDBC
1.42004年 / Merlin（灰背隼）XML、正则、JDBC3.0、断言、NIO
5.02004年 / Tigger （老虎）泛型、注解、可变参数、枚举
6.02006年 / Mustang （野马）脚本、JDBC 4.0
7.02011年 / Dolphin （海豚）NIO2.0 、try-with-resources
8.02014年3月 / Spider （蜘蛛）接口更新、lambda表达式、方法引用、Stream API、函数式接口、Hashorn、JavaFX、DateTime
9.02017年9月Jigsaw模块化、Jshell、接口小更新

Lambda标准格式

1.一些参数
2. 一个箭头
3. 一些代码

如果参数有多个，则使用逗号分隔； 如果没有参数，则留空
箭头是固定写法
大括号相当于方法体

省略规则

  1. 参数的类型可以省略，但是只能同时省略所有参数的类型，或者干脆都不省略，不能致谢个别参数的类型
  2. 如果参数有且仅有一个，那么小括号可以省略
  3. 如果大括号之内的语句有且仅有一个，那么无论有没有返回值，return、大括号和分好，都可以省略
 public static void main(String[] args) {
        //匿名内部类对象
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("多线程执行！！！");
            }
        };
        new Thread(runnable).start();

        //Lambda表达式使用
        new Thread(() -> System.out.println("111")).start();
    }

如何进行软件开发

  1. 自己编写二进制
  2. 汇编语言
  3. 面向过程
  4. 面向对象
  5. 函数式编程思想

面向对象强调“一切皆对象“，如果要想做事情，必须找到对象来做
函数式编程思想强调”做什么，而不是怎么做“

Lambda分析

Runnable接口当中的run方法语义分析

public void run(){
		//方法体
}
  1. 参数列表为空，不需要任何条件就可以执行该方法
  2. 没有返回值，方法不产生任何数据结果
  3. 方法体大括号，这才是关键的方法内容所在

Lambda表达式

() -> System.out.println("线程任务执行”);
  1. 小括号，不需要任何参数，即可直接执行
  2. 箭头指向后面要做的事情
  3. 尖肉后面就好比方法体大括号，代表具体要做的内容

示例

1、接口 Cook.java

/**
 * lambda表达式的必要前提
 *  1. 必须有一个接口
 *  2.接口当中必须保证有且有个抽象方法
 */
public interface Cook {
    /*
     * 唯一的抽象方法
     */
    void makeFood();
}

2、实现类

public class CookImpl implements Cook {
    @Override
    public void makeFood() {
        System.out.println("makeFood.......");
    }
}

3、内部类实现

public class Demo02_InnerClass {
    public static void main(String[] args) {
        method(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("makeFood...内部类实现。。。");
            }
        });
    }
    private static void method(Cook cook){
        cook.makeFood();
    }
}

4、Lambda实现

public class Demo02_Lambda {
    public static void main(String[] args) {
       method(() -> System.out.println("makeFood... Lambda实现方式。。。"));
    }
    private static void method(Cook cook){
        cook.makeFood();
    }
}

案例1：排序

1、实体类

public class Person(){
    private String name;
    private int age;
    //setter/getter、 构造方法、toString()省略
}

2、测试类
方式一：
使用匿名内部类排序

public class SortTest{
    public static void main(String[] args) {
        Person[] arrays = {
                new Person("刘备", 30),
                new Person("张飞", 25),
                new Person("张苞", 3),
                new Person("关羽", 27),
        };
        System.out.println(Arrays.toString(arrays));
        Arrays.sort(arrays, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        System.out.println("-------------------------------------排序后---------------------------------");
        System.out.println(Arrays.toString(arrays));
    }

方式二：
Lambda方式

public class Demo02_Lambda {
    public static void main(String[] args) {
        Person[] arrays = {
                new Person("刘备", 30),
                new Person("张飞", 25),
                new Person("张苞", 3),
                new Person("关羽", 27),
        };
        System.out.println(Arrays.toString(arrays));
        Arrays.sort(arrays,(Person o1, Person o2) -> {
            return o1.getAge() - o2.getAge();
        });
        System.out.println("-------------------------------------排序后---------------------------------");
        System.out.println(Arrays.toString(arrays));
    }
}

案例2：

public interface Calculator {
    //两数求和
    int sum(int a, int b);
}
//测试类
public class CalculatorLambdaTest {
    public static void main(String[] args) {
        method( (a, b) -> { return a + b ;});
    }
    private static void method(Calculator calc){
        int result = calc.sum(1,2);
        System.out.println(result);
    }
}

上面的表达式可以再简写

public class CalculatorLambdaFormat {
    public static void main(String[] args) {
    	// 带有参数类型
        //1.method( ( int a,  int b) -> { return a + b ;});
 
 		//省略参数类型
        //2.method( ( a,  b) -> { return a + b ;});

		//大括号语句有且只有一个，可省略大括号、return、分号
        //3.method( (a , b) -> a + b);
        method( (a , b) -> a + b);
    }
    private static void method(Calculator calc){
        int result = calc.sum(1,2);
        System.out.println(result);
    }
}

Lambda表达式的省略规则：
1.参数的类型可以省略，但是只能同时省略所有参数的类型，或者干脆都不省略，不能致谢个别参数的类型
2.如果参数有且仅有一个，那么小括号可以省略
3.如果大括号之内的语句有且仅有一个，那么无论有没有返回值，return、大括号和分好，都可以省略

Lambda表达式的使用前提：
1.必须保证有一个接口，而且其中的抽象方法有且仅有一个
2.必须具有上下文环境，才能推导出来Lambda对应的接口

Lambda表达式必须有上下文推导：
1.根据调用方法的参数推导得知Lambda对应的接口
2.根据局部变量的赋值来推导得知相应的接口

public class Lambda {
    public static void main(String[] args) {
        Runnable runnable = () -> System.out.println("执行。。。");
        new Thread(runnable).start();
    }
}

语法糖
Lambda表达式并不是匿名内部类的“语法糖”
语法糖：代码的写法更加简便，但其实原理不便。
例如：
1.方法当中的可变参数，底层仍然是一个数组
2.增强for循环用于java.lang.Iterable实现类型时，底层仍然是一个迭代器
3.自动装箱、自动拆箱

Lambda表达式和匿名内部类存在根本区别，并非语法糖
区别：

  1. 所需的类型不一样
    如果是匿名内部类，那么用接口、抽象类、普通的类
    如果是Lambda表达式，则必须是接口
  2. 使用的限制不同
    如果接口当中有且仅有一个抽象方法，那么可以使用Lambda表达式，也可以使用匿名内部类
    但是如果接口当中抽象方法不唯一，则只能使用匿名内部类，不能使用Lambda表达式
  3. 实现原理不同
    匿名内部类，其实就是一个类，编译之后，直接产生一个单独的.class字节码文件
    Lambda表达式，编译之后，没有单独的.class字节码文件，对应的字节码会再运行的时候才会动态生成

接口的组成部分

  1. 常量
  2. 抽象方法
  3. 默认方法 （修饰符default) java8
  4. 静态方法 java8
  5. 私有方法 java8

案例1：默认方法使用

public interface MyInterface {
    void method1();
    void method2();
    //现在需要重新定义一个方法，子类MyInterfaceImplA、MyInterfaceImplB都需要实现
    //void methodNew();
}

public class MyInterfaceImplA implements MyInterface{
    @Override
    public void method1() {
    }
    @Override
    public void method2() {
    }
    //重写接口的抽象方法
    @Override
    public void methodNew(){
    }
}

public class MyInterfaceImplB implements MyInterface{
    @Override
    public void method1() {
    }
    @Override
    public void method2() {
    }
    //重写接口的抽象方法
    @Override
    public void methodNew(){
    }
}

接口升级：本来是2个抽象方法，现在需要编程3个抽象方法
接口的实现类当中必须对接口所有的抽象方法都要覆盖重写，除非实现类是一个抽象类
根据设计模式当中的开闭原则：对扩展开放，对修改关闭
从java8开始，接口当中允许定义default默认方法
常量的修饰符：public static final （都可以省略）
抽象方法的修饰符：public abstract （都可以省略）
默认方法的修饰符：public default void（public可以省略，default不能省略）

可使用java8提供的默认方法，解决接口中无须让各个实现类不重写接口中的抽象方法，使用默认方法

public interface MyInterface {
    void method1();
    void method2();
    //现在需要重新定义一个方法
    //void methodNew();
}

public class MyInterfaceImplA implements MyInterface{
    @Override
    public void method1() {
    }
    @Override
    public void method2() {
    }
}

public class MyInterfaceImplB implements MyInterface{
    @Override
    public void method1() {
    }
    @Override
    public void method2() {
    }
}

测试方法

public class Demo {
    public static void main(String[] args) {
        MyInterface myInterface = new MyInterfaceImplA();
        //myInterface.method1();
        //myInterface.method2();
        myInterface.methodNew();
    }
}

案例2：静态方法使用

public interface Animal{
	public abstract void eat();// 抽象方法
	public static Animal getAnimal(){
		return new Cat();
	}
}

public class Cat implements Animal{
	public void eat(){
	}
}

public class Dog  implements Animal{
	public void eat(){
	}
}

public class Demo{
	public static void main(String[] args){
		Animal animal = Animal.getAnimal();
		animal.eat();
	}
}

集合接口的工厂静态方法：of
java8 当中接口中可以定义的静态方法
这个特性在java9中得以广泛应用

public static void main(String[] args) {
        //普通写法
        List<String> list = new ArrayList<>();
        list.add("曹操");
        list.add("刘备");
        list.add("关羽");
        list.add("张飞");
        System.out.println(list);

        //匿名内部类
        List<String> list2 = new ArrayList<String>(){
            {
                add("曹操");
                add("刘备");
                add("关羽");
                add("张飞");
            }
        };
        System.out.println(list2);

        //java 9 写法
        //静态
        //list
        List<String> list3 = List.of("aa","bb","cc","dd");
        System.out.println(list3);

        //set
        Set<String> set = Set.of("aa","bb","cc","dd");
        System.out.println(set);

        //map
        Map<String,Object> map = Map.of("k1","v1");
        System.out.println(map);
    }
_谁_
关注
更换JDK版本11-＞8_java学习笔记day01
c_x_y_1的博客
12-12 1356
JAVA学习笔记day01-更换JDK版本 更换JDK版本方法： jdk11->jdk8 1.背景： 原本安装的最新版本jdk11，但是在写一些代码的时候发现报错，据说是jdk11的原因，干脆就把它换成jdk8.毕竟jdk8 适合大多数情况，新特性学习一下就OK了。 2.具体步骤 （1）删除原jdk11的环境配置 JAVA_HOME。步骤如下 此电脑（右键）->属性->高级系统配置 环境变量->删除JAVA_HOME和path内关于JAVA_HOME相关的2个配置。 （2）
day22_JDK8新特性.pdf
11-02
在Java世界中，JDK8是一个重要的里程碑，因为它引入了许多创新特性和改进，极大地提升了开发效率。其中最引人注目的特性之一就是Lambda表达式，它是对函数式编程思想的一种实现。函数式编程强调的是“做什么”而非...
jdk9新特性学习（一）
weixin_44796147的博客
10-25 267
// jdk8 --> jdk9 目录结构的变化 jdk9中不再有jre文件夹，而是将jre中的文件放至根目录中 模块化系统 jdk8中JVM在运行时必须要加载rt.jar文件，使得java运行环境臃肿。 模块化根据不同模块加载程序运行需要的class，本质上是在package外再加一层module，通过模块管理包，使得： 代码组织更安全：不同module之间无法直接访问，但可以通过导入新建module-info.java暴露出目标包 // java9demo1包对外暴露 module java9
JDK8新特性相关知识讲解汇总
纵横的博客
04-29 468
以下是博主本人对jdk8相关新知识的学习以及讲解的汇总，如果对你帮助可以多多点赞和关注我哦~ （1）JDK8新特性—Lambda表达式详细介绍以及应用 （2）JDK8 关于中断线程的总结 （3）JDK8 lambda表达式对集合List的操作 （4）详细讲解JDK 8新特性之Optional类重点知识，一篇就够了！ （5）JDK 8对时间日期应用的改进详解 ...
了解JShell脚本工具
ToughCY的博客
09-19 296
JShell脚本工具是JDK9的新特性 什么时候会用到 JShell 工具呢，当我们编写的代码非常少的时候，而又不愿意编写类，main方法，也不愿意去编译和运 行，这个时候可以使用JShell工具。 启动JShell工具，在DOS命令行直接输入JShell命令。 接下来可以编写Java代码，无需写类和方法，直接写方法中的代码即可，同时无需编译和运行，直接回车即可。 注意: JShell工具，只适合片段代码的测试，开发更多内容，建议编写在方法中。 ...
JDK9初体会心得
johnLee的专栏
03-01 1705
JDK9的新特性 1. 轻量级的JSON API ; 2. HTTP 2 Client API ( 支持 HTTP 2.0 和 WebSockets , 替代传统的 HttpURLConnection ) ; 3. Process API 更新 , 以提升对操作系统进程的控制和管理 ; 4. Improve contended locking , 提升访问对象时的线程竞争处理 ; 5
jdk9新特征系列
lizhengjava的博客
11-02 6436
（一）：jdk和jre的改变 JDK和JRE已经在Java SE 9中进行了模块化处理。在Java SE 9之前，JDK构建系统用于生成两种类型的运行时映像 ——Java运行时环境（JRE）和Java开发工具包（JDK）。 JRE是Java SE平台的完整实现，JDK包含了JRE和开发工具和类库。 可下图显示了Java SE 9之前的JDK安装中的主目录。JDK_HOME是安装JDK
JDK9-21新特性概览（持续更新）
weixin_43626356的博客
05-28 1247
记录JDK9-21之间的新特性
32位jdk jdk-7u79-windows-i586.zip
09-17
Java Development Kit（JDK）是Java编程语言的核心组件，它为开发者提供了编译、调试和运行Java应用程序所需的所有工具。...对于新手和经验丰富的开发者来说，熟悉JDK的使用和配置都是学习Java编程的基础。
Java jdk1.7.0-x64
03-13
下载并解压Java JDK 1.7.0-x64后，设置环境变量PATH和JAVA_HOME，确保系统能够找到JDK的bin目录，这样就可以在命令行中使用javac编译器和java解释器了。文件列表中的“jdk1.7.0_51”可能是一个具体的更新版本，包含...
Lambda表达式——函数式编程思想
henrly的博客
08-10 982
目录1. 函数式编程思想概述2. 冗余的Runnable方法传统写法代码分析做什么，而不是怎么做3. 体验Lambda的更优写法 4. 回顾匿名内部类使用实现类使用匿名内部类匿名内部类的好处与弊端语义分析5. Lambda标准格式6.练习使用Lambda表达式6.1 使用Lambda标准格式（无参无返回）题目解答6.2 Lambda的参数、返回值传统写法代码分析Lambda写法6.3 Lambda...
参考学习编译OpenJDK9
mogusuntou的博客
10-24 3021
折腾了一晚上编译OpenJDK7失败了，不甘心，换成9再战一波。 1.openjdk代码由hg管理，奈何下载太慢，去github上找了个仓库，clone了一发。 git clone https://github.com/campolake/openjdk9.git 2.安装ccache提高编译速度 brew install cache 3. ./configure不通过 could n
JDK9 新特性详解
雨陆聪辰的博客
07-29 5772
JDK9 新特性详解
山东交通学院在江西2020-2024各专业最低录取分数及位次表.pdf
10-02
那些年，与你同分同位次的同学都去了哪里？全国各大学在江西2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
西京学院在江西2020-2024各专业最低录取分数及位次表.pdf
10-02
那些年，与你同分同位次的同学都去了哪里？全国各大学在江西2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
山西师范大学在江西2020-2024各专业最低录取分数及位次表.pdf
最新发布
10-02
那些年，与你同分同位次的同学都去了哪里？全国各大学在江西2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
沈阳工业大学在江西2020-2024各专业最低录取分数及位次表.pdf
10-02
那些年，与你同分同位次的同学都去了哪里？全国各大学在江西2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
基于Arduino平台的自动寻找物品设计源码
10-02
该项目是一款基于Arduino平台的自动寻找物品设计源码，包含302个文件，包括148个头文件、136个C语言源文件、3个Markdown文件、3个JSON文件、3个包含文件、2个C语言扩展文件、2个压缩文件、2个汇编文件、1个Git忽略文件、1个Arduino源代码文件。该系统旨在实现物品的自动定位和寻找。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值