Java 8 新特性(1)

【Java】jdk1.8新特性及用法总结 Java8新特性及用法总结1. 接口中的实现方法2. Lambda 表达式3. 方法引用 ::4. 函数式接口 × 4① Predicate 接口(断言、返回真假)② Consumer 接口(消费、有去无回)③ Supplier 接口(创造、无中生有)④ Function 接口(传递、返回数据)5. (未完待续) 1. 接口中的实现方法 ① 使用 default 关键字就可以给接口增加一个非抽象的... 阅读详情

目录

1. 允许在接口中有默认方法实现

Java 8允许我们使用default关键字在接口中添加非抽象的方法实现,这个特性也称为扩展方法。

/**
 * Java 8新特性:允许使用default关键字在接口中添加非抽象的方法实现
 * 在接口中除了定义抽象方法query外,还定义了一个默认方法printUsername,该类的实现类只需要实现抽象方法query,在实现类中可以直接调用默认方法;
 */
public interface DefaultMainFieldExample {

    void query(String id);

    default void printUsername(String username) {
        System.out.println(username);
    }
}
/**
 * default默认关键字实现类
 * 在实现类中可以直接调用父类定义的默认方法
 */
public class DefaultMainFieldExampleImpl implements DefaultMainFieldExample {

    @Override
    public void query(String id) {
        System.out.println(id);
    }

    public static void main(String[] args) {
        DefaultMainFieldExampleImpl defaultMainFieldExample = new DefaultMainFieldExampleImpl();
        defaultMainFieldExample.query("001");
        // 直接调用父类定义的默认方法
        defaultMainFieldExample.printUsername("default");
        
		// 匿名对象
		DefaultMainFieldExample mainFieldExample = new DefaultMainFieldExample() {
            @Override
            public void query(String id) {
                printUsername(id);
            }
        };
        mainFieldExample.query("002");
        mainFieldExample.printUsername("default");
    }
}

2. Lambda表达式

先从一个简单的例子说起,如何对一个String列表排序;

// JDK 8以前的方式
// Collections.sort接收一个集合以及比较接口Comparator作为输入参数,可以指定一个匿名对象作为参数传递值
List<String> names = Arrays.asList("Java", "Python", "JavaScript");
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
});

在Java 8中提供了一种相较于匿名对象更简洁的方法:Lambda表达式;

// Lambda表达式
// 适用于接口只有且只有一个"抽象"方法,Lambda表达式必须与抽象方法的声明相匹配
// 如果实现代码只有一行,可以省略大括号以及return关键字
// Java编译器会自动识别参数类型,可以省略参数类型
// IDEA推荐不要直接对象比较(针对该例中的字符串比较)
// Collections.sort(names, (String a, String b) -> b.compareTo(a));
Collections.sort(names, (String a, String b) -> {
    return b.toLowerCase().compareTo(a.toLowerCase());
});
Collections.sort(names, (String a, String b) -> b.toLowerCase().compareTo(a.toLowerCase()));
Collections.sort(names, (a, b) -> b.toLowerCase().compareTo(a.toLowerCase()));

3. 函数式接口

Lambda表达式是如果精确匹配Java的类型系统的呢?

1.每一个Lambda表达式都通过一个特定的接口,和一个给定的类型匹配;
2.函数式接口:每一个函数式接口都有且只有一个抽象方法声明,每个与之对应的Lambda表达式必须要与抽象方法的声明相匹配;
3.默认方法不是抽象的,可以添加任意的默认方法;
4.任意只包含一个抽象方法的接口,我们都可以用来做成Lambda表达式;
5.@FunctionalInterface注解,约束接口中只能有一个抽象方法,否则抛出编译器错误;

// @FunctionalInterface注解:约束接口中只能有一个抽象方法,否则抛出编译器错误;可省略
@FunctionalInterface
public interface LambdaInterface<F, T> {

    T convert(F from);

    default void printTip(String username) {
        System.out.println(username);
    }
}
// 函数式接口
// Lambda如果匹配Java的类型系统?
// 每一个函数式接口都必须包含一个精确的抽象方法声明,接口的每个Lambda表达式都必须与该方法的声明相匹配
// 默认方法不是抽象的,可以添加任意的默认方法
// 只要满足函数式接口的定义:有且仅有一个抽象方法,就可以对任意接口作为Lambda表达式
// @FunctionalInterface注解,约束接口中只能有一个抽象方法,否则抛出编译器错误
LambdaInterface<String, Integer> lambdaInterface = (from) -> Integer.valueOf(from);
lambdaInterface.printTip("Lambda");
Integer integer = lambdaInterface.convert("003");
System.out.println(integer);

4. 方法和构造函数引用

Java 8允许通过关键字"::"获取方法或者构造函数的引用;

// 方法和构造函数引用
// Java 8允许通过"::"关键字获取方法和构造函数的引用
// 说明:使用"::”关键字时,只适用于仅一个参数的方法,构造函数除外;
// 静态方法引用
LambdaInterface<String, Integer> integerLambdaInterface = Integer::valueOf;
System.out.println(integerLambdaInterface.convert("004"));

// 对一个对象的方法引用
SomeThing someThing = new SomeThing();
LambdaInterface<String, String> stringLambdaInterface = someThing::startWith;
System.out.println(stringLambdaInterface.convert("Lambda"));
// 静态方法引用
LambdaInterface<String, String> endWithLambdaInterface = SomeThing::endWith;
endWithLambdaInterface.convert("Lambda");

// 对构造函数的引用
PersonFactory<Person> personFactory = Person::new;
personFactory.create("Jack", "Rose");

class SomeThing {
    public String startWith(String startWith) {
        return String.valueOf(startWith.charAt(0));
    }

    public static String endWith(String endWith) {
        return String.valueOf(endWith.charAt(0));
    }

    public static String subString_0(String subString, int start, int end) {
        return subString.substring(start, end);
    }

    public static String subString_1(String subString) {
        return subString.substring(0, 1);
    }

    public static String subString_2(String subString, int start) {
        return subString.substring(start);
    }
}

class Person {
    private String firstName;
    private String lastName;

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

interface PersonFactory<P extends  Person> {
    P create(String firstName, String lastName);
}

5. Lambda的范围

5.1 访问局部变量

Lambda表达式可以访问外部的的final局部变量;

// 访问外部final局部变量
final int finaNum = 1;
LambdaInterface<Integer, String> lambdaInterfaceFinal = (from -> String.valueOf(finaNum + from));
System.out.println(lambdaInterfaceFinal.convert(2));

// 和匿名对象不一样的地方在于:局部变量不一定要是final
int finalNum = 2;
LambdaInterface<Integer, String> lambdaInterface = (from -> String.valueOf(finalNum + from));
System.out.println(lambdaInterface.convert(3));

// 虽然Lambda访问的外部变量不一定需要定义为final,然鹅在编译的时候变量会被隐式的当做final变量处理
// 从Lambda表达式引用的本地变量必须是最终变量或实际上的最终变量
int finalNoChange = 3;
LambdaInterface<Integer, String> lambdaInterfaceNoChange = (from -> String.valueOf(finalNoChange + from));
System.out.println(lambdaInterfaceNoChange.convert(4));
// finalNoChange = 4;

5.2 访问成员变量和静态变量

在Lambda表达式的内部可以获取对成员变量或者静态变量读写权限;

public void lambdaGetClassVariable() {

    // 访问成员变量和静态变量  
    // 访问静态变量
    LambdaInterface<Integer, String> lambdaInterface1ClassStaticVariable = (from -> String.valueOf(staticNum
            + from));
    System.out.println(lambdaInterface1ClassStaticVariable.convert(7));

    // 访问成员变量
    LambdaInterface<Integer, String> lambdaInterface1ClassNonStaticVariable = (from -> String.valueOf(nonStaticNum
            + from));
    System.out.println(lambdaInterface1ClassNonStaticVariable.convert(8));
}

5.3 访问默认接口方法

默认方法在Lambda表达式中无法访问;

6. 内置函数式接口

JDK 8 API中的函数式接口

6.1 Predicate

Predicate是一个布尔类型的函数,该函数只有一个输入参数。Predicate接口包含了多种默认方法;

public static void main(String args[]) {

    // Predicate是一个布尔类型的函数,该函数只有一个输入参数。Predicate接口包含了多种默认方法,
    // 用于处理复杂的逻辑动词(and, or,negate)
    // 函数式接口方法 - test
    Predicate<String> predicate = s -> s.length() > 0;
    System.out.println(predicate.test("Lambda"));

    // 默认方法 - and
    Predicate<String> predicate1And = s -> s.indexOf("mb") > 0;
    System.out.println(predicate1And.test("lambda"));
    // 连用
    System.out.println(predicate.and(predicate1And).test("JDK-8-Lambda"));

    // 理解:该默认方法的return其实也是一个Lambda表达式,返回一个布尔类型的参数给Predicate对象接收
    // default Predicate<T> and(Predicate<? super T> other) {
        // Objects.requireNonNull(other);
        // 这里的返回其实也是一个Lambda表达式,返回一个布尔类型的参数(or方法也类似)
        // return (t) -> test(t) && other.test(t);
    // }

    // 默认方法 - negate
    Predicate<String> predicate1Negate = s -> s.length() > 0;
    System.out.println(predicate1Negate.negate().test("Predicate.negate"));

    // 默认方法 - or
    Predicate<String> predicate1Or = s -> s.length() > 0;
    System.out.println(predicate1Or.or(predicate1Negate).test("or"));

    // 静态方法 - isEqual
    Predicate<String> predicate1IsEqual = Predicate.isEqual("Lambda");
    predicate1IsEqual.test("Lambda");

    // Predicate - 静态方法实现
    Predicate<Boolean> nonNull = Objects::nonNull;
    System.out.println(nonNull.test(true));
    Predicate<Boolean> isNull = Objects::isNull;
    System.out.println(isNull.test(false));
    Predicate<String> isEmpty = String::isEmpty;
    System.out.println(isEmpty.test("   "));
    Predicate<String> isNotEmpty = isEmpty.negate();
    System.out.println(isNotEmpty.test("Lambda"));
}

Predicate源码查看:
Predicate

6.2 Functions

Function接口接收一个参数,并返回单一的结果,默认方法可以将多个函数串联在一起;

public static void main(String args[]) {

    // Function接口接收一个参数,并返回单一的结果
    Function<String, String> stringFunction = s -> s.substring(1);
    System.out.println(stringFunction.apply("stringFunction"));

    Function<String, Integer> integerFunction = s -> s.length();
    System.out.println(integerFunction.apply("integerFunction"));

    // andThen
    Function<String, Integer> andThenFunction = Integer::valueOf;
    Function<String, String> applyFunctionAndThen = andThenFunction.andThen(String::valueOf);
    System.out.println(applyFunctionAndThen.apply("20200323"));

    // compose 
    Function<Integer, String> composeFunction = String::valueOf;
    Function<String, String> applyFunctionCompose = composeFunction.compose(Integer::valueOf);
    System.out.println(applyFunctionCompose.apply("20200323"));
}

Function源码查看:
Funtion

6.3 Supplier

Supplier接口产生一个给定类型的结果,Supplier没有输入参数;

public static void main(String args[]) {

    // Supplier接口产生一个给定类型的结果,Supplier没有输入参数
    Supplier<String> supplier = String::new;
    System.out.println(supplier.get());
}

6.4 Consumer

Consumer代表在一个输入参数上需要进行的操作;

public static void main(String args[]) {
	
    // Consumer代表在一个输入参数上需要进行的操作
    Consumer<String> consumer = s -> {
        s = s.substring(1);
        System.out.println(s);
    };
    consumer.accept("consumer");
}

/**
 * 源码 - Consumer
 */
 @FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);

    /**
     * andThen
     * @param after the operation to perform after this operation
     * @return a composed {@code Consumer} that performs in sequence this
     * operation followed by the {@code after} operation
     * @throws NullPointerException if {@code after} is null
     */
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

6.5 Comparator

Comparator接口接收两个参数,实现参数的比较,返回一个int类型的结果值;

public class DefaultFunctionInterfaceComparator {

    public static void main(String[] args) {
		// Person在之前已定义
        Comparator<Person> personComparator = (p_jack, p_rose) -> p_jack.getFirstName()
                .compareTo(p_rose.firstName);
        Person p1 = new Person("John", "Doe");
        Person p2 = new Person("Alice", "Wonderland");
        personComparator.compare(p1, p2);             // > 0
        personComparator.reversed().compare(p1, p2);  // < 0

    }
}

这节到此为止,欲知后事如何,请见下回分解哈!

Java 1.8 (JDK 1.8) 新特性实战指南与安装 Lambda表达式是Java 8中的一个核心特性,它提供了一种简洁的方式来表示匿名内部类。Lambda表达式允许我们将函数作为参数传递给方法,或者将代码作为数据进行处理。Lambda表达式的基本格式如下:Lambda表达式的出现,为Java带来了函数式编程的元素,使得代码更加简洁且易于阅读。Lambda表达式的特性主要包括以下几点:简洁性:Lambda表达式提供了更简短的语法来代替匿名类。类型推断:编译器可以根据上下文推断出Lambda表达式的参数类型和返回类型。无变量捕获。 阅读详情

相关推荐

Java JDK 1.8 64位:全面安装与新特性指南

Java开发工具包(JDK)是Java程序设计语言的核心组件,它允许开发者编写和运行Java程序。JDK 1.8 64位版本是Oracle公司在2014年发布的Java开发工具包的更新版,它引入了许多新的功能和改进,特别针对性能和开发效率。Java运行时环境(Java Runtime Environment,简称JRE)是运行Java程序所必需的环境的集合。它包括Java虚拟机(JVM)、Java核心类库以及Java命令和工具。

weixin_42577735的博客 791

Java-笔记15-复习

1.abstract 能修饰哪些结构? 修饰以后,有什么特点? 可以修饰:类、方法。 类不能实例化,提供子类 抽象方法,只定义了一种功能的标准。具体的执行,需要子类去实现。 2.接口是否能继承接口? 抽象类是否能实现(implements)接口? 抽象类是否能继承非抽象的类? 能,能,能 3. 声明抽象类,并包含抽象方法。测试类中创建一个继承抽象类的匿名子类的...

weixin_34199335的博客 303

PR控制以及使用PR控制用于单相离/并网逆变器

最近想学习一下并网逆变器,需要用到PR控制,全网找遍了许多学习资料,终于掌握的差不多了,在此做个记录,以及个人对PR(Proportional Resonant)控制的理解。在去年7月准备电赛的时候偶然看到有几篇讲解数字滤波器,第一次接触传递函数离散化,深刻被数字时代的数字方式折服,改改代码,就可以实现不同的截至频率,甚至不同阶数,而模拟方式还要改元器件。当时就感觉这玩意太他妈牛逼了,很想学懂它,奈何学不会呀。后面全身心做电赛,就忘了这事儿。直至最近学习PR控制,当初的感觉又回来了,一股劲儿吃下来了。

xht2403267701的博客 3万+

Java1.8新特性

原文 一、Java1.8新特性 1.Lambda表达式; 2.函数式接口; 3.方法引用和构造器引用; 4.Stream API; 5.接口中的默认方法与静态方法; 6.新时间日期API; 7.其他新特性。 二、Java1.8新特性简介 1.速度更快; 2.代码更少(新增了新的语法Lambda表达式); 3.强大的Stream API; 4.便于并行; 5.最大化减少空指针异常 Optional。 其中最为核心的是Lambda表达式与Stream API. 1.Lambda表达式 为什么使用Lambda表达

ss810540895的博客 1万+

Creo报错代码-9?手把手教你重新生成许可证文件(基于Creo 10.0)

本文详细解析Creo报错代码-9的成因及解决方案,重点介绍如何重新生成许可证文件以应对网络环境变化导致的验证失败。通过分步指南和高级技巧,帮助用户有效管理多网络环境下的Creo许可证问题,提升工作效率。

weixin_30839881的博客 565

标准化降水指数介绍

Mckee et al.(1993)认为降水量的减少是导致干旱的主要因素,其他气候因子一般变化较小,对干旱产生的影响不大,因此SPI使用降水量作为唯一参数。SPI能较好表达因降水量的大小反映干旱状况,操作简单,所需资料仅为降水量,同时该干旱指数在各个地区和各个时段都具有良好的计算稳定性,是继PDSI之后另一种被广泛应用的干旱指数。𝐻(𝑥)是Γ分布求得的概率,并当𝐻(𝑥)>0.5时,S=1;式中,𝛼是形状参数,𝛽是尺度参数,𝑥是当月降水量,𝛤(𝛼)是Gamma函数,用极大似然估计法计算最佳的𝛼和𝛽,即。

weixin_44259522的博客 2857

20分钟学会Java8新特性

Java8 - 新特性 1. Lambda表达式 为什么要使用Lambda表达式 Lambda 是一个匿名函数,我们可以把 Lambda 表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格,使Java的语言表达能力得到了提升。 1.1 Lambda表达式的使用举例 @Test public void test1(){ //未使用Lambda表达式之前 Runnable r1 = new Runnable() { //

JavaAlenboy 805

YooAsset 学习

YooAssets使用教程

weixin_44884538的博客 1659

java1.8新特性入门级讲解

java1.8引入了许多的特性,在此我们主要讨论一下几点: - **接口静态方法** - **接口默认方法** : 默认方法就是一个在接口里面有了一个或多个实现的方法。 - **函数式接口**: 一个在接口只有一个待实现的方法。 (重要) - **Lambda 表达式**: Lambda 允许把函数作为一个方法的参数(函数作为参数传递到方法中)。 (重要) - **Stream API**: 新添加的Stream API(java.util.stream) 把真正的函数式

我认不到你的博客 4642

英飞凌TC3xx--深度手撕HSM安全启动(三)--TC3xx HSM系统架构

TC3xx的HSM内核是一颗32位的ARM Cortex M3,主频可达100MHz,支持对称算法AES128、非对称算法PKC(Public Key Crypto) ECC256、Hash SHA2,以及TRNG(真随机数生成)。

认真搞搞汽车MCU 5749

Isaac Lab & GR00T N1 入门教程(七)人形机器人推理与技能学习策略基准测试

本文介绍了IsaacLab设计的工业机器人操作评估系统,包含两项任务:螺母倾倒(成功率91%)和排气管分拣(成功率95%)。系统支持通过IsaacGR00TN1模型进行策略闭环评估,提供完整的开发环境配置指南(需Ubuntu22.04、CUDA12.8等环境),数据集下载方式(HuggingFace平台托管),以及模型微调流程。评估支持并行化测试(建议10-30个并行环境),并给出详细硬件配置建议(推荐RTX A6000 Ada显卡)。文档还包含常见问题解决方案,特别说明当前暂不支持Blackwell GP

2506_90492529的博客 1119

JAVA8新特性(一)

最近需要进行java8新特性的技术分享,故将学习内容总结整理与大家分享

码农@攻城狮 486

微信公众平台 - 微信内置浏览器 WeixinJSBridge.invoke(‘xxx‘) API 报错:system:access_denied(常见于微信支付、分享朋友圈/转发好友等功能)解决方案

微信支付提示System:access_denied,调用微信支付返回:system:access_denied为什么,安卓版微信支付偶尔出现system:access_denied,微信公众号开发分享出现system:access_denied,system:access_denied如何解决?微信WeixinJSBridge.invoke(‘xxx‘)API调用后出现报错,微信内部H5WeixinJSBridge.invokesystem:access_denied,使用微信jssdk时报ac

🏆 前端领域优质创作者 5147

Java8(JDK1.8)新特性

1、速度快;2、代码少、简介(新增特性:lamdba表达式);3、强大的Stream API;4、使用并行流和串行流;5、最大化较少空指针异常Optional;其中最为核心的是Lambda表达式和Stream APILambda是一个匿名函数,我们可以将Lambda表达式理解为一段可以传递的代码(将代码像数据一样传递)。使用它可以写出简洁、灵活的代码。作为一种更紧凑的代码风格,使java语言表达能力得到提升。...

weixin_40294256的博客 5万+

智能运营模型的建设与运用实践

一项运营活动的全流程,主要包含客群挖掘与筛选、产品与权益选择、触点与活动选择、运营策略调优等关键环节,涉及客群管理、活动管理、权益管理、触达管理、智能调控等系统支撑需求,如今工商银行已开展与其相对应的推荐模型、分析模型等的研发与实践。自2023年9月该模型被知客运营平台吸收并上线以来,已累计有远程银行中心、吉林分行、重庆分行等30余家分行或机构使用,赋能融e借、积存金、结售汇、基金、理财、存款等12种场景,产生营销客户清单达千万人次,有力促进了保守型理财、天天盈、添益快线、寿险等产品的销售。

银行信息系统应用架构详解 853

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

Java中JDK 1.7和JDK 1.8新特性问题

JDK 1.7的部分新特性如下:   1)switch可以接受Stringe类型。随着Java语言的发展,在java7中,开始支持String类型。 public class Switch { public void test(String str) { switch (str) { case "computer": System.out.println("computer...

weixin_38894058的博客 1725

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

Java1.8 新特性之数组遍历

Java1.8 新特性之数组遍历 数组判空 Optional.ofNullable(变量).orElse(变量为空时给对象赋的值); 数组遍历 list.forEach(l->{System.out.println(l)}) 相对于传统的for循环去遍历数组,java 1.8新特性更加简洁方便。 ...

y1_z_l的博客 1243

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

JAVA1.8新特性

JAVA1.8新特性 Steam流 foreach map filter limit sorted parallel Collectors 统计 Steam流 其作用可以让你以一种声明的方式处理数据. 这种风格将要处理的元素集合看作一种流, 流在管道中传输, 并且可以在管道的节点上进行处理, 比如筛选, 排序,聚合等. 例子将流进行转换 : stream of elements +-----> |filter+-> |sorted+-> |map+-&gt.

wlxiarui的博客 231

Java1.8新特性学习

Java1.8新特性: 1. 接口可以定义具体的实现方法,方法前添加default,如:default void test2 () {System.out.println("具体方法");},这个default方法是所有的实现类都不需要去实现的就可以直接调用; 2. lambda表达式:函数式编程,能够简化代码的开发,如: @Test public ...

左上晨的博客 446

java jdk 1.8特性_Java JDK 1.7 和 JDK 1.8 新特性

引言本文主要介绍 Java JDK 中 1.7 和 1.8 的新特性。JDK 1.7 新特性1. switch可以接受String类型;public class Switch {public void test(String str) {switch (str) {case "computer":System.out.println("computer");break;case "book":Sy...

weixin_39574943的博客 282

Java JDK 1.7 和 JDK 1.8 新特性

引言   本文主要介绍 Java JDK 中 1.7 和 1.8 的新特性。 JDK 1.7 新特性   1. switch可以接受String类型; public class Switch { public void test(String str) { switch (str) { case "computer": System.out.println("c...

weixin_30628077的博客 153

Java版本特性 之 1.8 新特性

Java 1.8(也称为Java 8)引入了一系列重要的新特性和改进,这些特性提升了Java编程的效率和可读性。本文将介绍Java 1.7升级到1.8的所有新特性,包括设计思路和示例代码。

全栈工程师,热爱编程,喜欢探索各种技术栈。分享前端、后端、数据库等技术学习心得,以及在项目开发中的实践经验。 948

Java基础-序列化、泛型、1.8新特性、其他

Java基础-序列化、泛型、1.8新特性、其他

m0_50846237的博客 1295

Java1.8新特性方法引用

Java1.8新特性方法引用 简述 方法引用(::)是JDK1.8的新特性: 可以使用方法引用来优化Lambda表达式,(我觉得Lambda已经是很简化的格式了,但是这个玩意把Lambda都简化了,太牛掰,初期理解可能有难度,但是习惯了是真的爽)如下格式: new Object() 可以简写为 Object::new(就是把new放后头了,参数自动传递了) Object.method(a,b) 可...

zezea的博客 394
上一篇: Java中的异常处理机制
天真有邪
博客等级 码龄10年 3粉丝 20原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值