JDK版本特性(JDK8\11\17\21版本)

JDK版本特性

Oracle官网https://www.oracle.com/java/technologies/java-se-support-roadmap.html
Oracle官网中JDK版本的说明，Java SE 8、11、17和21是LTS版本。也就是长期支持版本。
我们针对这几个版本了解学习下对应版本的新特性。
在这里插入图片描述

JDK8版本

正式发布于2014年。

比较重要的新增特性如下：

1、移除HotSpot虚拟机的永久代，使用元空间替代

永久代有固定的大小限制，在JDK8之前可通过JVM参数 -XX:MaxPermSize= xxx m 设置，当加载的类的大小超过这个限制时，就会抛出 OutOfMemoryError: PermGen space 错误。这种设计限制了 Java 的灵活性和可伸缩性。

元空间的本质和永久代类似，都是对JVM规范中方法区的实现。移除永久代主要是为了解决与类元数据存储相关的内存管理和性能问题。
元空间相比于永久代具有以下优势：

  • 元空间基于本地内存不受 Java 堆内存大小的限制。
  • 元空间的大小可以根据应用程序的需求动态调整，减少了内存溢出的风险，并允许应用更高效地管理内存。

2、Lambda 表达式

语法：
Lambda 表达式基本语法如下：

(参数) -> 表达式   或者    (参数) -> { 代码块; }

作用：
Lambda 表达式的主要作用是简化部分匿名内部类的写法。

特点：

  • 参数无需声明类型： Lambda 表达式不需要声明参数类型，编译器可以自动推断参数类型。
  • 参数括号可选： 当只有一个参数时，可以省略括号。当参数个数大于一个时，括号是必需的。空括号用于表示空参数集。
  • 表达式的大括号可选： 当 Lambda 表达式的主体只包含一个表达式时，可以省略大括号。当表达式需要包含多个语句时，必需要使用大括号。
  • return关键字可选： 当 Lambda 表达式主体只有一个表达式，且该表达式会自动返回结果时，可以省略 return 关键字。

Lambda 表达式用法的简单示例：

public static void main(String[] args) {// ()表示空参数列表   且省略了 {}Thread thread = new Thread(() -> System.out.println("Lambda表达式"));Map<String, String> map = new HashMap<>();map.put("123","123");// (k,v) 表示参数列表 分别表示 Map的key的valuemap.forEach((k,v)->{System.out.println(k);System.out.println(v);});// removeIf要求必需有返回值List<String> list = new ArrayList<>();list.removeIf((item)->{ return "1".equals(item);});}

要理解Lambda 表达式的使用还需要了解一个知识点：函数式接口

3、函数式接口

函数式接口是**只包含一个抽象方法**的接口，它是在 Java 8 版本中引入的，其主要目的是支持函数式编程，有了函数式接口我们可以将函数作为参数传递、将函数作为返回值返回，同时也为使用 Lambda 表达式提供了支持。

标准的函数式接口使用@FunctionalInterface注解标注，例如：
@FunctionalInterface只是一个标记注解，可以让编译器检查接口是否符合函数式接口的定义。

@FunctionalInterface
public interface Runnable {public abstract void run();
}

对于无参数，无返回值的函数式接口的抽象方法， Lambda表达的用法如下：

public static void main(String[] args) {// 之前我们对于内名内部类的用法Runnable runnable = new Runnable() {@Overridepublic void run() {System.out.println("匿名内部类");}};// Runnable中只有一个run方法 且无参，无返回值  使用Lambda表达式Runnable runnable1 = ()->{System.out.println("使用Lambda表达式");};}

从上面的代码可以看出 Lambda表达式本质上就是 函数式接口的实例。
可以把Lambda表达式理解为函数式接口实例化后的对象。

其他的函数式接口：
为了丰富Lambda表达式的应用场景，Java内置了许多函数式接口：

在JDK8之前，我们经常使用的函数式接口有：
java.lang.Runnable
java.util.concurrent.Callable
java.util.Comparator
java.lang.reflect.InvocationHandler

在 JDK8 中，新增的函数式接口在 java.util.function 包中:
下面举几个常见的例子：
java.util.function.Consumer：消费型接口
java.util.function.Function：函数型接口
java.util.function.Supplier：供给型接口
java.util.function.Predicate：断定型接口

这几个新增的函数式接口大大丰富了Lambda表达式的使用。

Consumer 消费型接口

顾名思义，消费性接口肯定是拿到消息并消费，所以该接口中的方法，接收一个参数，但是没有返回值。

@FunctionalInterface
public interface Consumer<T> {// 这个是抽象方法void accept(T t);// 这个是 default 修饰的实现方法 (这个也是JDK8的新特性 允许接口中有实现方法但是必需使用default 修饰)default Consumer<T> andThen(Consumer<? super T> after) {Objects.requireNonNull(after);return (T t) -> { accept(t); after.accept(t); };}
}

Consumer 接口的用法：
Consumer 接口接收一个对象，可以在accept方法中对该对象进行操作，例如修改对象状态，打印该对象等。
该接口中的andThen方法接收一个Consumer对象，先执行调用者Consumer对象的accept方法，再执行传入的Consumer对象的accept方法。也就是一条消息可以被多个消费者依次消费处理。

public static void main(String[] args) {Consumer consumer1 = (s) -> {System.out.println(s);};consumer1.accept("消息1"); // 结果 消息1Consumer c1 = (s) -> {s = s + "c1";System.out.println(s);};Consumer c2 = (s) -> {s = s + "c2";System.out.println(s);};c1.andThen(c2).accept("消息被处理");  // 结果 消息被处理c1//     消息被处理c2}
Function函数型接口

Function 代表一个函数。
该接口包含一个抽象方法 R apply(T t)，接受一个参数 t（类型为 T），并返回一个结果（类型为 R）

还包含3个实现方法
compose、andThen、identity

@FunctionalInterface
public interface Function<T, R> {// 接收一个参数t ，返回一个参数RR apply(T t);// 接收一个Function类型的参数，调用接收参数的apply方法，返回Functiondefault <V> Function<V, R> compose(Function<? super V, ? extends T> before) {Objects.requireNonNull(before);return (V v) -> apply(before.apply(v));}// 接收一个Function类型的参数，先调用自己的apply方法，再调用接收参数的apply方法default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {Objects.requireNonNull(after);return (T t) -> after.apply(apply(t));}// 给啥返回啥static <T> Function<T, T> identity() {return t -> t;}
}

Function接口的用法：
由于Function接口的apply方法接收的参数和返回的参数类型都是自定义的，所以可以用来做数据处理，参数的类型转换。
根据提供的compose方法和andThen方法 还可以做方法的链式调用。
至于给啥返回啥的identity方法，看似无用，实则还是有用的。

public static void main(String[] args) {Function f1 = (t)->{// ==============  类型转换return Integer.parseInt((String) t);};Object apply = f1.apply("2024");System.out.println(apply);Function f2 = (t)->{// ==============  数据处理return (String)t + "数据处理";};String apply1 = (String) f2.apply("2024");System.out.println(apply1);// ============== 函数链式调用Function chain1 = (t)->{System.out.println("调用函数1");return (String) t + 1;};Function chain2 = (t)->{System.out.println("调用函数2");return (String) t + 2;};Function chain3 = (t)->{System.out.println("调用函数3");return (String) t + 3;};// andThen 相当于从外到内顺序调用String apply2 = (String) chain1.andThen(chain2).andThen(chain3).apply("0");System.out.println(apply2);// compose 相当于从内到外倒序调用String apply3 = (String) chain1.compose(chain2).compose(chain3).apply("0");System.out.println(apply3);}

identity方法的妙用：

public static void main(String[] args) {// ============ identity恒等函数的用法ArrayList<Dog> dogs = new ArrayList<>();dogs.add(new Dog("秀逗", "吃骨头"));dogs.add(new Dog("四眼", "吃馒头"));// 使用stream流 转map// Dog::getName 方法引用 也是JDK8的新特性// Function.identity()  我们想收集的map的value正好就是原对象Map<String, Dog> dogMap = dogs.stream().collect(Collectors.toMap(Dog::getName, Function.identity(), (k1, k2) -> k1));System.out.println(dogMap);}class Dog {private String name;private String hobby;public Dog(String name, String hobby) {this.name = name;this.hobby = hobby;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Dog{" +"name='" + name + '\'' +", hobby='" + hobby + '\'' +'}';}
}
Supplier供给型接口

Supplier 有一个 get() 抽象方法，用于获取结果。不接收参数，返回一个结果。

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

Supplier 可以用于延迟加载。
代码示例：

public static void main(String[] args) {Supplier supplier = () -> {return "Result";};// 只有调用get方法时 才会真正的获取结果System.out.println(supplier.get());}
Predicate断定型接口

Predicate接口中有个抽象方法test接收一个参数并返回一个布尔值。用于判断参数是否满足某种条件。

@FunctionalInterface
public interface Predicate<T> {// 接收一个参数t  返回一个布尔值boolean test(T t);// 接收到一个 Predicate 类型的参数，先调用调用者自身的test方法再&&传入参数的test方法的结果并返回布尔值default Predicate<T> and(Predicate<? super T> other) {Objects.requireNonNull(other);return (t) -> test(t) && other.test(t);}// 调用test方法并取反 default Predicate<T> negate() {return (t) -> !test(t);}// 接收一个 Predicate 类型的参数，先调用调用者自身的test方法再 || 传入参数的test方法的结果并返回布尔值default Predicate<T> or(Predicate<? super T> other) {Objects.requireNonNull(other);return (t) -> test(t) || other.test(t);}// 创建了一个 Predicate，它可以用来检查其他对象是否与给定的 targetRef 相等（如果 targetRef 非空）或是否都为 null（如果 targetRef 为空）。static <T> Predicate<T> isEqual(Object targetRef) {return (null == targetRef)? Objects::isNull: object -> targetRef.equals(object);}
}

Predicate接口的用法：

public static void main(String[] args) {Predicate predicate = (s)->{if("哈士奇".equals(s)){return true;}return false;};Predicate predicat1 = (s)->{String str = (String) s;if(str.length()==3){return true;}return false;};boolean test = predicate.test("哈士奇");System.out.println(test); // trueboolean test1 = predicate.and(predicat1).test("哈士奇");System.out.println(test1);  // truePredicate<Object> equal = Predicate.isEqual("哈士奇");boolean test2 = equal.test("二哈");System.out.println(test2);  // false}
其他的函数式接口

就不一一介绍了，了解了上面四个 自己再去看JDK源码就比较好了解其他函数式接口用途了。
在这里插入图片描述

4、方法引用

方法引用通过提供一种更加简洁、清晰的方式来引用方法，不仅提升了代码的可读性和可维护性，简化了代码的编写。

方法引用类型：

类型格式
类的静态方法类名::静态方法名
对象的实例方法实例对象::方法名
类的实例方法类名::实例方法名
类的构造器方法类::new
数组Type[]::new （Type表示数组的元素类型）

如果使用IDEA编写程序，会有方法引用的提示。
代码示例：

public static void main(String[] args) {// 类的静态方法引用Runnable eat = Dog::eat;eat.run();// 对象的实例方法引用Dog dog1 = new Dog();Runnable drink1 = dog1::drink;drink1.run();// 类的实例方法引用Consumer<Dog> drink = Dog::drink;drink.accept(new Dog());// 类的构造器方法引用Supplier<Dog> dogSupplier = Dog::new;Dog dog = dogSupplier.get();// 数组引用Function<Integer, int[]> function = int[]::new;int[] arrays = function.apply(123);}class Dog {private String name;public static void eat() {System.out.println("狗吃骨头！");}public void drink(){System.out.println("狗喝水！");}}

5、Stream API

引入Stream API的目的是为了提高集合类型数据处理的效率和代码的简洁性。

Stream API的使用分为三步。

  • ①、创建Stream流
  • ②、对Stream进行中间操作
  • ③、对Stream进行终端操作得到结果
创建Stream流

最常用的还是 通过集合的stream方法 创建Stream流

public static void main(String[] args) {List<String> list = new ArrayList<>(Arrays.asList("1", "2", "3"));// 通过集合的stream方法 创建Stream流Stream<String> stream = list.stream();// 通过 Arrays.stream方法 获取数组的 stream流IntStream stream1 = Arrays.stream(new int[]{1, 2, 3});// 使用 Stream.of方法Stream<String> stream2 = Stream.of("1", "2", "3");// 使用 Stream.builder方法Stream.Builder<Object> builder = Stream.builder();builder.accept("1");builder.accept("2");builder.accept("3");Stream<Object> stream3 = builder.build();}
中间操作

常用的中间操作：

方法名描述
map(Function<T, R> mapper)将元素通过给定的函数映射为另一个类型的元素
filter(Predicate predicate)根据给定的条件过滤元素
distinct()去除流中的重复元素
sorted()对元素进行排序，默认按自然顺序排序
sorted(Comparator comparator)使用自定义比较器对元素进行排序
limit(long maxSize)截取流中的前 maxSize 个元素
skip(long n)跳过流中的前N个元素
flatMap(Function<T, Stream> mapper)将每个元素映射为一个流，然后将这些流合并为一个流

中间操作代码示例：

public static void main(String[] args) {List<Dog> list = new ArrayList<>();Dog dog1 = new Dog("秀逗", 8);Dog dog2 = new Dog("四眼", 4);Dog dog3 = new Dog("四眼狗", 4);Dog dog4 = new Dog("哈士奇", 4);list.add(dog1);list.add(dog2);list.add(dog3);list.add(dog4);// ======================= 中间操作 =============================// map中间操作  将Dog元素 映射成 Dog中的name元素list.stream().map(Dog::getName);// filter中间操作 根据给定的条件过滤元素list.stream().filter((item) -> {return item.getAge() > 4;});// distinct() 去重  去重的标准是基于对象的equals()和hashCode()方法list.stream().distinct();// sorted()	 对元素进行排序，默认按自然顺序排序list.stream().sorted();// sorted(Comparator comparator)  使用自定义比较器对元素进行排序// 先按照年龄倒序，再按照姓名正序list.stream().sorted(Comparator.comparing(Dog::getAge).reversed().thenComparing(Dog::getName));// 自定义 ComparatorStream<Dog> sorted = list.stream().sorted((o1, o2) -> {// 先比较年龄 按照年龄从小到大排序int compareAge = Integer.compare(o1.getAge(), o2.getAge());if (compareAge != 0) {return compareAge;}// 再比较名字长度int nameLength = Integer.compare(o1.getName().length(), o2.getName().length());if (nameLength != 0) {// 长度长的在前面return -nameLength;}// 再自定义一个 如果名字里包含 哈士奇就排在前面boolean b1 = o1.getName().contains("哈士奇");boolean b2 = o2.getName().contains("哈士奇");// b1包含哈士奇 b1排在前面// 返回负数（如-1），表示第一个参数（在本例中是o1）应该排在第二个参数（o2）之前。//返回正数（如1），表示第一个参数应该排在第二个参数之后。//返回0，表示两者相等，对于排序而言，它们的相对位置不变if (b1 && !b2) {return -1;}// b2包含哈士奇 b2排在前面if (!b1 && b2) {return 1;}return 0;});// limit(n) 截取前n个元素list.stream().limit(2);// skip(long n)  跳过前n个元素list.stream().skip(2);// flatMap(Function<T, Stream> mapper)  将每个元素映射为一个流，然后将这些流合并为一个流// 相当于把有层级的 对象 都扁平化 消除层级List<List<Dog>> arrayLists = new ArrayList<>();arrayLists.add(new ArrayList<>(Arrays.asList(dog1,dog2,dog3)));arrayLists.add(new ArrayList<>(Arrays.asList(dog4)));arrayLists.stream().flatMap(List::stream);}
终端操作
方法名描述
collect()将流中的元素收集到集合或映射中，可以指定收集器来定制收集行为
forEach()对流中的每个元素执行指定的操作
forEachOrdered()与forEach类似，当使用parallelStream(并行流时)遍历时保留了元素的顺序
toArray()将流中的元素收集到数组中
reduce(accumulator)通过累积操作将流中的元素归约为单个结果
reduce(identity, accumulator)使用初始值和累积操作将流中的元素归约为单个结果
reduce(identity, accumulator, combiner)使用初始值、累积操作和组合操作将流中的元素归约为单个结果
min(comparator)使用指定的比较器找到流中的最小元素
max(comparator)使用指定的比较器找到流中的最大元素
count()计算流中元素的数量
anyMatch()检查流中是否有任何元素匹配指定的条件
allMatch()检查流中的所有元素是否都匹配指定的条件
noneMatch()检查流中是否没有元素匹配指定的条件
findFirst()返回流中的第一个元素（如果存在），通常与filter操作一起使用
findAny()返回流中的全部符合条件的元素（如果存在），通常与filter操作一起使用

终端操作代码示例：

public static void main(String[] args) {Dog dog1 = new Dog("秀逗", 8);Dog dog2 = new Dog("四眼", 4);ArrayList<Dog> dogs = new ArrayList<>();dogs.add(dog1);dogs.add(dog2);// ===============  终端操作  ===================// ============= collect()  将流中的元素收集到集合或映射中，可以指定收集器来定制收集行为// 收集SetSet<String> dogSet = dogs.stream().map(Dog::getName).collect(Collectors.toSet());// 收集ListList<String> dogList = dogs.stream().map(Dog::getName).collect(Collectors.toList());// 收集MapMap<String, Dog> dogMap = dogs.stream().collect(Collectors.toMap(Dog::getName, Function.identity(), (k1, k2) -> k1));// 收集分组Map<String, List<Dog>> dogGroup = dogs.stream().collect(Collectors.groupingBy(Dog::getName));// ========== forEach  对流中的每个元素执行指定的操作dogs.forEach(System.out::println);// ========== forEachOrdered  与forEach类似，当使用parallelStream(并行流时)遍历时保留了元素的顺序dogs.parallelStream().forEachOrdered(System.out::println);// ========== toArray  将流中的元素收集到数组中dogs.toArray();// ========== reduce(accumulator) 通过累积操作将流中的元素归约为单个结果List<String> list = Arrays.asList("1", "2", "3");list.stream().reduce((a,b)-> a+b);// ========== reduce(identity, accumulator) 使用初始值和累积操作将流中的元素归约为单个结果dogs.stream().mapToInt(Dog::getAge).reduce(0, Integer::sum);// ========== reduce(identity, accumulator, combiner)  使用初始值、累积操作和组合操作将流中的元素归约为单个结果dogs.parallelStream().map(Dog::getAge) // 将Dog流转换为年龄的IntStream.reduce(0, // 初始值 identityInteger::sum, // 累积器 accumulator，直接使用Integer的sum方法进行累加Integer::sum // 组合器 combiner，也是sum方法，用于并行处理时合并子结果);// ========== min(comparator) 使用指定的比较器找到流中的最小元素dogs.stream().min(Comparator.comparing(Dog::getAge));// ========== max(comparator)  使用指定的比较器找到流中的最大元素dogs.stream().max(Comparator.comparing(Dog::getAge));// ========== count()  计算流中元素的数量dogs.stream().count();// ==========  anyMatch()  检查流中是否有任何元素匹配指定的条件|dogs.stream().anyMatch((item)->{return item.getName().contains("哈士奇");});// ========== allMatch()  检查流中的所有元素是否都匹配指定的条件dogs.stream().allMatch((item)->{return item.getName().contains("哈士奇");});// ========== noneMatch()  检查流中是否没有元素匹配指定的条件dogs.stream().noneMatch((item)->{return item.getName().contains("哈士奇");});// ============ findFirst  返回流中的第一个元素（如果存在），通常与filter操作一起使用dogs.stream().filter((item)->{return item.getName().contains("哈士奇");}).findFirst();// ============ findAny  返回流中的全部符合条件的元素（如果存在），通常与filter操作一起使用dogs.stream().filter((item)->{return item.getName().contains("哈士奇");}).findAny();}

6、Optional 类

Optional 类本质上是一个容器类，用来更优雅的处理可能出现的空指针问题。

Optional 使用建议：

  1. 避免将Optional用作方法的参数或返回类型： Optional应该用于表示可能为null的值，而不是作为方法的参数或返回类型。在方法签名中使用Optional可能会使代码变得复杂，并且不符合Optional的设计初衷。

  2. 使用isPresent()和ifPresent()进行判断： 在使用Optional时，最好使用isPresent()方法来检查Optional是否包含值，然后使用ifPresent()方法来执行相应的操作。这样可以避免使用get()方法，从而避免潜在的空指针异常。

  3. 避免滥用Optional： Optional并不是解决所有空指针问题的银弹。在某些情况下，使用传统的null检查可能更加简单和清晰。Optional应该用于表示可能为null的值，并且仅在需要对null进行特殊处理时使用。

  4. 使用orElse()和orElseGet()提供默认值： 在使用Optional时，可以使用orElse()方法或orElseGet()方法来提供一个默认值，以防Optional为空。orElse()方法在Optional为空时会返回默认值，而orElseGet()方法在Optional为空时会执行一个Supplier函数来生成默认值。

代码示例：

public static void main(String[] args) {Dog dog = new Dog("Buddy", 3);// 创建一个Optional实例Optional<Dog> optionalDog = Optional.ofNullable(dog); // 确定有值时使用of，否则使用empty或ofNullable// 1. isPresent() 和 get()if (optionalDog.isPresent()) {System.out.println("Dog's name: " + optionalDog.get().getName());}// 2. ifPresent(Consumer)optionalDog.ifPresent(d -> System.out.println("Dog's age: " + d.getAge()));// 3. map(Function)Optional<String> dogNameOpt = optionalDog.map(Dog::getName);dogNameOpt.ifPresent(System.out::println); // 输出狗的名字// 4. flatMap(Function)// 假设有个方法返回Optional<Integer>Optional<String> mappedAgeOpt = optionalDog.flatMap(Dog::getOptionalName);mappedAgeOpt.ifPresent(name -> System.out.println("Mapped name: " + name));// 5. orElse(T)String dogNameOrDefault = optionalDog.map(Dog::getName).orElse("Unknown");System.out.println("Dog name or default: " + dogNameOrDefault);// 6. orElseGet(Supplier)String dogNameOrDefaultGet = optionalDog.map(Dog::getName).orElseGet(() -> "Fallback");System.out.println("Dog name or default via Supplier: " + dogNameOrDefaultGet);// 7. orElseThrow(Supplier)try {Dog dog1 = (Dog)Optional.empty().orElseThrow(() -> new IllegalArgumentException("Dog is missing"));} catch (IllegalArgumentException e) {System.out.println(e.getMessage());}}}@Data
class Dog {private String name;private Integer age;public Dog(String name, Integer age) {this.name = name;this.age = age;}public Optional<String> getOptionalName() {return Optional.ofNullable(name);}@Overridepublic String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +'}';}
}

7、LocalDate、LocalDateTime和DateTimeFormatter

在JDK8之前 处理日期、时间和格式化日期时间，使用 java.util.Date 、java.util.Calendar、java.text.SimpleDateFormat 这三个类。
为什么JDK8要引入 LocalDateTime 和 DateTimeFormatter呢？

有以下几个原因：

  • ①、线程不安全：
    java.util.Date 和 java.util.Calendar 线程不安全，这就导致我们在多线程环境使用需要额外注意。且java.util.Date类是可变的，我们可以随时修改它，如果不小心就会导致数据不一致问题
    java.text.SimpleDateFormat 也是线程不安全的，这可能导致日期格式化错误。而且它的模式字符串容易出错，不够直观。

  • ②、时区处理问题： Java 8 版本以前的日期 API 在时区处理上存在问题，例如时区转换和夏令时处理不够灵活和准确。而且时区信息在 Date 对象中存储不明确，这使得正确处理时区变得复杂。

LocalDate、LocalDateTime和DateTimeFormatter的使用示例：
 public static void main(String[] args) {// 获取当前时间LocalDateTime now = LocalDateTime.now();// 自定义格式化器DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");String format = formatter.format(now);System.out.println(format);// 通过格式化器 解析字符串 日期时间LocalDateTime parse1 = LocalDateTime.parse("2024-05-20 12:00:00", formatter);System.out.println(parse1);LocalDate date = LocalDate.now();// 自定义格式化器DateTimeFormatter formatterDate = DateTimeFormatter.ofPattern("yyyy-MM-dd");String formatDateStr = formatterDate.format(date);System.out.println(formatDateStr);// 通过格式化器 解析字符串 日期时间LocalDate date1 = LocalDate.parse("2024-05-20", formatterDate);System.out.println(date1);}
使用DateTimeFormatterBuilder构造特殊的解析器

构建一个能够解析两种格式的日期解析器 yyyy-MM-dd 和 yyyy/MM/dd

public static void main(String[] args) {// 构建一个能够解析两种格式的日期解析器// DateTimeFormatterBuilder 使用了方括号 [ ] 来定义备选的格式模式。// 这样构建的解析器会尝试按照提供的顺序匹配每一种模式，直到成功解析为止DateTimeFormatter formatter = new DateTimeFormatterBuilder().appendPattern("[yyyy-MM-dd]").appendPattern("[yyyy/MM/dd]").toFormatter();String dateStr1 = "2024-05-27";String dateStr2 = "2024/05/27";try {LocalDate date1 = LocalDate.parse(dateStr1, formatter);System.out.println("Parsed date 1: " + date1);LocalDate date2 = LocalDate.parse(dateStr2, formatter);System.out.println("Parsed date 2: " + date2);} catch (DateTimeParseException e) {System.err.println("Error parsing date: " + e.getMessage());}}

JDK11版本

挑几个比较重要的或者好用的特性学习下

1、全新的 HTTP 客户端 API

全新的 HTTP 客户端 API 优势：

  • **①、HTTP/2支持：**全新的 HttpClient 支持 HTTP/2 协议的所有特性，包括同步和异步编程模型。
  • ②、WebSocket支持： 支持WebSocket，允许建立持久的连接，并进行全双工通信。
  • ③、同步和异步： 提供了同步和异步的两种模式。
  • ④、链式调用： 新的HttpClient 允许链式调用，使得构建和发送请求变得更简单。
  • ⑤、更好的错误处理机制： 新的HttpClient 提供了更好的错误处理机制，当HTTP请求失败时，可以通过异常机制更清晰地了解到发生了什么。

HTTP 客户端 核心类：
java.net.http.HttpClient
java.net.http.HttpRequest
java.net.http.HttpResponse

HttpClient类常用方法：

方法注释
connectTimeout()设置建立HTTP连接的超时时间
version()指定HTTP协议的版本（HTTP/1.1或HTTP/2）
executor()设置自定义的Executor，该Executor用于异步任务
authenticator()设置HTTP身份验证
sslParameters()设置SSL/TLS的配置

HttpRequest类常用方法：

方法注释
uri()设置统一资源标识符 (URI)
header()单个添加请求头
headers()批量添加请求头
setHeader()设置特定的请求头
GET()创建一个 GET 请求
POST(HttpRequest.BodyPublisher body)创建一个带有请求体的 POST 请求
PUT(HttpRequest.BodyPublisher body)创建一个带有请求体的 PUT 请求
DELETE()创建一个 DELETE请求

HttpResponse类常用方法：

方法注释
statusCode()获取HTTP响应的状态码
body()获取HTTP响应体
headers()获取HTTP响应头

同步请求使用示例：

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;public class TestA {public static void main(String[] args) {HttpClient client = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(10))  // 连接超时为10秒.build();HttpRequest request = HttpRequest.newBuilder().uri(URI.create("https://www.baidu.com")) // 链接.GET()   // 请求方式.timeout(Duration.ofSeconds(10)) // 接口超时时间.build();HttpResponse<String> response = null;try {response = client.send(request, HttpResponse.BodyHandlers.ofString());} catch (Exception e) {e.printStackTrace();}System.out.println(response.body());}
}

异步请求使用示例：

public static void main(String[] args) {// 构建 HttpClient 对象HttpClient httpClient = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(10))  // 连接超时为10秒.build();// 构建 HttpRequest 对象HttpRequest request = HttpRequest.newBuilder().uri(URI.create("https://www.baidu.com")) // 链接.timeout(Duration.ofSeconds(5))     // 超时时间为 5 秒.GET()   // 请求方式.build();// 发送异步请求CompletableFuture<HttpResponse<String>> futureResponse = httpClient.sendAsync(request, HttpResponse.BodyHandlers.ofString());// 处理响应futureResponse.thenApply(HttpResponse::body)    // 获取响应体.thenAccept(System.out::println);        // 打印响应体System.out.println("异步请求");futureResponse.join(); // 等待处理完成}

2、处理文本文件的API

这两个API对于处理文本文件非常好用。

Files.readString(Path path)：读取一个文件的所有内容并将其返回为一个字符串。
Files.writeString(Path path, CharSequence csq, OpenOption… options)：将一个字符串写入到文件中。

代码示例：

public class TestA {public static void main(String[] args) throws IOException {Path path = Path.of("C:\\Users\\Administrator\\Desktop\\123.txt");String s = Files.readString(path);System.out.println(s);String ss = "123231\nwqedqwew\nqweqwewq";/*** StandardOpenOption的值  默认是  CREATE 和 WRITE** READ, 允许文件通道进行读取操作* WRITE, 允许文件通道进行写入操作* APPEND, 指示应该在文件的当前结尾之后追加数据，如果文件不存在，则创建新文件。* TRUNCATE_EXISTING, 如果文件已经存在，将其长度截断为0，即清空文件内容，然后开始写入。* CREATE, 如果指定的文件不存在，则创建它。如果文件已存在，这个选项本身不会影响其内容。* CREATE_NEW, 仅在文件不存在时创建新文件。如果文件已存在，则写入操作失败并抛出FileAlreadyExistsException异常。* DELETE_ON_CLOSE, 当关闭相关的通道或流时，自动删除此文件。这对于临时文件特别有用。* SPARSE, 指示文件系统应为文件使用稀疏文件支持。这对于大文件特别有用，可以减少实际分配的磁盘空间。* SYNC, 要求对文件的元数据和内容的更新同步写入到存储设备。这是最安全但可能较慢的选项，确保了在发生系统崩溃后数据的一致性。* DSYNC; 也称为DATA_SYNC）：要求仅文件内容的更新同步写入到存储设备，而元数据更新可以有不同的同步策略。*       相比SYNC，这个选项提供了较好的性能折衷，但仍保证了数据的基本完整性。** */Files.writeString(path, ss);}
}

3、新增 ZGC

Z Garbage Collector，这款垃圾回收器的主要特点是可伸缩的、低延迟。

  • 低延迟：ZGC旨在实现暂停时间不超过10毫秒的目标。这对于要求极低停顿时间的应用（如金融服务、交易系统和大型Web服务）非常有利。

  • 可扩展性：ZGC设计用于处理非常大的内存容量，能够高效管理数百GB乃至TB级别的堆内存，非常适合现代云基础设施中的大内存服务器。

  • 并发执行：几乎所有垃圾回收工作都是并发执行的，包括标记、重定位（即移动存活对象）、压缩等过程，从而大大减少了应用程序的停顿时间。

  • 无分代设计：ZGC摒弃了传统分代收集器中的年轻代和老年代的概念，转而采用统一的内存管理方式，虽然它内部有类似颜色的区分来优化垃圾回收效率，但对外呈现的是单一内存池。

  • 可选择的内存限制：用户可以通过JVM参数设置堆内存的使用上限，ZGC会尝试保持堆的使用不超过这个限制，有助于容器化环境中的资源管理。

ZGC的使用：
ZGC在JDK11版本 ，只支持 Linux/x64 操作系统。
为了方便演示，我这里 使用JDK22版本在 Windows系统上演示。

ZGC垃圾回收器 需要手动指定。
在JVM的启动参数上新增如下参数：

-XX:+UnlockExperimentalVMOptions -XX:+UseZGC

-XX:+UnlockExperimentalVMOptions 允许使用实验性特性
-XX:+UseZGC 使用ZGC 作为垃圾回收器

从JDK 15开始，ZGC（Z Garbage Collector）就已经成为默认启用的垃圾收集器之一，无需再使用-XX:+UnlockExperimentalVMOptions来解锁实验性特性。这意味着从JDK 15及之后的版本可以直接通过 -XX:+UseZGC 选项来启用ZGC，而不需要额外的标志来解锁实验性功能。
在这里插入图片描述

添加如下JVM启动参数： -Xlog:gc*:file=gc.log:time

看下启动后的gc日志：

[2024-05-28T15:05:46.172+0800] Initializing The Z Garbage Collector    // 初始化ZGC
[2024-05-28T15:05:46.172+0800] Version: 22.0.1+8-16 (release)  // Java版本
[2024-05-28T15:05:46.172+0800] Using legacy single-generation mode // ZGC当前配置为使用传统的单代模式进行垃圾回收
[2024-05-28T15:05:46.172+0800] NUMA Support: Disabled   // NUMA（非统一内存访问）优化未被启用
[2024-05-28T15:05:46.172+0800] CPUs: 8 total, 8 available  // 系统总共有8个CPU核心，全部可用，并且可用内存为16.2GB
[2024-05-28T15:05:46.172+0800] Memory: 16207M    // 系统总共有8个CPU核心，全部可用，并且可用内存为16.2GB
[2024-05-28T15:05:46.172+0800] Large Page Support: Disabled  // 大页内存支持，大页可以减少内存管理开销
[2024-05-28T15:05:46.172+0800] GC Workers: 2 (dynamic)  // 有2个动态调整的垃圾回收工作线程
[2024-05-28T15:05:46.172+0800] Address Space Type: Contiguous/Unrestricted/Complete  //  ZGC的地址空间配置，大小为9.6GB，采用连续、不受限、完整的地址空间类型
[2024-05-28T15:05:46.173+0800] Address Space Size: 3200M x 3 = 9600M // ZGC的地址空间配置，大小为9.6GB，采用连续、不受限、完整的地址空间类型
[2024-05-28T15:05:46.173+0800] Min Capacity: 8M  // 最小堆容量8MB
[2024-05-28T15:05:46.173+0800] Initial Capacity: 200M  //初始化堆容量200MB
[2024-05-28T15:05:46.173+0800] Max Capacity: 200M  //最大堆容量200MB
[2024-05-28T15:05:46.173+0800] Medium Page Size: 4M // 设置为4MB，这通常用于内部内存分配和管理
[2024-05-28T15:05:46.173+0800] Pre-touch: Disabled  // 不会预先分配和初始化所有内存页以减少以后的页面错误，这可能会在首次访问时增加延迟
[2024-05-28T15:05:46.173+0800] Uncommit: Enabled   // 启用了解除提交内存功能，允许JVM释放不再需要的物理内存给操作系统，并设置了300秒的延迟
[2024-05-28T15:05:46.173+0800] Uncommit Delay: 300s
[2024-05-28T15:05:46.181+0800] Runtime Workers: 2   // 运行时工作线程: 同样为2个，与GC工作线程数一致
[2024-05-28T15:05:46.181+0800] Using The Z Garbage Collector  // 开始使用 ZGC

关于ZGC更深入的知识点 在后面学习JVM的时候再写…

JDK17版本

1、增强版伪随机数生成器

在JDK17版本之前 我们要生成随机数据主要通过：
java.util.Random
java.security.SecureRandom

这两个实现都有局限性：

Random生成的随机数有可预测性：
java.util.Random 使用的是一个线性同余生成器（LCG）算法，Random 的输出是完全可预测的，如果我们知道种子和算法，完全可以生成相同的随机序列。这在需要高安全性的随机数生成（如加密）时是不合适的。

java.security.SecureRandom 是 Java 提供的一个用于生成加密强度随机数的类，专门为需要高安全性的应用场景设计，比如加密、安全令牌生成、会话密钥以及数字签名应用。

SecureRandom 优劣势分析：

优势劣势
安全性高： SecureRandom设计用于提供加密强度的随机数生成，这意味着它生成的随机数更难以预测，对于安全敏感的应用至关重要。它通常基于操作系统提供的强随机数生成器（例如 /dev/urandom 在Unix-like系统中），或者使用硬件随机数生成器（如果可用），以确保高度的不可预测性。性能问题： 由于SecureRandom强调安全性，它的生成速度可能比非安全的随机数生成器（如java.util.Random）慢。特别是在大量需要随机数的场景下，这种性能差异可能会成为瓶颈。
可配置性： 用户可以选择不同的随机数生成算法，Java提供了多种算法供选择，比如SHA1PRNG、NativePRNG等，可以根据应用场景的安全需求和性能要求来定制。资源消耗： 特别是当依赖于硬件随机数生成器时，如果硬件生成随机数的速度较慢或资源紧张，可能会对系统整体性能产生影响。

JDK17版本引入了 增强版伪随机数生成器
RandomGenerator 接口：

获取RandomGenerator 实例：

  • 默认实现 RandomGenerator.getDefault()
  • 使用RandomGenerator.of(String name)获取特定的随机数生成器，name 为预定义的生成器名称。
  • 使用RandomGeneratorFactory 工厂 获取RandomGenerator 实例
    代码示例：
import java.util.random.RandomGenerator;
import java.util.random.RandomGeneratorFactory;public class TestA {public static void main(String[] args) {// 获取默认的 随机数生成器RandomGenerator randomGenerator1 = RandomGenerator.getDefault();// 获取指定的 随机数生成器RandomGenerator randomGenerator2 = RandomGenerator.of("Xoshiro256PlusPlus");// 使用 随机数生成工厂RandomGeneratorFactory 获取默认的随机数生成器RandomGeneratorFactory<RandomGenerator> aDefault = RandomGeneratorFactory.getDefault();RandomGenerator randomGenerator3 = aDefault.create();// 使用 随机数生成工厂RandomGeneratorFactory 获取指定的随机数生成器RandomGeneratorFactory<RandomGenerator> factory = RandomGeneratorFactory.of("Xoshiro256PlusPlus");RandomGenerator randomGenerator4 = factory.create();// 打印工厂中所有可用的随机数生成器RandomGeneratorFactory.all().forEach((item)->System.out.println(item.name()));}
}

RandomGeneratorFactory工厂中所有可用的随机数生成器如下：

随机数生成器名称版本使用算法特性
RandomJDK1.0线性同余生成器 (LCG)简单、快速，但周期短且质量较低
SecureRandomJDK1.1依赖于底层平台提供的安全随机数生成算法高质量、安全的随机数，适用于加密等安全需求，但是性能一般
L32X64MixRandomJDK17LXM系列算法，基于线性同余和XorShift高性能、适合并行计算，适用于普通用途
L128X128MixRandomJDK17LXM系列算法，基于线性同余和XorShift增强版L32X64，具有更长的周期和更高的质量
L64X128MixRandomJDK17LXM系列算法，基于线性同余和XorShift适用于需要中等周期和质量的应用
L128X1024MixRandomJDK17LXM系列算法，基于线性同余和XorShift超长周期，高质量，适用于高需求应用
L64X128StarStarRandomJDK17LXM系列算法，基于线性同余和XorShift类似L64X128，但具有不同的混合策略
Xoshiro256PlusPlusJDK17Xoshiro256++ 算法高速、长周期，适用于高性能计算
L64X256MixRandomJDK17LXM系列算法，基于线性同余和XorShift提供更长的周期，适用于需要更高质量随机数的场景
Xoroshiro128PlusPlusJDK17Xoroshiro128++ 算法高速、适合资源有限的环境
L128X256MixRandomJDK17LXM系列算法，基于线性同余和XorShift非常长的周期，适用于对随机数质量要求极高的场景
SplittableRandomJDK17基于64位乘法哈希算法高性能、线程安全，适合并行计算
L64X1024MixRandomJDK17LXM系列算法，基于线性同余和XorShift超长周期，适用于需要极高质量随机数的场景

比较常用的方法

  • 生成随机数：例如 nextInt()、nextInt(0, 100)、nextLong()
  • 生成随机数流：例如 ints()、longs()，这些方法返回的是一个 Stream，对于生成大量随机数比较有用。

代码示例：

import java.util.random.RandomGenerator;public class TestA {public static void main(String[] args) {// 获取默认的 随机数生成器RandomGenerator randomGenerator = RandomGenerator.getDefault();// 范围是 Integer.MIN_VALUE（-2^31）到 Integer.MAX_VALUE（2^31 - 1）之间的所有整数。int i = randomGenerator.nextInt();System.out.println(i);// 生成 [0,100) 之间的整数   包含0，不包含100int i1 = randomGenerator.nextInt(100);System.out.println(i1);// 生成 [50,100) 之间的整数   包含50，不包含100int i2 = randomGenerator.nextInt(50,100);System.out.println(i2);// 获取无限随机数流  并截取前10个  默认的int类型最大范围randomGenerator.ints().limit(10).forEach(System.out::println);// 获取包含10个随机数的流  默认的int类型最小范围randomGenerator.ints(10).forEach(System.out::println);// 生成一个无限的范围在[10, 20)的随机数流，并截取前10个，直接打印randomGenerator.ints(10, 20).limit(10).forEach(System.out::println);}
}

2、增强版Switch

  • 防止的Fall-through新写法 (守卫模式)
    case xxx -> 可以不用谢break; 也能防止穿透

  • 模式匹配(类型模式、空模式、常量模式)

测试这个Demo 需要稍微新点版本的 IDEA 我用的IntelliJ IDEA 2023.1

public class TestA {public static void main(String[] args) {Object[] objects = {"Java", 123, "C#", "PHP", 6.66, "DeepJava"};for (Object obj : objects) {switch (obj) {case Integer intR -> System.out.println("整数型：" + intR);case Float floatR -> System.out.println("浮点型：" + floatR);case Double doubleR -> System.out.println("双精度浮点数：" + doubleR);case String str && str.length() > 5 -> System.out.println("长度超过5的字符串：" + str);case String str -> System.out.println("短字符串：" + str);case null -> System.out.println("为空值");default -> System.out.println("其他类型：" + obj);}}}
}

JDK21版本

1、虚拟线程

虚拟线程在 JDK 19 版本中作为预览特性引入，旨在简化和改善 Java 的并发模型。
在JDK 21版本 虚拟线程已经被作为正式特性。

理解平台线程和系统内核线程的对应关系：
在JVM中 java.lang.Thread 就代表平台线程， HotSpot 虚拟机在Windows和Linux操作系统下，一个平台线程对应一个内核线程(在其他操作系统下 这个对应关系就不一定是1:1了)。

如下图所示：
在这里插入图片描述
平台线程的优劣势
优势：

优势描述举例
一对一映射在JVM中，java.lang.Thread代表平台线程。HotSpot虚拟机在Windows和Linux操作系统下，一个平台线程对应一个内核线程。每个Java平台线程对应一个由操作系统管理的内核线程。
多线程并发平台线程允许Java程序进行并发操作，提高程序的并发能力和资源利用率。可以在一个线程中进行网络请求，在另一个线程中进行文件读写。
硬件加速平台线程可以利用操作系统的多核处理能力，实现真正的并行计算。高性能计算应用程序可以通过多核处理实现并行计算。

劣势：

劣势描述举例
高开销平台线程的创建和销毁成本较高，涉及操作系统级别的资源分配和管理。服务器应用为每个请求创建一个新线程，消耗大量资源。
线程数量受限操作系统能够支持的线程数量有限，在高并发场景下可能很快达到资源限制。高并发Web服务器可能因线程资源耗尽而无法响应新请求。
阻塞问题使用阻塞I/O操作时，平台线程会一直占用内核线程，导致资源浪费。文件读写操作使用阻塞I/O时，线程在操作完成前一直阻塞。
上下文切换开销平台线程的上下文切换开销较大，涉及寄存器、内存等资源的切换。多线程应用频繁进行线程上下文切换，降低程序执行效率。

理解虚拟线程和平台线程的对应关系：
上面说了在JVM中 java.lang.Thread 就代表平台线程， 在JDK19开始引入虚拟线程后，为了使得虚拟线程的使用能够如同使用平台线程一样，所以 java.lang.Thread 也代表了虚拟线程，只是二者的创建方式和底层实现不同，对平台线程和虚拟线程的抽象都是用 java.lang.Thread 表示。
这么设计最直接的好处就是虚拟线程的API与平台线程相同，开发者无需学习新的并发模型或API，可以直接在现有代码中使用虚拟线程。这使得现有的多线程代码可以无缝地转换为使用虚拟线程。
如下图所示：
在这里插入图片描述
虚拟线程的优劣势
优势：

优势描述平台线程对比
轻量级虚拟线程消耗的系统资源更少，可以在同一个JVM进程中创建和管理大量线程。(甚至可以创建上万数量级的虚拟线程)平台线程创建和销毁成本高，涉及操作系统级别的资源管理。
高并发能够同时运行数万个虚拟线程，甚至更高，提高并发能力，特别适用于I/O密集型任务。平台线程数量受限，高并发场景下可能达到系统资源限制。 但是平台线程更适合做密集计算和精细控制线程行为的场景
简单的同步编程支持传统的同步阻塞编程模型，开发者无需学习新的并发模型，代码更易理解和维护。
高效利用CPU虚拟线程在等待I/O操作时可以释放平台载体线程去执行其他任务，提高CPU利用率。平台线程上下文切换开销较大，频繁切换会影响系统性能。
工具链兼容调试器、分析工具和其他基于Thread API的工具无需修改即可支持虚拟线程。平台线程已经广泛支持现有工具链，但管理和调试大量线程复杂且资源消耗大。

劣势：

劣势描述平台线程对比
性能不确定性在某些极端情况下，虚拟线程的性能可能无法预期，需要实际测试和调整。平台线程性能稳定，但由于高开销和数量限制，扩展性差。

总结下平台线程和虚拟线程的适用场景

平台线程的适用场景

场景描述示例
高性能计算平台线程能够充分利用多核处理器的并行计算能力，适用于CPU密集型任务。科学计算、图像处理、视频编码等需要大量计算资源的应用。
需要操作系统级特性的应用平台线程可以直接利用操作系统提供的线程管理和调度功能，适用于需要与操作系统深度交互的任务。低延迟、高可靠性的系统服务，如数据库管理系统、网络服务器等。
固定数量的并发任务适用于并发任务数量相对固定且有限的场景，线程管理和资源开销可以接受。传统的Web服务器、应用服务器等，处理相对少量并发请求。
阻塞I/O操作虽然平台线程在阻塞I/O操作时会占用内核线程，但在某些情况下，平台线程的使用仍然合适。需要处理少量阻塞I/O操作且对线程资源消耗不敏感的应用，如简单的文件读写操作。

虚拟线程的适用场景

场景描述示例
高并发、I/O密集型任务虚拟线程可以轻松管理大量并发任务，特别适用于I/O密集型操作，如网络通信、文件读写等。高并发的Web服务器、微服务架构中的各个服务节点。
轻量级并发任务虚拟线程创建和销毁成本低，非常适合需要频繁创建和销毁线程的应用。实时聊天应用、大规模的消息处理系统。
复杂的业务逻辑虚拟线程支持简单的同步阻塞编程模型，使得编写和维护复杂的业务逻辑变得更加容易。涉及复杂数据处理和业务流程的后台服务。
高扩展性要求虚拟线程能够在不显著增加系统资源开销的情况下支持数万个并发任务，适用于需要高扩展性的应用。物联网（IoT）平台、大规模在线游戏服务器。
资源受限环境虚拟线程在资源受限的环境下表现出色，可以显著减少内存和CPU的使用。嵌入式系统、边缘计算设备。

运行下面的代码 建议IDEA使用新点的版本，我使用的是IntelliJ IDEA 2023.3.6。
虚拟线程的创建代码示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;public class TestA {public static void main(String[] args){// 方式一、Thread.ofVirtual()Thread thread = Thread.ofVirtual().name("虚拟线程").start(()->{System.out.println("虚拟线程1执行任务");});// 方式二、Thread.startVirtualThread()Thread.startVirtualThread(()-> System.out.println("虚拟线程执行任务"));// 方式三、线程池try (ExecutorService executorService = Executors.newVirtualThreadPerTaskExecutor();){executorService.execute(()->{System.out.println("虚拟线程执行任务");});} catch (Exception e) {throw new RuntimeException(e);}//方式四、通过 ThreadFactory 创建// 获取线程工厂类ThreadFactory factory = Thread.ofVirtual().factory();Thread newThread = factory.newThread(() -> {System.out.println("虚拟线程执行任务");});newThread.start();}
}

2、序列化集合

主要有以下三个接口：
SequencedCollection
SequencedSet
SequencedMap

目的是提供统一的方法来获取集合的第一个元素和最后一个元素。

下面用 ArrayList，LinkedHashSet，LinkedHashMap举例

import java.util.*;public class TestA {public static void main(String[] args) {List<String> list = new ArrayList<>(Arrays.asList("1", "2", "3"));System.out.println(list.getFirst());   // 1System.out.println(list.getLast());   // 3LinkedHashSet<String> hashSet = new LinkedHashSet<>();hashSet.add("1");hashSet.add("2");hashSet.add("3");System.out.println(hashSet.getFirst());  // 1System.out.println(hashSet.getLast());  // 3LinkedHashMap<String, String> map = new LinkedHashMap<>();map.put("1","1");map.put("2","2");map.put("3","3");System.out.println(map.firstEntry());  // 1=1System.out.println(map.lastEntry());  // 3=3}
}

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

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

相关文章

Facebook的创新实验室：人工智能与新技术探索

Facebook的创新实验室：人工智能与新技术探索

Facebook作为全球领先的社交媒体平台之一&#xff0c;一直在不断探索和应用最新的技术来改善用户体验、推动创新和拓展业务边界。其创新实验室更是探索人工智能&#xff08;AI&#xff09;和新技术的前沿&#xff0c;为未来的社交媒体发展开辟了新的可能性。本文将深入探讨Face…
阅读更多...
【题解 | 分享】2023年十四届蓝桥杯国赛（Java B组）

【题解 | 分享】2023年十四届蓝桥杯国赛（Java B组）

互质 答案&#xff1a;640720414 参考&#xff1a; public class Main {static int mod 1000000007;public static void main(String[] args) {long sum power(2023, 2023);long p1 ((sum % mod) * power( 7, mod - 2)) % mod;long p2 ((sum % mod) * power( 17, mod -…
阅读更多...
【ZYNQ】SCU 与 GIC

【ZYNQ】SCU 与 GIC

在多 CPU 架构中&#xff0c;处理器之间可以对共享数据进行操作。Snoop control uint (SCU) 模块用于确保每个处理器都在最新的数据拷贝上运行&#xff0c;从而保持缓存一致性。通用中断控制器 Generic interrupt controller (GIC) 使用优先级的思想&#xff0c;管理 CPU 中断信…
阅读更多...
Spring系统学习 - Spring入门

Spring系统学习 - Spring入门

什么是Spring&#xff1f; Spring翻译过来就是春天的意思&#xff0c;字面意思&#xff0c;冠以Spring的意思就是想表示使用这个框架&#xff0c;代表程序员的春天来了&#xff0c;实际上就是让开发更加简单方便&#xff0c;实际上Spring确实做到了。 官网地址&#xff1a;ht…
阅读更多...
【Mac】XMind for mac（XMind思维导图）v24.04.10311软件介绍和安装教程

【Mac】XMind for mac（XMind思维导图）v24.04.10311软件介绍和安装教程

软件介绍 XMind for Mac是一款功能强大的思维导图软件。它具有以下主要特点&#xff1a; 1.多样化的思维导图功能&#xff1a;XMind for Mac提供了丰富的思维导图编辑功能&#xff0c;用户可以创建各种类型的思维导图&#xff0c;包括组织结构图、逻辑图、时间轴图等&#xf…
阅读更多...
fluent UI v9版本Dialog右上角x按钮聚焦问题解决

fluent UI v9版本Dialog右上角x按钮聚焦问题解决

右上角x按钮聚焦效果展示 第一次点击不会聚焦&#xff0c;第二次或多次点击会出现这种情况。如果多个地方公用一个页面里&#xff0c;这个页面包含这个组件&#xff0c;那其它页面刚打开弹框就是聚焦状态&#xff0c;是个样式的问题。 解决&#xff1a; import * as React fr…
阅读更多...
【Vue3】自定义组件directiveapp.use()

【Vue3】自定义组件directiveapp.use()

历史小剧场 崇祯很勤政&#xff0c;崇祯并非王国之君&#xff0c;弘光很昏庸&#xff0c;弘光活该倒霉&#xff0c;几百年来&#xff0c;我们都这样认为。 但我们之所以一直这样认为&#xff0c;只是因为有人这样告诉我们。 之所以有人这样告诉我们&#xff0c;是因为他们希望我…
阅读更多...
比较与深浅克隆

比较与深浅克隆

1.比较 &#xff08;1&#xff09;Comparable接口&#xff1a;&#xff08;重写compareTo方法&#xff09; 由于它是一个接口&#xff0c;而且在这个接口中只有一个compareTo方法&#xff0c;所以所有实现该接口的类都需要重写。这个compareTo方法相当于制定一个比较标准&…
阅读更多...
pyinstaller将py文件打包成exe

pyinstaller将py文件打包成exe

pyinstaller将py文件打包成exe 一、为什么需要将python文件打包成exe文件？二、具体操作步骤一、为什么需要将python文件打包成exe文件？ python文件需要在python环境中运行，也就是需要安装python解释器。有时我们自己写的python程序需要分享给自己的朋友、同事或者合作伙伴，…
阅读更多...
封装一个websocket，支持断网重连、心跳检测，拿来开箱即用

封装一个websocket，支持断网重连、心跳检测，拿来开箱即用

封装一个websocket&#xff0c;支持断网重连、心跳检测 代码封装 编写 WebSocketClient.js import { EventDispatcher } from ./dispatcherexport class WebSocketClient extends EventDispatcher {constructor(url) {console.log(url, urlurl)super()this.url url}// #soc…
阅读更多...
STM32_FSMC_HAL（介绍）

STM32_FSMC_HAL（介绍）

FSMC&#xff08;Flexible Static Memory Controller&#xff09;是STM32微控制器中的一种内存控制器&#xff0c;它允许微控制器与外部存储器接口&#xff0c;如SRAM、NOR Flash、NAND Flash和PSRAM等。FSMC特别适用于需要高速数据交换和大量数据存储的应用场景。 典型应用&a…
阅读更多...
react跨组件通信Context

react跨组件通信Context

案例&#xff1a;现在有个父-子-孙组件 需要进行组件通信 import { useState } from "react"; // 创建上下文 const CountContext React.createContext();//子组件 const SonComponent (props) > {return (<div><h2>子组件</h2><Grandson…
阅读更多...
【机器学习】让大模型变得更聪明

【机器学习】让大模型变得更聪明

文章目录 前言1. 理解大模型的局限性1.1 理解力的挑战1.2 泛化能力的挑战1.3 适应性的挑战 2. 算法创新&#xff1a;提高模型学习和推理能力2.1 自监督学习2.2 强化学习2.3 联邦学习 3. 数据质量与多样性&#xff1a;增强模型的泛化能力3.1 高质量数据的获取3.2 数据多样性的重…
阅读更多...
#1 深度优先搜索

#1 深度优先搜索

深搜思想 DFS其实是针对图论的一种搜索算法&#xff0c;由一个节点出发&#xff0c;不撞南墙不回头式的遍历所有的节点。 如先遍历1&#xff0c;沿&#xff08;1,2&#xff09;遍历2&#xff0c;再沿&#xff08;2,4&#xff09;遍历4&#xff0c;撞南墙&#xff08;边界条件…
阅读更多...
XSS另类攻击(四)kali系统beef-xss安装和使用

XSS另类攻击(四)kali系统beef-xss安装和使用

★★免责声明★★ 文章中涉及的程序(方法)可能带有攻击性&#xff0c;仅供安全研究与学习之用&#xff0c;读者将信息做其他用途&#xff0c;由Ta承担全部法律及连带责任&#xff0c;文章作者不承担任何法律及连带责任。 1、环境说明 kali系统&#xff0c;ip&#xff1a;192.1…
阅读更多...
k8s的ci/cd实践之旅

k8s的ci/cd实践之旅

书接上回k8s集群搭建完毕&#xff0c;来使用它强大的扩缩容能力帮我们进行应用的持续集成和持续部署&#xff0c;整体的机器规划如下&#xff1a; 1.192.168.8.156 搭建gitlab私服 docker pull gitlab/gitlab-ce:latest docker run --detach --hostname 192.168.8.156 --publ…
阅读更多...
SAP 生产订单批量报工(代码分享)

SAP 生产订单批量报工(代码分享)

最近公司一直在对成本这块的业务进行梳理，影响比较大的就是生产这块的报工，经常会要求要批量的冲销报工，然后在继续报工，来调整生产订单的实际工时，前面的博客中已经给大家分享了批量冲销生产订单的代码， 下面给大家分享一下生产订单批量报工的代码 首先流程制造和离散制…
阅读更多...
【算法】过桥

【算法】过桥

✨题目链接&#xff1a; 过桥 ✨题目描述 ✨输入描述: 第一行一个数n(2≤n≤2000) 接下来一行n个数a[i](1≤|a[i]|≤2000)表示浮块上的数字 ✨输出描述: 输出一行&#xff0c;表示对应的答案 ✨示例1 &#x1f4cd;输入 4 2 2 -1 2 &#x1f4cd;输出 2 &#x1f4cd;说明 1…
阅读更多...
HNCTF 2024 ez_pecp 冰蝎+CS流量分析

HNCTF 2024 ez_pecp 冰蝎+CS流量分析

考点:冰蝎webshell流量分析CS4.x流量解密 给了两个 流量包 第一个 ctf1.pcapng 查看其HTTP请求 而在CS中流量特征是基于tls协议 http-beacon 通信中&#xff0c;默认使用 GET 方法向 /dpixel 、/__utm.gif 、/pixel.gif 等地址发起请求&#xff0c;而且下发指令的时候会请求 …
阅读更多...
如何使用浔川AI翻译机？——浔川AI社

如何使用浔川AI翻译机？——浔川AI社

1 前言 对于“如何使用浔川AI翻译机&#xff1f;”这个问题&#xff0c;我们官方 总结出以下结论&#xff1a; 首先&#xff1a; 复制以下代码&#xff1a; # -*- coding: utf-8 -*- import tkinter as tk import tkinter.messagebox import pickle import random# 窗口 wi…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023