JavaSE（十六）Java8新特征

最新推荐文章于 2021-03-18 14:31:56 发布
最新推荐文章于 2021-03-18 14:31:56 发布
阅读量196 收藏
点赞数
分类专栏： # JavaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oDiQiuTaiWeiXian/article/details/100132714
版权

文章目录

接口的非抽象方法

  接口是对功能的说明而不是对功能的实现，所以接口只能包含抽象方法，但从Java8开始，接口却可以包含非抽象方法（默认方法和静态方法）。
　　接口的默认方法就是用default修饰的普通方法，它包含了函数体，提供默认方法的目的就是为了减少子类实现接口的工作量。Java的一大特点就是单继承，单继承让编程者从复杂的继承关系中解脱出来（复杂的继承关系会让产生Bug的几率大幅度上升），接口如果能够有默认实现，那么又会将编程者扔进复杂的继承关系中。在Java8的核心包中，很多原有的接口被添加了若干个新的功能（特别是集合框架下的接口），为了减少子类重新实现这些接口的工作量，添加了默认方法这一语法。可见，默认方法是Java核心包的开发者为了偷懒而做的妥协，在实际应用中，尽量不要使用默认方法这一语法。
　　接口的静态方法和普通类的静态方法拥有相同的语法结构，用static修饰且包含了函数体，类的静态方法虽然无法体现出多态，但可以被继承，而对于接口来说，无论是其子接口还是其实现类，静态方法都不能被继承。

Lambda表达式

函数式接口

  有且仅有一个抽象方法的接口（可以有多个非抽象方法）就是函数式接口。可以使用@FunctionalInterface对函数式接口进行标识，该注解会在编译时检查当前接口是否满足函数式接口的条件，函数式接口并不强制要求必须使用该注解进行标识，就像使用@Override来标识重写函数一样。可见，除了可有可无的@FunctionalInterface注解以外，函数式接口并没有添加新的语法，只是对满足特殊条件的接口进行了概念上的新定义。
　　函数式接口的用法和普通接口的用法完全一样，提出函数式接口的定义主要是为了实现Lambda表达式。在Java中内置了一些比较常用的函数式接口，以便在接收Lambda表达式时，可以方便地利用已存在的，满足条件的函数式接口（满足条件主要指参数类型和个数以及返回类型，而与接口名和方法名无关），如果这些函数式接口都无法满足需求，依然需要自定义函数式接口。Java中部分内置的函数式接口如下：

接口抽象函数说明
Consumer<T>void accept(T t)消费型接口
BiConsumcr<T, U>void accept(T t, U u)
Supplier<T>T get()供给型接口
Function<T, R>R apply(T t)函数型接口
BiFunction<T, U, R>R apply(T t, U u)
UnaryOperator<T>T apply(T t)
BinaryOperator<T>T apply(T t1， T t2)
ToXxxFunction<T>xxx applyAsXxx(T t)xxx可取int、long、double
XxxFunction<R>R apply(xxx value)xxx可取int、long、double
Predicate<T>boolean test(T t)断言型接口

Lambda表达式

  Lambda表达式虽然在语法上表现为一个表达式，但实际上会被编译为一个实现了某函数式接口的匿名内部类，其语法结构为：(参数列表)->{代码}，其中，参数列表在类型和个数上必须和函数式接口中唯一抽象方法的参数列表保持一致（参数名可以不同），而这里的代码将会作为该抽象方法的函数体。
　　Lambda表达式必须要赋值给一个函数式接口类型的变量（成员变量、局部变量或函数参数），其原因有两点：首先，只有赋值给一个函数式接口，才能确定该Lambda表达式被编译为实现了哪个函数式接口的匿名内部类；其次，Lambda表达式不会自动执行函数体中的代码，必须具有进行方法调用的句柄。大多数时候，Lambda表达式被赋值给一个方法的参数（函数式接口类型），这时在方法中回调函数式接口就可以执行Lambda表达式的代码，由于接口中可以存在非抽象方法，所以可以通过非抽象方法调用抽象方法（Lambda表达式只能实现抽象方法）来实现功能的封装（模板方法模式），这时可以通过回调函数式接口的非抽象方法来执行Lambda表达式的代码。
　　Lambda表达式的基本语法结构为：(参数列表)->{代码}，其中，参数列表的参数类型可以省略，因为可以根据其代表的抽象方法推导出参数类型（省略参数类型通常是编程人员更喜欢的编程方式），如表达式(int a, String b)->{}可以简写为(a, b)->{}。Java还提供了很多其他的语法糖来实现某些特殊的Lambda表达式：

  1. 省略()，如a->{…}，代表(a)->{…}，有且仅有一个参数时的语法糖
  2. 省略{}，如(…)->表达式，有且仅有一条表达式时的语法糖，当表达式为函数且无返回值时，代表(…)->{表达式;}，当表达式为其他形式时（如有返回值的函数、普通的运算表达式等），代表(…)->{return 表达式;}

  在Lambda表达式的代码块中，不但可以使用代码块中的变量、参数列表中的形参，还可以使用Lambda表达式所在类中的成员变量，以及Lambda表达式所在位置可见的局部变量（会自动将局部变量的定义修改为final修饰）。

方法引用

  方法引用是Lambda表达式的一种特殊表现形式，通过指向一个已实现的方法来与函数式接口进行绑定，它可以使语言的构造更紧凑简洁，减少冗余代码。方法引用的主要格式如下：

  1. 实例::实例方法名，如instance::fun，等效于(X x, Y y…)->instance.fun(x, y…)
  2. 类名::静态方法名，如MyClass::fun，等效于(X x, Y y…)->MyClass.fun(x, y…)
  3. 类名::实例方法名，如MyClass::fun，等效于(MyClass clazz, X x…)->clazz.fun(x…)
  4. 类名::new，如MyClass::new，等效于(X x, Y y…)->new MyClass(x, y)

  被引用方法的参数列表与其函数式接口方法的参数列表必须具有严格的对应关系。

集合新特征

可迭代对象的遍历

  对于可迭代的类（实现了Iterable接口的类，如集合），可以通过Iterator来进行元素的遍历，而在Java8中，又引入了新的遍历方式，那就是通过Iterable的forEach方法。forEach函数的参数是一个函数式接口，该函数式接口的抽象方法的参数，就是每次被迭代处理的元素，可以用Lambda表达式来对每次迭代的元素进行处理，如iterableObject.forEach(e->{…对本次迭代的元素e进行处理…})。通过Iterator来进行迭代，需要自己手动写for循环语句，这种迭代方式被叫着外部迭代；提供函数并在函数内部进行循环，只需要传递针对各个元素进行处理的处理对象给函数，这种迭代方法叫着内部迭代。

public interface Iterable<T> {
    Iterator<T> iterator();
    
    default void forEach(Consumer<? super T> action) {
        for (T t : this) {
            action.accept(t);
        }
    }
}

列表排序

  对于列表的排序，可以使用工具类Collections的静态方法sort，而在Java8中，又提供了对列表进行排序的新方法，那就是List的sort方法。sort方法只接收一个Comparator参数来对元素进行比较（排序本来就是以比较作为基础的），由于Comparator本身是个函数式接口，所以可以用Lambda表达式来对元素进行比较，如listObject.sort((a, b)->{…a与b进行比较，并返回比较结果…})。

public interface List<E> extends Collection<E> {
	default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }
    ...
}

Stream

  Stream使用一种类似SQL语句的直观方式来提供一种对Java集合进行运算和表达的高阶抽象，这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。
　　每个流都绑定着一个数据源（集合、阵列、IO、生成函数等），但它不会改变数据源，只是按照特定的规则对数据进行处理，如同SQL中的select语句。流的处理分为中间处理和最终处理，中间处理会将流进行处理并返回一个新的流（新的流绑定着一个新的数据源），最终处理才是为了得到最后的结果，流的存在只是作为处理数据源的一种工具，所以如果没有最终处理，再多的中间处理都是没有意义的。每一次流操作，应该包含数据源、零次或多次中间处理、一次最终处理，只有在执行最终处理时，流操作才会真正的执行。

public interface Stream<T> extends BaseStream<T, Stream<T>> {
    Stream<T> filter(Predicate<? super T> predicate); // 过滤
    Stream<T> sorted(Comparator<? super T> comparator); // 排序
    Stream<T> sorted(); // 对实现了Comparable的元素进行排序
    Stream<T> limit(long maxSize); // 最多保留maxSize个元素
    Stream<T> distinct(); // 根据元素的equal方法去重
    Stream<T> peek(Consumer<? super T> action); // 新流与原流数据完全相同，但在新流中执行最终操作前，会先对每个元素执行action操作，常用于并行流的同步控制
    Stream<T> skip(long n); // 忽略n个元素，由其他元素组成新流
    
    // 将流中的每一个数据都进行特定的处理，然后组成新的流
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);
    IntStream mapToInt(ToIntFunction<? super T> mapper);
    LongStream mapToLong(ToLongFunction<? super T> mapper);
    DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);
    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper); // 每一个元素进行处理后都能得到一个流，最后把所有流进行合并得到新流，例如已有一个学校的班级流，mapper就是根据班级流的每一个班级得到该班级的学生流，那么该方法最后得到的是学校的学生流
    IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);
    LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper);
    DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper);
    
    boolean allMatch(Predicate<? super T> predicate); // 所有元素都满足条件时返回true，否则false
    boolean anyMatch(Predicate<? super T> predicate); // 只要有元素满足条件就返回true，否则false
    boolean noneMatch(Predicate<? super T> predicate); // 没有任何元素满足条件时返回true，否则false
    
    // 对流中的各个元素进行处理
    void forEach(Consumer<? super T> action); // 在并行流中无法保证消费元素的顺序
    void forEachOrdered(Consumer<? super T> action); // 在并行流中也能保证消费元素的顺序
    
    // 将流处理为一个最终数据，reduce适用于以返回值的方式得到处理结果，collect适用于以参数的方式得到处理结果
    T reduce(T identity, BinaryOperator<T> accumulator); // accumulator的apply方法返回处理结果，apply方法参数分别为上一次处理的结果和新的迭代元素，identity为上一次处理结果的初始值（在迭代第一个元素时使用）
    Optional<T> reduce(BinaryOperator<T> accumulator); // 第一次迭代的结果就是第一个元素，从第二个元素开始使用accumulator
    <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner); // 对于并行流和串行流，该方法展现出完全不同的行为
    				// 对于串行流，第三个参数被忽略，计算方式与两个参数的reduce方法相似，只是处理的结果类型不一定与原流的元素类型相等
    				// 对于并行流，会先使用accumulator对每一个元素进行一次处理得到新的流（必然与原流个数相等），然后使用combiner消费新的流中的任意两个元素并将结果加入新流，直到新流中只有一个元素为止
    <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner); // 对于并行流和串行流，该方法展现出完全不同的行为
    				// 对于串行流，第三个参数被忽略，supplier只会产生一个容器，accumulator处理的第一个参数就是supplier产生的唯一容器
    				// 对于并行流，先对每一个元素都调用accumulator处理（方法的第一个参数每次都由supplier新产生，最后将产生的supplier组成一个新的流），然后使用combiner消费新的流中的任意两个元素（第一个元素会保留在新流中），直到新流中只有一个元素
    <R, A> R collect(Collector<? super T, A, R> collector); // collector是对具有三个参数的collect方法的参数的封装，Collectors提供了许多常用的collector，比如将Stream转换为list
    
    long count(); // 统计流中元素个数
    Optional<T> findFirst(); // 返回第一个元素，如果是无序流，返回的可能是任一元素
    Optional<T> findAny(); // 返回任一元素
    Optional<T> min(Comparator<? super T> comparator); // 返回最小元素
    Optional<T> max(Comparator<? super T> comparator); // 返回最大元素
    
    // 创建Stream并关联数据源，我们常用Collection的stream方法来创建串行流或parallelStream方法来创建并行流（流关联的数据源就是当前Collection）
    public static<T> Builder<T> builder(); // 通过builder的方式创建流
    public static<T> Stream<T> empty(); // 绑定的数据源为空数据
    public static<T> Stream<T> of(T... values); // 绑定的数据源为values
    public static<T> Stream<T> generate(Supplier<T> s); // 创建一个流，每次获取元素时通过提供者生成元素
    public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b); // 将两个流合并为一个流
}

public interface BaseStream<T, S extends BaseStream<T, S>> extends AutoCloseable {
    Iterator<T> iterator(); // 返回对流的迭代器
    boolean isParallel(); // 是否是并行流
    S sequential(); // 返回等效的串行流，当前流是串行流时返回本身
    S parallel(); // 返回等效的并行流，当前流是并行流时返回本身
    S unordered(); // 返回等效的无序流
    S onClose(Runnable closeHandler); // 关闭流时的额外操作
    void close(); // 关闭流
}

  几个将集合进行过滤的例子，帮助理解流的各个方法：

// 最常用的方法
public static  List<String> normal(Stream<String> stream, String start) {
    return stream.filter(e->e.startsWith(start)).collect(Collectors.toList());
}

public static List<String> reduce(Stream<String> stream, String start) {
    if (stream.isParallel()) {
        return stream.reduce(new ArrayList(),
                (x, e)->{
                    ArrayList<String> list = new ArrayList<>();
                    if (e.startsWith(start)) list.add(e);
                    return list;
                },
                (x1, x2)-> {
                    x1.addAll(x2);
                    return x1;
                }
        );
    }

    return stream.reduce(
            new ArrayList<String>(),
            (list, e)->{
                if (e.startsWith(start))
                    list.add(e);
                return list;
             },
            (x, y)->null
    );
}

public static List<String> collect(Stream<String> stream, String start) {
    if (stream.isParallel()) {
        return stream.collect(ArrayList::new,
                    (list, e)->{
                        if (e.startsWith(start))
                            list.add(e);
                    },
                    (list1, list2)->{
                        list1.addAll(list2);
                    }
                );
    }

    return stream.collect(ArrayList::new,
                (list, e)->{
                    if (e.startsWith(start))
                        list.add(e);
                },
                (x, y)->{}
            );
}

Optional

  Optional对象是一个可以存放单个对象的容器，它可能存放了一个对象，也可能没有存放任何对象（存放的null值被当做没有存放对象）。

public final class Optional<T> {
    public static<T> Optional<T> empty(); // 创建一个空的Optional
    public static <T> Optional<T> of(T value); // 创建一个存放了value的Optional，value不能为null，否则抛出异常
    public static <T> Optional<T> ofNullable(T value); // value为null时等同于empty()，否则等同于of(value)
    public boolean isPresent(); // 是否存放了对象
    public T get(); // 返回存放的对象，若未存放对象抛出异常
    public T orElse(T other); // 返回存放的对象，若未存放对象就返回other
    public T orElseGet(Supplier<? extends T> other); // 返回存放的对象，若未存放对象就由other生成一个对象返回
    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X; // 返回存放的对象，若未存放对象则抛出由exceptionSupplier生成的异常
    public Optional<T> filter(Predicate<? super T> predicate); // 如果存放了对象且对象满足predicate则返回该Optional，否则返回空Optional对象
    public void ifPresent(Consumer<? super T> consumer); // 如果存放了对象就用consumer来处理，否则不做任何操作
    public<U> Optional<U> map(Function<? super T, ? extends U> mapper); // 如果存放了对象则对存放的对象进行处理得到一个新的对象，并将对象存放到一个Optional返回，否则返回空Optional
    public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper);
}

新的日期与时间API

  在Java8之前，通过java.util.Date与Calendar来处理日期和时间，在Java8中，对日期和时间模块进行了大幅度的重构，主要包含了以下新的类：

  • 时间戳Instant、时钟Clock，时间戳就是时刻，同一时刻在不同的时区表现为不同的时间，而时钟主要用于获取当前的时间戳
  • 时区时间ZonedDateTime，某一时刻在某一时区表现出来的时间，是时间戳的一种表现形式
  • 日期LocalDate、时间LocalTime、时间与日期LocalDateTime，用于记录时间，与时区无关，如生日，上班时间等
  • 时区ZoneId、相对于格林尼治时间的时间偏差ZoneOffset
  • 时间间隔Duration、时间段Peroid

其他新功能

  • 添加了类Base64来完成Base64格式的加解密，详见章节《加密与安全》。
  • 支持重复注解，详见章节《反射与注解》。
万里墨香
关注
专栏目录
java8源码-javase:Java
06-04
java8 源码 javase 用于练习Java基础代码。 collections 用于普通的集合的用法。 Reference的实例。 concurrent-module 代码来自Java8 in action，主要写的是异步计算CompleteableFuture用法。 还有部分同步的集合类...
Java都到16了，为什么都还在用8，是越做越烂了么？
程序猿DD
03-19 2001
送一波超大福利！不仅有低价ECS，更有机械键盘、AirPods Pro等好礼！昨天转了小胖哥关于 Java 16发布的解读（没看过的小伙伴点过来：Java 16 正式发布！你还学得动吗？）...
java se8_初学java是选java se7还是java se8好？
weixin_32487647的博客
02-12 661
我们通过一个小程序来比较下java7 与 java8 性能的差距C# .NET 4.5： 2.412秒java7 运行时间：6秒java8 运行时间：2秒复制下面的代码，在同一台计算机上，分别在java7 环境 与 java8环境下执行一次，运算能力执行速度一目了然public static void main(String[] args) {Long start = System.curren...
Java8与JDK1.8与JDK8与J2SE8与J2SE1.8的区别是什么？——Java的各个版本和各个版本的历史版本号的关系与解读
热门推荐
快乐李同学的博客
06-09 4万+
Java8与JDK1.8与JDK8的区别是什么？ Java是面向对象的编程语言，在我们开发Java应用的程序员的专业术语里，Java这个单词其实指的是Java开发工具，也就是Java Development Kit。所以我们常常在CSDN等各大程序员论坛讨论到安装Java8或者JDK8或者JDK1.8，其实这3个专业词汇的概念是一样的。因为在用户眼中，Java是Java应用；而在程序员眼中，Jav...
Java SE 16新版本特性（中文注释说明）
weixin_45576146的博客
03-18 1729
目录合并发行说明JDK 16 发行说明Introduction/介绍IANA 数据 2020dJDK 16 的新功能和增强功能已删除的功能和选项甲骨文 JDK 与甲骨文开放 JDK 的区别 合并发行说明 本页包含 JDK 16 一般可用性 （GA） 版本的所有发布说明 JDK 16GA JDK 16 发行说明 Introduction/介绍 这些说明描述了重要的更改、增强功能、删除的 ABI 和功能、废弃的 ABI 和功能，以及有关 JDK 16 和 Java SE 16 的其他信息。在某些情况下，这些
Java语言规范(JavaSE8)英文版
01-24
JavaSE8版本引入了许多重要的新特性，如lambda表达式、默认方法、函数式接口等，极大地提升了Java的可读性和功能性。以下是对这些关键知识点的深入探讨： 1. **Lambda表达式**：JavaSE8引入的最显著特性之一就是...
Java虚拟机规范(JavaSE8)英文版
01-24
JavaSE8是Java Standard Edition的第八个版本，它引入了许多重要的新特性，包括lambda表达式、默认方法以及日期/时间API的改进。这份"Java虚拟机规范(JavaSE8)英文版"是理解JVM工作原理和技术细节的重要参考资料。 ...
JavaSE8 API文档
12-07
Java SE 8（Java Standard Edition 8）是Java平台的一个重大更新，引入了许多新特性，改进了语言设计，增强了库功能，并对API进行了扩展。Java SE 8 API文档是开发者的重要参考资料，它详尽地列出了Java SE 8中所有...
java8新特性
12-14
java SE8 新特性，每一位java开发工程师的必备宝典，其中包括lambda表达式以及lambda编程、stream API处理、新的日期与时间API、JavaScript引擎、并发增强处理、杂项处理等等。
JavaSE（十一）加密与安全
墨香院
09-21 7293
加密算法： 　　加密分为可逆加密（双向加密）和不可逆加密（单向加密），可逆的加密可以由明文得到密文，也可以由密文得到明文，而不可逆的加密只能由明文得到密文。 　　加密算法也可以分为无密钥的算法和有密钥的算法，无密钥的算法只有在算法保密的前提下才是安全的，有密钥的算法只有算法和密钥同时泄密才会变得不安全。其实不可逆加密md5和可逆加密base64这些算法都是无密钥的，如果只有通信双方才知道这两种算法...
JavaSE（七）XML与配置文件
墨香院
08-04 475
资源文件： 　　通过一个Class对象获取该类的资源，如Test.class.getResource(fileName)返回资源的URL或Test.class.getResourceAsStream(fileName)返回资源的输入流，fileName是相对于类所在的目录的相对路径，无论哪种系统，fileName各级目录间用/分割，如果fileName是以/开始的绝对路径，那么根目录是与包的定义方...
JavaSE（八）并发编程
墨香院
08-04 434
并发编程： 　　并发编程主要涉及到多进程和多线程编程，而java通常涉及到的是多线程编程，并发不是并行，同一时刻一个处理器核只能有一个执行单元在上面运行。并发编程不仅可以提高响应速度，还能最大地利用处理器资源，尤其是多核处理器中。 　　 线程基础： 　　在java中，一个线程对应的数据结构为Thread类。 　　线程有六种状态：分别是新创建、可运行（包括等待运行和正在运行状态）、被阻塞、等待、计时...
JavaSE（十四）虚拟机
墨香院
09-27 422
文章目录
JavaSE（十）网络
墨香院
09-16 410
TCP协议： 　　TCP的连接过程需要三次握手，首先服务器处于监听状态，客户端发起SYN报文并进入SYN_SEND状态，服务器监听到该SYN并为该请求分配资源，资源分配成功后服务器连接状态变为SYN_RCVD，同时向客户端发送ACK+SYN，客户端收到该ACK+SYN后分配资源，分配资源成功后客户端状态变为ESTABLESHED，并向服务器发送ACK，服务器收到这个ACK后服务器状态变为ESTAB...
JavaSE（一）基本语法
墨香院
08-04 325
文章目录诞生版本特点JDK注释命名包数据类型：运算控制语句数组克隆Jar包正则表达式 诞生   1991年Sun公司的“Green”项目要求代码短小、紧凑且平台无关，于是James Gosling就领导开发出Java，1996年初正式发布。 版本 Java SE(J2SE)：标准版。主要用于桌面应用程序开发。 Java EE(J2EE)：企业版。主要用于服务器应用企业级开发。 Java ME(J...
JavaSE（十三）跨语言调用
墨香院
09-27 265
Java的平台无关性   Java是一种与软硬件平台无关的语言，之所以能实现这一点，是因为与平台相关的操作都由JRE屏蔽了，为了屏蔽平台相关的操作，JRE本身是平台相关的，所以不同的平台需要安装相应运行平台的JRE（JRE包含JVM与Java自带的标准包）。 JNI简介   通过程序对操作系统进行操作，须要通过操作系统提供的系统调用，而操作系统提供的系统调用几乎都不是Java所写，所以Java自带...
JavaSE（十五）架构与思想
墨香院
10-09 253
SPI JNDI
JavaSE（三）文件与IO
墨香院
08-04 246
文件： 　　在java中用于描述一个文件的类为File，然而这并不一定是个真实存在的文件，只是一个抽象的概念。 　　文件路径分隔符用File.separator代替，该值与系统环境有关，文件的相对路径为虚拟机启动时设置的工作目录(一般javaSE默认为项目根目录，而javaEE与服务器配置相关)，可以通过System.getProperty(“user.dir”)获取，因为文件存放的位置与配置有关...
2018黑马程序员Java面试宝典：涵盖JavaSE与最新框架
"最新版的Java程序员面试宝典是由黑马程序员在2018年发布，涵盖JavaSE和JavaEE的基础知识以及最新的框架，旨在帮助求职者准备面试，包含了一系列常见的面试题目。" 该面试宝典是Java程序员面试的重要参考资料，内容...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值