探索JDK8的新特性

1. JDK8简介

1.1 简述

Java 8由Oracle从2014年3月18日发布，此版本是自Java 5（发布于2004年）之后的一个重量级版本，也是java发展史上的一个里程碑式的版本。这个版本在JVM、编译器、库、Java语法特性等方面都做了很大改进，同时在语言的表达力、简洁性等个方面也有了很大的提高。目前几乎所有的JAVA框架也都已升级到支持JDK8，打开框架源码想了解其设计，假如不理解JDK8的这些特性看起来就会非常吃力。所以我们设计了这个专题，我们将在这个专题中讲解JDK8中的部分关键特性，并用实际案例讲解这些特性应用，希望同学们在JDK8技术的应用上有一个很好的提高。

1.2 新特性介绍

Java 8这个版本提供了很多实用的新特性,针对接口推出了接口默认方法，接口静态方法以及函数式接口，同时为了简化代码编写，推出了lambda表达式，为了增强对数据的操作，还定义了Stream操作等。这个版本目前是市场上一个应用最广泛，也是最重要的一个版本。

2. JDK8接口新特性

2.1 概述

JDK8中对接口规范进行了新的定义，允许在接口中定义默认方法（使用default关键字修饰），静态方法，同时还推出了函数式接口（使用@FunctionInterface注解描述）设计。

2.2 应用场景

基于JDK8中接口新规范的定义，不仅可以扩展接口新功能（新的标准），还能保持接口向前兼容的特性。例如Java API中的集合操作规范。

2.3 快速入门分析

  • default方法设计及实现

JDK8中为了对接口业务进行扩展，但又不影响实现类，提供了默认方法。此类型的方法实用default关键字修饰，可以有方法体的实现。例如list接口中的sort方法：

@SuppressWarnings({"unchecked", "rawtypes"})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);}}

说明：一个接口中可以有多个默认方法，在实现类中可以有选择的对方法进行重写。例如：

interface IA{
default void doMethod01() {
System.out.println("doMethod01");
}
default void doMethod02() {
System.out.println("doMethod02");
}
} 
class ClassA implements IA{}

  • static方法设计及实现

JDK8的接口中还支持静态方法，例如：

interface IB{
static void doMethod() {
System.out.println("doMethod()");
}
}

  • 函数式接口设计及实现

Java8引入了一个是函数式接口（Functional Interfaces），此接口使用

@FunctionalInterface修饰，并且此接口内部只能包含一个抽象方法。

@FunctionalInterface
public interface Comparator<T> {int compare(T o1, T o2);  // public abstract
}

说明：函数式接口推出的目的主要是为了配合后续Lambda表达式的应用。

2.4 应用案例增强分析及实现

在JDK中的java.util.function包中定义了大量函数式接口。常用的有如下几个：

  • 消费型接口。

@FunctionalInterface
public interface Consumer<T> {void accept(T t);
}

  • 函数式接口。

@FunctionalInterface
public interface Function<T, R> {R apply(T t);
}

  • 判定式接口。

@FunctionalInterface
public interface Predicate<T> {boolean test(T t);
}

  • 供给式接口。

@FunctionalInterface
public interface Supplier<T> {T get();
}

 

3. JDK8中Lambda 表达式应用

3.1 概述

Java中的Lambda表达式是JDK8中的一种新特性，它允许我们将一段代码（这段代码可以理解为一个接口的实现）当成参数传递给某个方法，然后进行业务处理，这种方式更像是一种函数式编程风格，可以让代码结构更简洁，开发效率更高。

3.2 应用场景

Java中的Lambda为JAVA编程注入了函数式编程思想，在迭代操作，映射操作，聚合操作等很多方面的实现上做出了很大努力。并从语法角度简化了程序员对特定代码的编写，通过底层的类型推断，方法引用等特性让代码表现的更加优雅。现在已成为我们编程过程中常用的一种编程方式。

3.3 快速入门分析

最简单的Lambda表达式可由逗号分隔的参数列表、->符号和语句块组成，例如：

Arrays.asList( "a", "b", "d" ).forEach( e -> System.out.println( e ) );

在上面这个代码中的参数e的类型是由编译器推理得出的，你也可以显式指定该参数的类型，例如：

Arrays.asList( "a", "b", "d" ).forEach( ( String e ) -> System.out.println( e ) );

如果Lambda表达式需要更复杂的语句块，则可以使用花括号将该语句块括起来，类似于Java中的函数体，例如：

Arrays.asList( "a", "b", "d" ).forEach( e -> {System.out.print( e );System.out.println( );
} );

lambda 表达式可以让代码编写更加简洁。我们先来思考下普通的函数或方法具备的几个元素：

  • 访问修饰符。

  • 返回值类型。

  • 方法名。

  • 参数列表。

  • 代码块。

在lambda 表达式应用过程中，你应该也注意到了，一般只有两个元素：

(parameter list) -> body

其中“->” 将参数列表与函数主体分离，旨在对给定参数进行处理。函数的主体可能是一条或多条语句。例如其常见结构如下：

() -> statementarg -> statement (arg1, arg2, ...) -> {  body-block }(Type1 arg1, Type2 arg2, ...) -> { 
method-body-block;return value; 
}

Lambda表达式有返回值，返回值的类型也由编译器推理得出。如果Lambda表达式中的语句块只有一行，则可以不用使用return语句，下列两个代码片段效果相同：


Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> e1.compareTo( e2 ) );Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> {int result = e1.compareTo( e2 );return result;
} );

3.4 应用案例增强实现

结合对lambda表达式基本语法的认识，通过如下案例在对lambda表达式继续强化分析和实现。

案例1：构建一个线程对象，执行Runnable类型的任务。

传统方式的实现，其关键代码如下：

new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
}).start();

基于JDK8中的Lambda表达式实现方式，对传统方式线程对象的创建进行简化，其关键代码如下：

new Thread(()->{
System.out.println("hello");
}).start();

案例2：通过lambda表达式演示排序过程中代码的简化。

定义一字符串数组，然后对字符串数组中的内容，按字符串元素的长度对其进行排序。代码如下：

String[] strArray= {"abcd","ab","abc"};

在JDK8之前传统的实现方案，基于Arrays类对数组中的元素进行排序操作，关

键代码实现如下：  

Arrays.sort(strArray,new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.length()-o2.length();
}
});

基于JDK8中的Lambda表达式，对排序如上排序方案的代码实现过程进行简化

，关键代码如下：

Arrays.sort(strArray, (s1, s2) -> s1.length() - s2.length());

 

4. JDK8中方法引用

4.1 概述

方法引用是用来直接引用类方法、实例方法或者构造方法的一种新的方式。这里要特别强调一点的是“方法引用”提供的是一种对方法的引用而不是执行方法的方式，简单点理解的话就是可以将方法作为参数进行传递，我们还可以将方法引用理解为lambda的一种深层表达。

4.2 应用场景

方法引用是一种更简洁易懂的Lambda表达式，操作符是双冒号"::"，也可以将方法引用看成是一个更加紧凑，易读的Lambda表达式。

4.3 快速入门分析

方法引用是一种更简洁易懂的Lambda表达式，操作符是双冒号"::"，也可以将方法引用定义一个list集合，然后基于Lambda表达式迭代集合中的内容进行输出，关键代码如下：

List<String> list = Arrays.asList("a","b","c");list.forEach(str -> System.out.println(str));

基于方法引用的方式，输出list集合中的具体内容的，然后与传统Lambda表达式方式，进行对比分析，关键代码如下：

list.forEach(System.out::println);

说明：当你要访问的接口方法与执行的方法引用参数相同，返回值也相同即可直接使用方法引用。

4.4 应用案例增强分析

JDK8方法的引用可分为如下几类：

  • 构造方法引用。

格式：ClassName::new，应用默认构造函数。

package com.cy.java8.methodref;
import java.util.function.Supplier;
public class TestConstructorMethodRef01 {
public static void main(String[] args) {
//1.传统方式
Supplier<Object> s1=new Supplier<Object>() {
@Override
public Object get() {
return new Object();
}
};
System.out.println(s1.get());
//2.Lambda方式
Supplier<Object> s2=()->new Object();
System.out.println(s2.get());
//3.构造方法引用"类名::new"
Supplier<Object> obj=Object::new;
System.out.println(obj.get());
}
}

  • 类静态方法引用。

格式：ClassName::static_method。package com.cy.java8.methodref;
import java.util.function.Function;
public class TestClassMethodRef01 {public static void main(String[] args) {
//1.传统应用方式
Function<String, Integer> f1=new Function<String, Integer>() {
@Override
public Integer apply(String t) {
return Integer.parseInt(t);
}
};
Integer result=f1.apply("100");
System.out.println(result);
//2.lambda应用方式
Function<String, Integer> f2=(t)->Integer.parseInt(t);
System.out.println(f2.apply("200"));
//3.类方法引用应用方式"类名::方法名"
Function<String,Integer> f3=Integer::parseInt;
System.out.println(f3.apply("300"));
}
}

练习：比较两个整数大小。

Comparator<Integer> com=Integer::compare;System.out.println(com.compare(39, 20));

  • 类实例方法引用。

格式：ClassName::method，方法不能带参数。

package com.cy.java8.methodref;
import java.io.File;
import java.util.function.Function;
public class TestClassInstanceMethodRef01 {public static void main(String[] args) {
//1.传统方式
Function<File,String> f1=new Function<File,String>() {
@Override
public String apply(File f) {
return f.getAbsolutePath();
}
};
System.out.println(f1.apply(new File("pom.xml")));
//2.Lambda方式
Function<File,String> f2=file->file.getAbsolutePath();
System.out.println(f2.apply(new File("pom.xml")));
//3.类实例方法引用"类名::实例方法名"
Function<File,String> f3=File::getAbsolutePath;
System.out.println(f3.apply(new File("pom.xml")));
}
}

练习：堆数组中内容进行排序，通过方法引用简化编写。

Arrays.sort(strArray,(s1,s2)->s1.compareToIgnoreCase(s2));
Arrays.sort(strArray, String::compareToIgnoreCase);

  • 对象实例方法引用。

格式：对象实例::method，方法不能带参数。

public class TestObjectInstanceMethodRef01 {public static void main(String[] args) {
List<String> list=Arrays.asList("A","B","C");
//传统方式
list.forEach(new Consumer<String>() {
@Override
public void accept(String t) {
System.out.println(t);
}
});
//Lambda表达式方式
list.forEach(t->System.out.println(t));
//方法引用方式
PrintStream ps=System.out;
list.forEach(ps::println);
list.forEach(System.out::println);
}
}

练习:获取集合中元素的个数。

List<Integer> list=Arrays.asList(10,20);
Supplier<Integer> supplier=(list::size);
System.out.println(supplier.get());

5. JDK8中Stream API应用

5.1 概述

Stream 作为 Java 8 的一大亮点，它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作，或者大批量数据操作。

5.2 应用场景

在当今这个数据爆炸的时代，数据来源多样化、数据海量化，很多时候不得不脱离 RDBMS，以底层返回的数据为基础进行更上层的数据统计。而原有 Java 的集合 API 中，仅仅有极少量的辅助型方法，更多的时候是程序员需要用 Iterator 来遍历集合，然后完成相关的聚合应用逻辑。这是一种远不够高效而且相对比较笨拙的方法。在JDK8中使用 Stream 对象，不仅丰富了在业务层面对数据处理的方式，还可以让代码更加简洁、易读和高效。

5.3 快速入门分析

我们在使用Stream对象时，一般会按照如下为三个步骤进行操作：

  • 第一步：创建Stream流对象。

  • 第二步：Stream流中间操作。

  • 第三步：Stream流终止操作。

Stream对象的操作过程，可通过图-1进行进一步分析。

Steam对象简易应用，

统计list集合中偶数的个数,代码如下：

List<Integer> list = Arrays.asList(3, 2, 12, 5, 6, 11, 13);
long count = stream.stream()//创建.filter(i -> i % 2 == 0)//中间操作.count();//终止
System.out.println(count);

获取list集合中所有的偶数,代码如下:

static void doTest02(){List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);List<Integer> collect = integers.stream() //初始操作(获取Stream对象).filter((integer) -> integer % 2 == 0)//中间操作.collect(Collectors.toList());//终止操作System.out.println(collect);
}

5.4 应用案例增强分析

  • Stream对象创建,常见方式有如下几种：

  1. 借助Collection接口中的stream()或parallelStream（）方法。

  2. 借助Arrays类中的stream(...)方法。

  3. 借助Stream类中的of(...)方法。

  4. 借助Stream类中的iterator和generator方法（无限操作）。

Stream对象创建，案例分析如下：

Collection<Integer> col=new ArrayList<>();...
Stream<Integer> s1=col.stream();
Stream<Integer> s2=col.parallelStream();IntStream s3=Arrays.stream(new int[] {1,2,3,4});Stream<Integer> s4=Stream.of(10,20,30,40);Stream<Integer> s5=Stream.iterate(2, (x)->x+2);
s5.forEach(System.out::println);Stream<Double> s6=Stream.generate(()->Math.random());
s6.forEach(System.out::println);

  • Stream中间操作。

Stream 对象创建以后可以基于业务执行一些中间操作，但这些操作的结果需要借助终止操作进行输出，案例分析如下：

初始条件：给定list集合作为Stream操作的对象，代码如下：

List<Integer> list=Arrays.asList(100,101,102,200);

对数据进行过滤：

//输出集合中所有的偶数
//1.创建流
Stream<Integer> s1=list.stream();
//2.中间操作(过滤)
Stream<Integer> s2=s1.filter((n)->n%2==0);
//3.终止操作
s2.forEach(System.out::println);
//也可以将多个操作合在一起
list.stream().filter(n->n%2==0).forEach(System.out::println);

限定操作(limit):

list.stream()
.filter(n->n%2==0)
.limit(2)
.forEach(System.out::println);

跳过操作(skip)：

list.stream()
.filter(n->n%2==0)
.skip(2)
.forEach(System.out::println);

去重操作(distinct)：

list.stream()
.distinct()
.forEach(System.out::println);

排序操作(sorted)：底层基于内部比较器Comparable或外部Comparator比较器进行比对。

list.stream()
.sorted()
.forEach(System.out::println);

list.stream()
.sorted((s1,s2)->{//Comparator
return s1-s2;}).forEach(System.out::println);

映射操作(map)：

List<String> list=Arrays.asList("a","bc","def");list.stream()
.map((x)->x.toUpperCase())
.forEach(System.out::println);list.stream()
.map((x)->x.length())
.forEach(System.out::println);

  • Stream终止操作。

Stream终止操作是Stream的结束操作，案例分析如下：

List<String> list=Arrays.asList("a","bc","def");
list.stream()
.map((x)->x.toUpperCase())
.forEach(System.out::println);

list.stream()
.map((x)->x.length())
.forEach(System.out::println);

案例：初始条件定义，给定一个list集合：

List<Integer> list=Arrays.asList(10,11,12,13,14,15);

match操作：

boolean flag=list.stream().allMatch((x)->x%2==0);//是否匹配所有
System.out.println(flag);
flag=list.stream().anyMatch((x)->x%2==0);//是否存在匹配
System.out.println(flag);
flag=list.stream().noneMatch((x)->x>20);//是否没有匹配项
System.out.println(flag);

find操作：

Optional<Integer> optional=list.stream().sorted().findFirst();
System.out.println(optional.get());
optional=list.parallelStream().filter((x)->x%2!=0).findAny();
System.out.println(optional.get());

count操作：

long count=list.stream().count();
System.out.println(count);

求最大，最小值：

optional=list.stream().max((x,y)->{return x-y;});
System.out.println(optional.get());
optional=list.stream().min((x,y)->{return x-y;});
System.out.println(optional.get());

forEach迭代操作：

list.stream().forEach(System.out::println);

Reduce(归约)操作：

//计算集合中所有元素的和，其中第一个参数0为初始值，然后与后面每个值累加
Integer sum=list.stream().reduce(0,(x,y)->{return x+y;});
System.out.println(sum);

Collector(收集)操作：

List<Integer> result=
list.stream()
.map(x->x*2)
.collect(Collectors.toList());
System.out.println(result);list.stream().map(x->x*2).collect(Collectors.toSet());
System.out.println(result);double avg=
list.stream()
.collect(Collectors.averagingDouble(x->x));
System.out.println(avg);Optional<Integer> max=
list.stream().collect(Collectors.maxBy((x,y)->{return x-y;}));
System.out.println(max.get());Map<Object,List<Integer>> map=
list.stream().collect(Collectors.groupingBy(x->x%2==0));
System.out.println(map);

6. JDK8中Stream 练习

6.1 reduce操作

案例1：计算多个整数的和。

static void doTestReduce01() {List<Integer> list = Arrays.asList(1,2,3,4,5,6);Optional<Integer> count = list.stream().reduce((a, b) -> (a + b));System.out.println(count.get()); // 21
}

案例2：计算多个整数乘积，然后再乘以2。

static void doTestReduce02() {
List<Integer> list = Arrays.asList(1,2,3,4,5,6);
Integer count = list.stream().reduce(2, (a, b) -> (a * b));
System.out.println(count);  // 1440
}

案例3：计算多个整数的和，假如超出范围，则对其进行类型转换。.

案例1和2的缺点在于返回的数据都只能和 Stream 流中元素类型一致，但假如求和或乘积之后的数值超过了 Integer 能够表示的范围怎么办？例如，需要使用 Long 类型接收，这就用到了我们下面reduce() 方法的应用形式了。

static void doTestReduce03() {
List<Integer> list = Arrays.asList(Integer.MAX_VALUE, Integer.MAX_VALUE);
long count = list.stream().reduce(0L, (a, b) -> (a + b), (a,b) -> 0L);
System.out.println(count);
}

6.2 collect操作实现

获取指定目录下所有目录文件的文件名。

List<String> allDirNames =Arrays.stream(new File("d:\\").listFiles()).filter(File::isDirectory).map(File::getName).collect(Collectors.toList());
System.out.println(allDirNames);

6.3 并行流的简易应用

并行流应用的目的主要借助多核处理器优势，提高的操作性能。

 public static void main (String[] args) {String[] strings =  {"1", "2", "3", "4", "5"};doPrint(Arrays.stream(strings).sequential());doPrint(Arrays.stream(strings).parallel());}public static void doPrint (Stream<String> stream) {stream.forEach(s -> {System.out.println(Thread.currentThread().getName()+"->"+s);});}

 

6.4 小节面试分析

6.4.1 如何理解Stream技术？

JDK8中的Stream技术是一种用于表示和操作数据流的编程模型。它提供了一组丰富的函数式操作，可以通过链式调用来对数据流进行过滤、映射、排序、归约等操作。以下是对JDK8中的Stream技术的一些理解：

  1. 数据流表示: Stream是对数据的抽象表示，可以理解为是一种元素（或对象）的序列。与传统的集合不同，Stream可以在底层数据源上进行类似于流水线的处理操作，而无需存储所有的元素。

  2. 惰性求值: Stream具有惰性求值的特性，只有当需要对Stream进行终端操作（如foreach、reduce）时，才会触发中间操作（如filter、map）进行计算。这种特性可以节省内存和计算资源。

  3. 函数式操作: Stream提供了一套函数式操作风格的API，可以通过链式调用将操作串联起来。常见的操作包括筛选（filter）、映射（map）、排序（sorted）、归约（reduce）等。这些操作是以lambda表达式的形式传递给Stream，使得代码更简洁，可读性更强。

  4. 并发执行: Stream API还支持并发执行，在某些情况下可以通过并行化操作来提升计算性能。Stream会根据底层数据源的特性自动判断是否适合并行处理。

  5. 应用场景: Stream技术适用于对大规模数据集进行复杂的数据处理和分析。通过Stream，可以使用简洁、可读性强的代码来实现常用的数据处理功能，提高开发效率和代码质量。

总之，JDK8中的Stream技术是一种非常强大和灵活的数据处理工具，可以帮助开发人员更高效地处理和分析数据。熟练使用Stream技术有助于编写更简洁、可读性更强的代码。

7. JDK8中新日期对象应用

7.1 概述

　在Java8之前，日期和时间的管理一直是令Java开发者很痛苦的一个的问题。java.util.Date、java.util.Calendar，SimpleDateFormat都一直没有很好解决这个问题。故此，Java8引入了一套全新的日期时间处理API，新的API基于ISO标准日历系统，解决了以前日期和时间类的很多弊端问题。

7.2 应用场景

Java8中的时间处理API定义在java.time包中，这些API具备不可变且线程安全特性,具备准确和灵活特性。所以现在基本可以使用这组API替换所有原有历史版本中时间API的应用。

7.3 快速入门分析

新日器对象类型中，常用API应用分析:

  • Instant 时间戳对象应用，默认是0时区，比北京少8个时区。

//获取瞬时对象(当前时间年月日时分秒),Instant是绝对时间，没有时区的概念
Instant instant1 ==Instant.now();//Clock.systemUTC().instant();
System.out.println(instant1);
//通过这种方式获取的时间戳与北京时间相差8个时区，需要修正为北京时间
instant1=instant1.plusMillis(TimeUnit.HOURS.toMillis(8));;
//输出系统可用时区
System.out.println(ZoneId.getAvailableZoneIds());
//输出系统默认时区
System.out.println(ZoneId.systemDefault());
//输出系统默认时区时间
System.out.println(Instant.now().atZone(ZoneId.systemDefault()));获取时间间隔。Instant start = Instant.now();
...
Instant end = Instant.now();
Duration timeElapsed = Duration.between(start, end);
System.out.println("Milliseconds: " + timeElapsed.toMillis());

  • LocalDate 日期对象，不包含具体时间。

LocalDate ld1=LocalDate.now();
System.out.println(ld1);
LocalDate ld2 = LocalDate.of(2019, Month.JANUARY, 8);
System.out.println(ld2);
LocalDate ld3=LocalDate.parse("2019-12-12");
System.out.println(ld3);

  • LocalTime 时间对象，不包含日期。


LocalTime lt1=LocalTime.now();
System.out.println(lt1);
LocalTime lt2=LocalTime.now(ZoneId.systemDefault());
System.out.println(lt2);
long t=ChronoUnit.HOURS.between(lt1, lt2);
System.out.println(t);

  • LocalDateTime 包含了日期和时间对象，没有时区信息。

LocalDateTime ldt02 = 
LocalDateTime.of(2019, Month.DECEMBER, 31, 23, 59, 59);
System.out.println(ldt02);//2019-12-31T23:59:59
DayOfWeek dayOfWeek = ldt02.getDayOfWeek();
System.out.println(dayOfWeek);      // WEDNESDAY

  • ZoneDateTime 包含时区的完整日期时间对象，偏移量以UTC时间为基准。

ZonedDateTime zdt01=ZonedDateTime.now();
System.out.println(zdt01);
ZoneId zd01=TimeZone.getDefault().toZoneId();
System.out.println(zd01);

7.4 应用案例增强分析

项目中我们经常会用到日期类型转换，在JDK8中的实现方式如下：

LocalDateTime ld4 = 
LocalDateTime.parse("2019/12/12 12:12:12",
DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss"));
System.out.println(ld4);

说明：jdk8之前的日期与字符串之间的转换通常会借助SimpleDateFormat对象，但是此对象线程不安全，通常要借助ThreadLocal对象，保证SimpleDateFormat对象每个线程一份。

8. JDK8新特性总结

8.1 重难点分析

  • 接口新特性?(默认方法，函数式接口，静态方法)

  • Lambda表达式?(函数式，简化语法，开发效率)

  • 方法引用(MethodReference)

  • Stream应用实践分析?（数据操作更方便，创建，中间操作，终止操作）

  • 常用新的日期对象应用?（灵活，安全，准确）

8.2 FAQ分析

  • 常用的函数式接口有哪些？(消费型，供给型，判定型，函数式)

  • Lambda表达式关键作用是什么？(简洁，开发效率)

  • Stream应用中有哪些常用操作？（过滤，统计，映射，规约，收集,...）

  • JDK8中常用的日期API有哪些？(Instant,LocalDateTime,DateTimeFormater)

  • …...

以上就是Java 8部分关键新特性的简要概述和示例。随着Java 8的广泛应用，这些新特性已成为现代Java开发者的必备知识，不仅提升了编码效率，也让代码变得更加简洁优雅。通过深入学习和实践这些新特性，我们可以更高效地构建高质量的Java应用程序。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/260843.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

k8s除了可以直接运行docker镜像之外，还可以运行什么？ springboot项目打包成的压缩包可以直接运行在docker容器中吗？

k8s除了可以直接运行docker镜像之外，还可以运行什么？ springboot项目打包成的压缩包可以直接运行在docker容器中吗？

Kubernetes&#xff08;k8s&#xff09;主要设计用于自动部署、扩展和管理容器化应用程序。虽然它与Docker容器最为密切相关&#xff0c;Kubernetes实际上是与容器运行时技术无关的&#xff0c;这意味着它不仅仅能够管理Docker容器。Kubernetes支持多种容器运行时&#xff0c;包…
阅读更多...
NestJS入门6：日志中间件

NestJS入门6：日志中间件

前文参考&#xff1a; NestJS入门1 NestJS入门2&#xff1a;创建模块 NestJS入门3&#xff1a;不同请求方式前后端写法 NestJS入门4&#xff1a;MySQL typeorm 增删改查 NestJS入门5&#xff1a;加入Swagger 1. 安装 nest g middleware logger middleware​ ​ ​ 2. lo…
阅读更多...
深入理解java虚拟机---自动内存管理

深入理解java虚拟机---自动内存管理

2.2 运行时数据区域 Java虚拟机在执行Java程序的过程中会把它所管理的内存划分为若干个不同的数据区域。这些区域有各自的用途&#xff0c;以及创建和销毁的时间&#xff0c;有的区域随着虚拟机进程的启动而一直存在&#xff0c;有些区域则是依赖用户线程的启动和结束而建立和销…
阅读更多...
BioTech - 大型蛋白质复合物的组装流程 (CombFold)

BioTech - 大型蛋白质复合物的组装流程 (CombFold)

欢迎关注我的CSDN&#xff1a;https://spike.blog.csdn.net/ 本文地址&#xff1a;https://spike.blog.csdn.net/article/details/136187314 CombFold是用于预测大型蛋白质复合物结构的组合和分层组装算法&#xff0c;利用AlphaFold2预测的亚基之间的成对相互作用。CombFold的组…
阅读更多...
亿道丨三防平板pad丨三防平板是指哪三防丨三防工业级平板电脑

亿道丨三防平板pad丨三防平板是指哪三防丨三防工业级平板电脑

三防工业级平板电脑成为许多行业中的重要工具。本文将介绍三防工业级平板电脑的特点以及其在各个领域中的广泛应用。 三防工业级平板电脑的特点 三防工业级平板电脑是指具备防水、防尘和防震功能的平板电脑。这些特点使得它们能够在恶劣环境中工作&#xff0c;如沙尘飞扬的工地…
阅读更多...
SpringCloud-Nacos集群搭建

SpringCloud-Nacos集群搭建

本文详细介绍了如何在SpringCloud环境中搭建Nacos集群&#xff0c;为读者提供了一份清晰而详尽的指南。通过逐步演示每个关键步骤&#xff0c;包括安装、配置以及Nginx的负载均衡设置&#xff0c;读者能够轻松理解并操作整个搭建过程。 一、Nacos集群示意图 Nacos&#xff0…
阅读更多...
ctfshow MISC类部分wp

ctfshow MISC类部分wp

2023愚人杯 1. 阿尼亚哇库哇库 压缩包里两个文件&#xff1a; 阿尼亚哇库哇库&#xff01;.doc 和 HINT.png 先看HINT.png,图片打不开 使用01打开: 发现文件头有问题&#xff0c;前几位修改为89 50 4E 47后&#xff0c;图片打开依然不正常。发现长高尺寸不对。用脚本根据CR…
阅读更多...
滑动变阻器在电路中的连接方式有哪些？

滑动变阻器在电路中的连接方式有哪些？

滑动变阻器是可以改变电阻值的电子元件&#xff0c;广泛应用于各种电路中。在电路中&#xff0c;滑动变阻器的连接方式主要有以下几种&#xff1a; 1. 串联连接&#xff1a;滑动变阻器与被测电阻串联在一起&#xff0c;通过改变滑动变阻器的阻值来改变整个电路的总阻值。这种连…
阅读更多...
linux---内存管理

linux---内存管理

一 虚拟内存 即使是现代操作系统中&#xff0c;内存依然是计算机中很宝贵的资源&#xff0c;看看你电脑几个T固态硬盘&#xff0c;再看看内存大小就知道了。 为了充分利用和管理系统内存资源&#xff0c;Linux采用虚拟内存管理技术&#xff0c;利用虚拟内存技术让每个进程都有…
阅读更多...
Flume（二）【Flume 进阶使用】

Flume（二）【Flume 进阶使用】

前言 学数仓的时候发现 flume 落了一点&#xff0c;赶紧补齐。 1、Flume 事务 Source 在往 Channel 发送数据之前会开启一个 Put 事务&#xff1a; doPut&#xff1a;将批量数据写入临时缓冲区 putList&#xff08;当 source 中的数据达到 batchsize 或者 超过特定的时间就会…
阅读更多...
创新工作方式：低代码拖拉拽实现业务流程智能化

创新工作方式：低代码拖拉拽实现业务流程智能化

前言 “低代码”这个火热的概念在近些年来备受追捧&#xff0c;由此引发了业内关于其前景和应用范围的广泛热议。作为一种新兴的开发方式&#xff0c;低代码技术正在站在技术领域的风口浪尖&#xff0c;成为行业的一个重要趋势。它以其高效、灵活和可定制的特性&#xff0c;为…
阅读更多...
机器人十大前沿技术（2023-2024年）

机器人十大前沿技术（2023-2024年）

2023-2024年机器人十大前沿技术 1. 具身智能与垂直大模型 具身智能是指拥有自主感知、交互和行动能力的智能体&#xff0c;能够与环境进行实时互动&#xff0c;从而实现对环境的理解和适应。 “大模型”是指在深度学习和人工智能领域中&#xff0c;使用大量参数和数据进行训…
阅读更多...
python自学...

python自学...

一、稍微高级一点的。。。 1. 闭包&#xff08;跟js差不多&#xff09; 2. 装饰器 就是spring的aop 3. 多线程
阅读更多...
解决ubuntu登录密码问题

解决ubuntu登录密码问题

解决ubuntu登录密码问题 不要随便删除密码&#xff0c;不要随便改密码&#xff0c;很容导致密码过期&#xff0c;或者密码无效。参考了很多人的做法&#xff0c;都没有得到解决。下面的过程&#xff0c;够详细了&#xff0c;我就是这么搞好的。 1、重启虚拟机&#xff0c;不停…
阅读更多...
RMAN备份与恢复

RMAN备份与恢复

文章目录 一、RMAN介绍二、全量备份三、增量备份0级备份1级增量备份累积性差量备份总结 四、压缩备份压缩备份介绍压缩备份操作压缩备份优缺点 五、异常恢复1、恢复前的准备2、恢复数据库 六、RMAN相关参数 一、RMAN介绍 RMAN&#xff08;Recovery Manager&#xff09;是Oracl…
阅读更多...
react使用Map方法遍历列表不显示的问题

react使用Map方法遍历列表不显示的问题

问题&#xff1a; 在最开始搭建选项卡的时候&#xff0c;我的js代码是这样的 import React, { Component } from react import ./css/02-maizuo.css export default class App extends Component {state {list: [{id: 1,text: 电影},{id: 2,text: 影院}, {id: 3,text: 我的}…
阅读更多...
天锐绿盾｜防泄密系统｜计算机文件数据\资料安全管理软件

天锐绿盾｜防泄密系统｜计算机文件数据\资料安全管理软件

“天锐绿盾”似乎是一款专注于防泄密和计算机文件数据/资料安全管理的软件。在信息安全日益受到重视的今天&#xff0c;这样的软件对于保护企业的核心数据资产和防止敏感信息泄露至关重要。 通用地址&#xff1a;www.drhchina.com 防泄密系统的主要功能通常包括&#xff1a; 文…
阅读更多...
【力扣白嫖日记】1965.丢失信息的雇员

【力扣白嫖日记】1965.丢失信息的雇员

前言 练习sql语句&#xff0c;所有题目来自于力扣&#xff08;https://leetcode.cn/problemset/database/&#xff09;的免费数据库练习题。 今日题目&#xff1a; 1965.丢失信息的雇员 表&#xff1a;Employees 列名类型employee_idintnamevarchar employee_id 是该表中具…
阅读更多...
数据结构-邻接链表

数据结构-邻接链表

介绍 邻接矩阵是运用较多的一种储存图的方法&#xff0c;但如果一张网图边数较少&#xff0c;就会出现二维矩阵中大部分数据为0的情况&#xff0c;浪费储存空间 为了避免空间浪费&#xff0c;也可以采用数组与链表结合的方式来存储图 假设有这样一张图 我们可以先用一个数组…
阅读更多...
Facebook元宇宙探索：虚拟社交的新时代

Facebook元宇宙探索：虚拟社交的新时代

在数字化时代的浪潮中&#xff0c;人类社交的模式和形式正在经历着翻天覆地的变化。而当下&#xff0c;Facebook作为全球最大的社交媒体平台之一&#xff0c;正积极探索着元宇宙的未来。元宇宙被认为是虚拟世界的下一步进化&#xff0c;它将重新定义人们的社交方式、娱乐体验以…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发