Java 22 新特性

最新推荐文章于 2024-06-04 09:30:59 发布
最新推荐文章于 2024-06-04 09:30:59 发布
阅读量1.5k 收藏 23
点赞数 12
分类专栏： # java各版本新特性 文章标签： java Java22 新特性
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang_luwei/article/details/137247918
版权
Java22引入了12项新特性，包括G1的区域锚定、super(...)前导语句、FFMAPI、流聚合器等，旨在提升性能、简化代码和优化内存管理。这些新特性涉及核心库、语言规范、HotSpot和工具组件，展示了Oracle在Java生态系统的持续改进。
摘要由CSDN通过智能技术生成

文章目录

Java22 新特性

JDK 22 于 2024 年 3 月 19 日 发布

官方文档：OpenJDK Java 22 文档

Java各个版本的文档入口：Java平台，标准版文档

Java各个版本下载：https://jdk.java.net/archive/

JDK 22 共有 12 个新特性：

423:Region Pinning for G1
447:Statements before super(…) (Preview)
454:Foreign Function & Memory API
456:Unnamed Variables & Patterns
457:Class-File API (Preview)
458:Launch Multi-File Source-Code Programs
459:String Templates (Second Preview)
460:Vector API (Seventh Incubator)
461:Stream Gatherers (Preview)
462:Structured Concurrency (Second Preview)
463:Implicitly Declared Classes and Instance Main Methods (Second Preview)
464:Scoped Values (Second Preview)

JEP 423: G1 的区域锚定

JEP 423: Region Pinning for G1

主要是通过引入Region Pinning来降低使用JNI时G1收集器的延时。与Java代码不同，JNI交互可能使用指向堆中对象的显式指针。当Java线程执行JNI 代码的关键区域时，无法在堆中重新定位这些对象。为了避免此问题，G1在关键区域禁用GC，这可能会导致延迟增加，因为如果其他非JNI线程触发GC，它们将被阻止。此更改允许G1 GC通过固定JNI代码使用的内存区域但允许重新定位和收集其他内存区域，即使线程位于关键区域也可以运行。

JEP 447: super(…) 前导语句（预览版）

JEP 447: Statements before super(…) (Preview)

作为一种面向对象的语言，Java 提供了扩展另一个（非最终）类并继承状态和行为（在允许的情况下）的能力。为了可靠地工作，必须以自上而下的顺序调用类的构造函数，以避免子类构造函数干扰超类构造函数。当开发人员决定显式调用超类构造函数时，这必须是第一个语句。这会带来一些限制，这可能会导致代码比预期的更复杂。其中最明显的是，在调用超类构造函数之前，无法对构造函数参数执行测试。如果测试导致引发异常，则对超类构造函数的调用在技术上将成为不必要的开销。

此JEP引入了一种在调用super之前允许语句的受控方法。

比如在JEP 447之前的代码如下：

public class PositiveBigInteger extends BigInteger {

    public PositiveBigInteger(long value) {
        super(value);               // Potentially unnecessary work
        if (value <= 0)
            throw new IllegalArgumentException(non-positive value);
    }

}

在JEP 447之后代码可以如下：

public class PositiveBigInteger extends BigInteger {

    public PositiveBigInteger(long value) {
        if (value <= 0)
            throw new IllegalArgumentException(non-positive value);
        super(value);
    }

}

JEP 454: 外部函数和内存 API

JEP 454: Foreign Function & Memory API

Foreign Function & Memory (FFM) API包含了两个incubating API
JDK14的JEP 370: Foreign-Memory Access API (Incubator)引入了Foreign-Memory Access API作为incubator
JDK15的JEP 383: Foreign-Memory Access API (Second Incubator)Foreign-Memory Access API作为第二轮incubator
JDK16的JEP 393: Foreign-Memory Access API (Third Incubator)作为第三轮，它引入了Foreign Linker API (JEP 389)
FFM API在JDK 17的JEP 412: Foreign Function & Memory API (Incubator)作为incubator引入
FFM API在JDK 18的JEP 419: Foreign Function & Memory API (Second Incubator)作为第二轮incubator
JDK19的JEP 424: Foreign Function & Memory API (Preview)则将FFM API作为preview API
JDK20的JEP 434: Foreign Function & Memory API (Second Preview)作为第二轮preview
JDK21的JEP 442: Foreign Function & Memory API (Third Preview)作为第三轮preview
JDK22的JEP 454则正式发布此特性

使用示例

// 1. Find foreign function on the C library path
Linker linker          = Linker.nativeLinker();
SymbolLookup stdlib    = linker.defaultLookup();
MethodHandle radixsort = linker.downcallHandle(stdlib.find("radixsort"), ...);
// 2. Allocate on-heap memory to store four strings
String[] javaStrings = { "mouse", "cat", "dog", "car" };
// 3. Use try-with-resources to manage the lifetime of off-heap memory
try (Arena offHeap = Arena.ofConfined()) {
    // 4. Allocate a region of off-heap memory to store four pointers
    MemorySegment pointers
        = offHeap.allocate(ValueLayout.ADDRESS, javaStrings.length);
    // 5. Copy the strings from on-heap to off-heap
    for (int i = 0; i < javaStrings.length; i++) {
        MemorySegment cString = offHeap.allocateFrom(javaStrings[i]);
        pointers.setAtIndex(ValueLayout.ADDRESS, i, cString);
    }
    // 6. Sort the off-heap data by calling the foreign function
    radixsort.invoke(pointers, javaStrings.length, MemorySegment.NULL, '\0');
    // 7. Copy the (reordered) strings from off-heap to on-heap
    for (int i = 0; i < javaStrings.length; i++) {
        MemorySegment cString = pointers.getAtIndex(ValueLayout.ADDRESS, i);
        javaStrings[i] = cString.reinterpret(...).getString(0);
    }
} 
// 8. All off-heap memory is deallocated here
assert Arrays.equals(javaStrings, new String[] {"car", "cat", "dog", "mouse"});  // true

JEP 456: 未命名变量和模式

JEP 456: Unnamed Variables & Patterns

Unnamed Patterns and Variables支持用_来替代没有使用的变量声明
JDK21的JEP 443: Unnamed Patterns and Variables (Preview)作为preview
JDK22的JEP 456则正式发布

比如之前的代码是这样子：

static boolean isDelayTimeEqualToReverbRoomSize(EffectLoop effectLoop) {
    if (effectLoop instanceof EffectLoop(Delay(int timeInMs), Reverb(String name, int roomSize))) {
        return timeInMs == roomSize;
    }
    return false;
}

使用此特性之后如下：

static boolean isDelayTimeEqualToReverbRoomSize(EffectLoop effectLoop) {
    if (effectLoop instanceof EffectLoop(Delay(int timeInMs), Reverb(_, int roomSize))) {
        return timeInMs == roomSize;
    }
    return false;
}

这里假设Reverb的name没有使用

其他示例1

int guitarCount = 0;
for (Guitar _ : guitars) {
    if (guitarCount < LIMIT) { 
        guitarCount++;
    }
}

其他示例2

var lesPaul = new Guitar("Les Paul");
try { 
    cart.add(stock.get(lesPaul, guitarCount));
} catch (OutOfStockException _) { 
    System.out.println("Sorry, out of stock!");
}

JEP 457: 类文件 API（预览版）

JEP 457: Class-File API (Preview)

JEP 457 提供了一个用于解析、生成和转换 Java 类文件的标准 API。此 API 处于预览状态。Java 生态系统有许多用于解析和生成 Java 类文件的库：ASM、BCEL、Javassist等大多数字节码生成框架都使用它们。Java类格式每6个月演化一次，每个新的Java版本都会发布，因此生成框架必须同时演进，否则可能会不支持最新的语言演进。JDK 本身使用ASM来实现它的一些工具，以及lambda实现，这在需要生成类文件的部分中，一个Java版本的功能与JVM中可以使用的功能之间存在差异，因为您必须等待支持版本 N 的新功能的 ASM 版本，然后才能在版本N+1中使用它们。类文件API通过在JDK中提供用于解析、生成和转换类文件的API来克服这个问题。

比如要生成如下方法

void fooBar(boolean z, int x) {
    if (z)
        foo(x);
    else
        bar(x);
}

用ASM的示例:

ClassWriter classWriter = ...;
MethodVisitor mv = classWriter.visitMethod(0, "fooBar", "(ZI)V", null, null);
mv.visitCode();
mv.visitVarInsn(ILOAD, 1);
Label label1 = new Label();
mv.visitJumpInsn(IFEQ, label1);
mv.visitVarInsn(ALOAD, 0);
mv.visitVarInsn(ILOAD, 2);
mv.visitMethodInsn(INVOKEVIRTUAL, "Foo", "foo", "(I)V", false);
Label label2 = new Label();
mv.visitJumpInsn(GOTO, label2);
mv.visitLabel(label1);
mv.visitVarInsn(ALOAD, 0);
mv.visitVarInsn(ILOAD, 2);
mv.visitMethodInsn(INVOKEVIRTUAL, "Foo", "bar", "(I)V", false);
mv.visitLabel(label2);
mv.visitInsn(RETURN);
mv.visitEnd();

使用此特性的示例:

ClassBuilder classBuilder = ...;
classBuilder.withMethod("fooBar", MethodTypeDesc.of(CD_void, CD_boolean, CD_int), flags,
                        methodBuilder -> methodBuilder.withCode(codeBuilder -> {
    Label label1 = codeBuilder.newLabel();
    Label label2 = codeBuilder.newLabel();
    codeBuilder.iload(1)
        .ifeq(label1)
        .aload(0)
        .iload(2)
        .invokevirtual(ClassDesc.of("Foo"), "foo", MethodTypeDesc.of(CD_void, CD_int))
        .goto_(label2)
        .labelBinding(label1)
        .aload(0)
        .iload(2)
        .invokevirtual(ClassDesc.of("Foo"), "bar", MethodTypeDesc.of(CD_void, CD_int))
        .labelBinding(label2);
        .return_();
});

JEP 458: 启动多文件源码程序

JEP 458: Launch Multi-File Source-Code Programs

JDK11的JEP 330: Launch Single-File Source-Code Programs引入了直接运行单个源文件的能力，一个缺点是所有源代码都必须放在一个文件中。要处理多个文件，仍然需要单独的编译步骤，这迫使开发人员在其项目中使用构建工具。如果开发人员仍然是初学者，那么情况可能会更糟：他们必须暂停对语言的学习，并且必须优先考虑学习或构建 Maven 或 Gradle 等工具。

Java22引入了一个启动器，它支持运行由多个文件组成的程序。假设一个目录包含两个文件Prog.java及Helper.java，其中每个文件声明一个类

// Prog.java
class Prog {
    public static void main(String[] args) { Helper.run(); }
}

// Helper.java
class Helper {
    static void run() { System.out.println("Hello!"); }
}

运行java Prog.java会在内存编译Prog并执行其main方法，这里Prog引用了Helper类，则启动器会在文件系统查找Helper.java文件然后内存编译。

如果是引用了jar包的类，则可以通过--class-path lib/*来指定，比如

Prog1.java
Prog2.java
Helper.java
libs/
├─ library1.jar
├─ library2.jar

可以通过如下来启动

$ java --class-path 'lib/*' Prog1.java
$ java --class-path 'lib/*' Prog2.java

如果libs里头的是模块化的，则可以使用如下方式启动

$ java -p lib Prog1.java
$ java -p lib Prog2.java

JEP 459: 字符串模板（第二轮预览）

JEP 459: String Templates (Second Preview)

JDK21的JEP 430: String Templates (Preview)引入了String Templates
JDK22作为第二次preview

使用示例

String title = "My Online Guitar Store";
String text = "Buy your next Les Paul here!";
String html = STR."""
        <html>
          <head>
            <title>\{title}</title>
          </head>
          <body>
            <p>\{text}</p>
          </body>
        </html>
        """;

JEP 460: 向量 API（第七轮孵化）

JEP 460: Vector API (Seventh Incubator)

JDK16引入了JEP 338: Vector API (Incubator)提供了jdk.incubator.vector来用于矢量计算
JDK17进行改进并作为第二轮的incubatorJEP 414: Vector API (Second Incubator)
JDK18的JEP 417: Vector API (Third Incubator)进行改进并作为第三轮的incubator
JDK19的JEP 426:Vector API (Fourth Incubator)作为第四轮的incubator
JDK20的JEP 438: Vector API (Fifth Incubator)作为第五轮的incubator
JDK21的JEP 448: Vector API (Sixth Incubator)作为第六轮的incubator
JDK22则作为第七轮的incubator，使用示例如下

void scalarComputation(float[] a, float[] b, float[] c) {
   for (int i = 0; i < a.length; i++) {
        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;
   }
}

static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;

void vectorComputation(float[] a, float[] b, float[] c) {
    int i = 0;
    int upperBound = SPECIES.loopBound(a.length);
    for (; i < upperBound; i += SPECIES.length()) {
        // FloatVector va, vb, vc;
        var va = FloatVector.fromArray(SPECIES, a, i);
        var vb = FloatVector.fromArray(SPECIES, b, i);
        var vc = va.mul(va)
                   .add(vb.mul(vb))
                   .neg();
        vc.intoArray(c, i);
    }
    for (; i < a.length; i++) {
        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;
    }
}

JEP 461: 流聚合器（预览版）

JEP 461: Stream Gatherers (Preview)

JDK22针对stream引入了gather操作，允许用户自定义中间操作，比如自定义distinctBy操作

guitars.stream()
        .gather(distinctBy(Guitar::guitarStyle))
        .forEach(System.out::println);

static <T, A> Gatherer<T, ?, T> distinctBy(Function<? super T, ? extends A> classifier) {
    Supplier<Map<A, List<T>>> initializer = HashMap::new;
    Gatherer.Integrator<Map<A, List<T>>, T, T> integrator = (state, element, _) -> {
        state.computeIfAbsent(classifier.apply(element), _ -> new ArrayList<>()).add(element);
        return true; // true, because more elements need to be consumed
    };
    BiConsumer<Map<A, List<T>>, Gatherer.Downstream<? super T>> finisher = (state, downstream) -> {
        state.forEach((_, value) -> downstream.push(value.getLast()));
    };
    return Gatherer.ofSequential(initializer, integrator, finisher);
}

这里展示了使用gather的几个func：initializer(可选，用于维护状态)、integrator(用于集成输入)、combiner(可选，用于组合并行流)、finisher(可选，当stream没有输入的时候执行)

java.util.stream.Gatherers内置了如下几个操作：fold、mapConcurrent、scan、windowFixed、windowSliding

JEP 462: 结构化并发（第二轮预览）

JEP 462: Structured Concurrency (Second Preview)

JDK19的JEP 428: Structured Concurrency (Incubator)作为第一次incubator
JDK20的JEP 437: Structured Concurrency (Second Incubator)作为第二次incubator
JDK21的JEP 453: Structured Concurrency (Preview)作为首次preview
JDK22作为第二次preview，使用示例如下

Response handle() throws ExecutionException, InterruptedException {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        Supplier<String>  user  = scope.fork(() -> findUser());
        Supplier<Integer> order = scope.fork(() -> fetchOrder());

        scope.join()            // Join both subtasks
             .throwIfFailed();  // ... and propagate errors

        // Here, both subtasks have succeeded, so compose their results
        return new Response(user.get(), order.get());
    }
}

JEP 463: 隐式声明类和实例主方法（第二轮预览）

JEP 463: Implicitly Declared Classes and Instance Main Methods (Second Preview)

JDK21的JEP 445: Unnamed Classes and Instance Main Methods (Preview)作为首次preview，引入了未命名的类和实例main方法特性可以简化hello world示例，方便java新手入门
JDK22作为第二次preview，它支持了更为灵活的程序启动协议，比如允许启动类的方法有public、protected权限，如果启动类包含参数方法则会选择有参数的，否则选择无参的main方法。

示例如下

        static void main(String[] args) {
            System.out.println("static main with args");
        }

        static void main() {
            System.out.println("static main without args");
        }

        void main(String[] args) {
            System.out.println("main with args");
        }

        void main() {
            System.out.println("main with without args");
        }

javac --release 21 --enable-preview Main.javajava --enable-preview Main
其中main方法选择的优先顺序是static的优于非static的，然后有args的优于没有args的

JEP 464: 作用域值（第二轮预览）

JEP 464: Scoped Values (Second Preview)

JDK20的JEP 429: Scoped Values (Incubator)作为Incubator
JDK21的JEP 446: Scoped Values (Preview)作为preview版本
JDK22作为第二次preview，具体使用如下：

class Server {
  public final static ScopedValue<User> LOGGED_IN_USER = ScopedValue.newInstance();
 
  private void serve(Request request) {
    // ...
    User loggedInUser = authenticateUser(request);
    ScopedValue.where(LOGGED_IN_USER, loggedInUser)
               .run(() -> restAdapter.processRequest(request));
    // ...
  }
}

通过ScopedValue.where可以绑定ScopedValue的值，然后在run方法里可以使用，方法执行完毕自行释放，可以被垃圾收集器回收

小结

这次更新的 12 项新特性里，有六个是归在核心 Java 库下面的：

  • JEP 454：外部函数和内存 API，让你能更轻松地调用外部函数和管理内存；
  • JEP 457：类文件 API（预览版），让你能更方便地处理类文件；
  • JEP 460：向量 API（第七轮孵化），让你的向量运算更加高效；
  • JEP 461：流聚合器（预览版），让你的流处理更加灵活；
  • JEP 462：结构化并发（第二轮预览），让你的并发编程更加有序；
  • JEP 464：作用域值（第二轮预览），让你的变量作用域更加清晰。

还有四个新特性是归在 Java 语言规范下面的：

  • JEP 447：super(…) 前导语句（预览版），让你在调用父类构造方法之前能执行其他语句；
  • JEP 456：未命名变量和模式，让你的代码更加简洁易读；
  • JEP 459：字符串模板（第二轮预览），让你的字符串拼接更加优雅；
  • JEP 463：隐式声明类和实例主方法（第二轮预览），让你的类和实例方法声明更加简洁。

另外，还有一个新特性是归在 HotSpot 下面的：

  • JEP 423：G1 的区域锚定，让你的垃圾回收更加高效。

最后，还有一个新特性是归在 Java 工具下面的：

  • JEP 458：启动多文件源码程序，让你能更加方便地运行多个源文件的程序。

这些新特性都被归类到了四个主要的 Java 项目里：Amber、Loom、Panama 和 Valhalla。这四个项目可是 Oracle 的亲儿子，专门负责孵化一系列组件，最后整合到 JDK 里去的。

悬浮海
关注
  • 12
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java 22 发布，新特性一览
成富的专栏
03-26 1392
Java 22 发布于 2024 年 3 月 19 号。目前已经可以下载到不同供应商的构建版本了。推荐使用 Eclipse Temurin 的版本。这个最新的 Java 版本有哪些新东西呢？我们来看一下。首先介绍 Java 22 全新的功能。第一个是Class File API。这是解析、生成和转换 Java 类文件的标准 API。目前在处理 Java 的字节码时，必须用到第三方库，比如 ASM...
Java 17 新特性
DevCampsite的博客
10-04 1189
Java 17 新特性
从Java8到Java22重点特性梳理
果子爸聊技术
05-02 1106
从Java8到Java22新特性梳理
Java 22 正式发布，一文了解全部新特性
最新发布
芋艿V
06-04 87
???? 这是一个或许对你有用的社群???? 一对一交流/面试小册/简历优化/求职解惑，欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料：《项目实战（视频）》：从书中学，往事上“练”《互联网高频面试题》：面朝简历学习，春暖花开《架构 x 系统设计》：摧枯拉朽，掌控面试高频场景题《精进 Java 学习指南》：系统学习，互联网主流技术栈《必读 Java 源码专栏》：知其然，知其所以然????这是一个或许...
JDK22发布了！来看看有哪些新特性
威哥爱编程，一个坚持研究技术的80后老鸟，擅长后端、AI 大模型、鸿蒙等技术体系，愿与你在技术路上一起成长！
03-25 3320
由于 JEP 423 主要是关于垃圾回收器的内部工作机制，它并不直接提供新的API或者对开发者可见的行为改变，因此没有直接的示例代码。JEP 463 的目标是提供一个平滑的学习曲线，使得学生和新程序员能够以简洁的方式编写基本程序，并随着他们技能的提升，逐步扩展到使用 Java 的更高级特性。2024年3月19日，Oracle 官网正式发布了 JDK22，虽然这是一个非 LTS（长期支持）版本，但 JDK22也带来了一些引人注目的新特性，V哥详细阅读了官网文档，把相关新特性总结出来，分享给大家，一睹为快。
jdk—新特性
m0_73746654的博客
02-21 364
S.22--新特性 PART2+注解 本章内容 Stream流 注解 1 Stream流 1.1 概念 Stream是jdk8增加的一个接口，该接口提供了一些对容器(单列集合,双列集合,数组)数据进行操作的规则， 有了这些规则(Stream接口中的方法)就可以不通过遍历容器就可以完成对相关数据的操作处理。 特点：不能存放任何的数据，只有对数据的操作的能力,不会修改原来容器中的数据. 当需要对多个元素所在的容器进行操作（特别是多步操作）的时候，考虑到性能及便利性，我们应该首先拼好 一个“模型”步骤方案，然后
Java22已发布，支持SpringBoot3.3.0正式版
yuanjinshenglife的专栏
03-24 2278
Java22已发布，支持SpringBoot3.3.0正式版
JDK 21 和 JDK 22：到目前为止我们所知道的
xuejianxinokok的专栏
09-06 3836
在 JDK 17 中提供。，其中他与使用旧的 Java 本机接口 (JNI) 调用相比，为 JDK 21 (JEP 442) 和 JDK 22 (JEP Draft 8310626) 提供了使用此 API 进行字符串转换的基准。，一种功能 JEP 类型，建议定义一个高效的 API，用于获取异步调用跟踪，以便从带有 Java 和本机帧信息的信号处理程序进行分析。，在 Valhalla 项目的支持下，引入了开发人员声明的原始类 - 由值对象 API 定义的特殊类型的值类 - 即定义新的原始类型。
Java22的新特性
go4it
03-25 889
Java语言特性系列。
Java 11 新特性
DevCampsite的博客
09-27 6048
Java 11 新特性
Day22 IO流及Java8新特性.md
08-09
缓冲流：对于频繁操作的的文件一般使用缓冲流 Lambda:lambda表达式的写法 相当于匿名内部类的简写： 语法结构：(参数)->{功能语句}; Stream: 操作对象需要调用stream()或者是parallelStream()方法转换为流在进行方法...
day22_JDK8新特性.pdf
11-02
总的来说，JDK8的这些新特性显著改善了Java的开发体验，使得Java在现代软件开发中保持了竞争力。Lambda表达式的引入让Java具备了函数式编程的能力，Stream API则提供了高效的集合处理方式，这些都极大地提升了开发者...
2018最新 Java9新特性详解视频
03-30
22.新特性14：Deprecated的相关API 23.新特性15：智能java编译工具 24.新特性16：统一的JVM日志系统 25.新特性17：javadoc的HTML5支持 26.新特性18：Javascript的Nashorn引擎升级 27.新特性19：java的动态编译器 28....
Java并发编程（22）并发新特性-障碍器CyclicBa
11-22
这个特性在多线程协作处理任务时尤其有用，比如分布式计算、多阶段处理流程等场景。在Java 5中引入的CyclicBarrier，它的名字"Barier"意味着障碍，而"Cyclic"则表示可以重用，即当所有等待的线程都到达屏障点后，...
Java22重磅发布！！！！卷不动了，真的卷不动了。。。。
dsgdauigfs的博客
03-22 1624
就在3月19日，Java22重磅发布。Java22新增了12项增强功能，其中包括七个预览特性和一个孵化器特性，这些功能都显著到足以引起JDK增强提案（JEPs）的关注。它们涵盖了Java语言、其API、性能以及JDK中包含的工具的改进。真的卷不动了，，前段时间才将项目升级到Java17。。。。接下来我们看看具体的新特性介绍。。。
Java基础（22）之集合进阶
笑笑不说话
03-05 321
1. Collection 1.1 集合基础知识回顾 1.2 集合类体系结构 集合存储数据的方式有单列和双列 Clooection中还有List（可以存储可重复的数据）和Set（可以存储不可重复的数据）。 有重复的数存储到Set中，重复的数据就会被合一，变成一个。 List，Set和Map接口中还有实现类 下面是几个主要使用的实现类 1.3 Clooection集合概述和使用 代...
JAVA22 FFM实战之HelloWorld
weixin_43328357的博客
03-15 1445
本文以curl和lua为例，提前研究jdk22的ffm api使用方式
【Java 22 新特性】构造器 super(...) 之前可以添加语句
成富的专栏
02-21 765
在学习 Java 的时候，我们都会记得一条 Java 的语法规则，与 Java 的 类继承和构造器有关。在继承一个类的时候，子类的构造器必须要使用super(...)来调用父类的构造器。这个super(...)语句必须是子类构造器方法的第一条语句。如果super(...)不是第一条语句，就会出现编译错误。这一条规则对于调用同一个类的构造器也是适用的，也就是调用this(...)的...
java jdk 1.5_22 64
07-30
Java JDK 1.5_22 64是指Java Development Kit（JDK）的一个版本。JDK是Java软件开发工具包，提供了开发和运行Java应用程序所需的工具和库。1.5_22是JDK的版本号，表示JDK的主要版本为1.5，修订版本号为22。64表示该版本为64位的操作系统。 Java JDK 1.5_22 64具有许多特性和功能。它包括Java编译器（javac）和Java虚拟机（JVM），以及其他工具和库。开发人员可以使用JDK开发Java应用程序，编译Java源代码并生成可执行文件，然后在JVM上运行这些文件。 1.5_22版本是Java 1.5的修订版本22。Java 1.5（也称为Java 5或J2SE 5.0）是Java平台的一个重要更新版本。它引入了许多新特性，如泛型、枚举、自动装箱和拆箱、增强的for循环等，这些特性使得Java语言更强大和易用。 64表示该版本适用于64位操作系统。与32位操作系统相比，64位操作系统能够更好地支持大型内存和处理器。使用64位的JDK可以充分利用64位操作系统的优势，提供更高的性能和可扩展性。 总之，Java JDK 1.5_22 64是一个具有许多特性和功能的Java开发工具包版本，适用于64位操作系统。它能够支持Java开发人员开发和运行Java应用程序，并提供了许多新的特性和优势。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

悬浮海

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值