标签 java 下的文章

2024-08-12

在JavaScript中，事件流描述的是从页面接收事件的顺序。事件流被分为两种：“捕获”和“冒泡”。

捕获阶段：事件从最外层开始，逐层向内传播，直至目标元素。
目标阶段：事件在目标元素上触发。
冒泡阶段：事件从目标元素开始，向外逐层传播，最终到达最外层。

在DOM2级事件规范中，可以使用addEventListener函数来指定事件处理程序，第三个参数如果为true则表示在捕获阶段处理事件，如果为false则表示在冒泡阶段处理事件。

例子代码：




// 获取元素
var parent = document.getElementById('parent');
var child = document.getElementById('child');
 
// 添加事件监听器
parent.addEventListener('click', function() {
    console.log('父元素捕获阶段');
}, true);
 
child.addEventListener('click', function(e) {
    console.log('子元素目标阶段');
    e.stopPropagation(); // 阻止冒泡
}, true);
 
parent.addEventListener('click', function() {
    console.log('父元素冒泡阶段');
}, false);

在上述代码中，点击child元素时，会先打印“父元素捕获阶段”，然后打印“子元素目标阶段”，通过调用e.stopPropagation()阻止事件继续冒泡。最后在冒泡回到parent时，打印“父元素冒泡阶段”。

- 阅读更多 -

【Java 基础篇】Java HashSet 集合详解：高效存储唯一元素的利器

System

2024-08-12

所有,java




import java.util.HashSet;
import java.util.Set;
 
public class HashSetExample {
    public static void main(String[] args) {
        // 创建HashSet实例
        Set<String> uniqueElements = new HashSet<>();
 
        // 添加元素
        uniqueElements.add("Element1");
        uniqueElements.add("Element2");
        uniqueElements.add("Element3");
        uniqueElements.add("Element2"); // 重复元素不会添加
 
        // 遍历HashSet
        for (String element : uniqueElements) {
            System.out.println(element);
        }
 
        // 检查元素是否存在
        System.out.println("Element2 is in the set: " + uniqueElements.contains("Element2"));
 
        // 删除元素
        uniqueElements.remove("Element1");
 
        // 清空HashSet
        // uniqueElements.clear();
 
        // 获取HashSet大小
        System.out.println("Size of the set: " + uniqueElements.size());
    }
}

这段代码展示了如何创建和使用HashSet集合，它是一个不允许有重复元素的集合。代码中包含了添加元素、遍历元素、检查元素存在性、删除元素以及获取集合大小的基本操作。

- 阅读更多 -

C#结合JavaScript实现多文件上传

System

2024-08-12

所有,java

在C#中结合JavaScript实现多文件上传，通常涉及到前端的HTML和JavaScript代码以及后端的C#代码。以下是一个简单的示例：

前端HTML和JavaScript代码:




<form id="uploadForm" enctype="multipart/form-data">
    <input type="file" id="fileUpload" multiple />
    <input type="button" value="Upload" onclick="uploadFiles()" />
</form>
 
<script>
function uploadFiles() {
    var files = document.getElementById('fileUpload').files;
    var formData = new FormData();
 
    for (var i = 0; i < files.length; i++) {
        formData.append("file" + i, files[i]);
    }
 
    var xhr = new XMLHttpRequest();
    xhr.open("POST", "/upload", true);
    xhr.onload = function () {
        if (this.status == 200) {
            alert(this.responseText);
        }
    };
    xhr.send(formData);
}
</script>

后端C#代码:




using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.IO;
using System.Threading.Tasks;
 
[Route("[controller]")]
[ApiController]
public class UploadController : ControllerBase
{
    [HttpPost("upload")]
    public async Task<IActionResult> Upload(List<IFormFile> files)
    {
        var uploadsDir = Path.Combine(_env.WebRootPath, "uploads");
 
        foreach (var file in files)
        {
            if (file.Length > 0)
            {
                var filePath = Path.Combine(uploadsDir, file.FileName);
                using (var stream = new FileStream(filePath, FileMode.Create))
                {
                    await file.CopyToAsync(stream);
                }
            }
        }
 
        return Ok("Files uploaded successfully.");
    }
}

在这个示例中，前端JavaScript使用FormData来收集文件，然后通过XMLHttpRequest发送到后端的C# ASP.NET Core控制器。控制器中的Upload方法接收多个上传的文件，并将它们保存到服务器的uploads文件夹中。

确保你的ASP.NET Core项目配置了正确的路由和CORS策略，以允许从前端发起的跨域请求。

- 阅读更多 -

【Java】Java中的多态

System

2024-08-12

所有,java

多态是面向对象编程中的一个核心概念，允许一个接口表示多种形态。在Java中，多态的表现形式通常有以下几种：

方法重载（Overloading）：在同一个类中，多个同名方法拥有不同的参数列表，即通过参数类型和/或参数数量的不同来区分。




public class Example {
    public void method(int a) {
        System.out.println("方法接收一个整型参数");
    }
 
    public void method(String b) {
        System.out.println("方法接收一个字符串参数");
    }
}

方法覆盖（Overriding）：子类继承父类并重写父类中已经定义的方法，以实现不同的行为。




public class Parent {
    public void method() {
        System.out.println("父类方法");
    }
}
 
public class Child extends Parent {
    @Override
    public void method() {
        System.out.println("子类覆盖方法");
    }
}

对象向上转型（Upcasting）：将子类对象赋给父类引用，可以在不改变任何代码的前提下增加子类。




public class Parent {
    public void method() {
        System.out.println("父类方法");
    }
}
 
public class Child extends Parent {
    @Override
    public void method() {
        System.out.println("子类覆盖方法");
    }
}
 
public class Main {
    public static void main(String[] args) {
        Parent parent = new Child(); // 向上转型
        parent.method(); // 调用子类的方法
    }
}

在上述例子中，我们定义了一个父类Parent和一个继承自Parent的子类Child。在Main类的main方法中，我们创建了一个Child类的实例，并将其向上转型为Parent类型，然后调用method方法，实现了不同的行为。这就是多态的一个典型应用。

- 阅读更多 -

【Java基础系列】JDK21新特性

System

2024-08-12

所有,java

JDK 21目前还未正式发布，但根据Java社区的动态，预计在2023年3月会发布。JDK 21预计的新特性包括：

模式匹配（Pattern Matching）: 增强的switch表达式和语句。
文本块（Text Blocks）: 提供一种更简洁的方式来写多行字符串。
密封类型（Sealed Types）: 限制哪些类可以扩展或实现其他类或接口。
指定时间点的JVM启动（Specified JVM Launch Time）: 通过JVM选项来控制启动时间。
Vector API（VTA）: 为向量计算提供一套API。
外部存储器访问 API（External Storage Access API）: 提供对外部存储器（如固态硬盘）的编程访问。

以上特性可能会在JDK 21中正式推出，但具体的发布计划和特性可能会随着时间推移而变化。请查看官方文档或后续更新以获取最新信息。

System

2024-08-12

所有,java

java.lang.NoClassDefFoundError: org/springframework/aot/AotDetector 这个错误表明 JVM 在运行时尝试加载 org/springframework/aot/AotDetector 类，但没有找到这个类。这通常是因为该类所在的 JAR 文件在编译时存在于类路径中，但在运行时没有被找到。

解决方法：

确认你的项目是否应该使用 Spring AOT 特性，如果应该，确保你的项目依赖中包含了正确版本的 Spring 框架 JAR 文件，该文件中含有缺失的类。
如果你正在使用构建工具（如 Maven 或 Gradle），检查 pom.xml 或 build.gradle 文件中是否正确地声明了 Spring 相关依赖，并且没有任何排除规则导致了依赖缺失。
确保所有需要的 JAR 文件都已经下载并且没有损坏。有时候，下载不完整或者网络问题可能导致 JAR 文件损坏。
如果你正在使用 IDE（如 IntelliJ IDEA 或 Eclipse），确保项目的类路径设置正确，包括所有需要的库。
如果你是从一个构建的存档（如 WAR 或 JAR）直接运行应用程序，确保所有必要的 JAR 文件都包含在这个存档中，并且在运行时类路径被正确设置。
如果你是使用的是应用服务器，确保 Spring 相关的 JAR 文件被放置在正确的位置，例如 WEB-INF/lib 目录下。
如果你已经确认所有依赖都是最新的，且类路径也没有问题，可以尝试清理并重新构建项目。

总结，解决这个问题的关键是确保所有必要的 Spring 框架依赖都已正确添加到项目中，并且在运行时可以被类加载器找到。

System

2024-08-12

所有,java

javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException 异常通常表示在 SSL 握手阶段发生了问题，导致无法建立安全连接。这个问题可能是由于多种原因造成的，比如证书不被信任、证书已经过期、SSL 协议不兼容等。

解决方法：

检查服务器的 SSL 证书是否有效，未过期，并且由受信任的证书颁发机构签发。
确认客户端的信任库（truststore）包含了服务器证书的颁发机构的根证书。
如果证书是自签名的，确保导入到客户端信任库中。
确保客户端和服务器支持的 SSL/TLS 协议版本和加密套件是兼容的。
如果使用了特定的 SSL/TLS 配置，确保客户端和服务器的配置一致。

如果你需要更具体的解决方案，请提供详细的异常堆栈跟踪信息，这样可以提供更针对性的解决方案。

- 阅读更多 -

Java基础从入门到起飞目录合集

System

2024-08-12

所有,java

由于问题中提到的“Java基础从入门到起飞”是一个很广泛的主题，我将提供一个包含了基础知识和高级特性的Java技术目录合集。这个目录涵盖了Java开发的基础语法、面向对象编程、集合框架、异常处理、I/O操作、多线程、网络编程、JUnit测试等主题。

Java 基础语法
- 注释
- 标识符和关键字
- 数据类型
- 变量和常量
- 运算符
- 流程控制语句
- 方法
- 类和对象
- 封装和继承
- 多态
- 内部类
Java 高级特性
- 异常处理
- 泛型
- 反射
- 注解
- 多线程
- NIO 和 IO
- 网络编程
- JDBC
- Servlets
- JSP
- Spring 框架
- Hibernate
- Maven
- Git
Java 集合框架
- List
- Set
- Map
- Queue
- Iterator
- Comparable & Comparator
Java 8 新特性
- Lambda 表达式
- Stream API
- Date and Time API
- Optional Class
- Default Methods for Interfaces
Java 9 新特性
- JShell
- Private Interface Methods
- Improve Javadoc
- Variable Handles
- More Concurrency Updates
Java 11 新特性
- Lambda Parameter Type Inference
- Linking
- HTTP Client (Preview)
- Unicode 10
- TLS 1.3 Support
Java 17 新特性
- Sealed Classes (Preview)
- Pattern Matching for instanceof (Second Preview)
- EdDSA Signature Algorithms
- Remove the Java EE and CORBA Modules
- ZGC: A Scalable Low-Latency Garbage Collector

这个目录涵盖了Java开发的基础和高级特性，同时也包含了最新版本的一些重要更新。这样，开发者们可以从入门到起飞，形成一个连贯的知识框架。

- 阅读更多 -

Java Jar 包还不知道怎么反编译，赶紧看看这个 IDEA 插件！

System

2024-08-12

所有,java

Jar 包反编译是一个常见的需求，尤其在开发阶段或者维护阶段，我们可能需要查看 Jar 包中的源代码。在 Java 中，有多种反编译工具，例如 JD-GUI、JAD 等。但如果你正在使用 IntelliJ IDEA 作为你的开发环境，那么你可以直接使用 IDEA 自带的插件来进行 Jar 包的反编译。

以下是如何在 IntelliJ IDEA 中安装和使用 Jar 包反编译插件的步骤：

打开 IntelliJ IDEA，选择 "File" -> "Settings" -> "Plugins"。
在 "Plugins" 页面中，点击 "Browse repositories..." 按钮，搜索 "Java Bytecode Decompiler" 插件并安装。
安装完成后，重启 IntelliJ IDEA。
打开你想要反编译的 Jar 包，在 "Project" 视图中右键点击 Jar 包，选择 "Show in Explorer"。
在文件资源管理器中，双击 Jar 包以打开它，你会看到插件已经将 Jar 包的内容反编译为 Java 源代码。

注意：这个插件不能修改 Jar 包中的内容，它只是让你能查看源代码而已。如果你需要修改 Jar 包中的代码，你需要使用专业的反编译工具，并且有可能会遇到困难，因为这些工具可能不是为了修改而设计的。

- 阅读更多 -

【JVM基础篇】Java的四种垃圾回收算法介绍

System

2024-08-12

所有,java

Java的四种常见垃圾收集算法分别是：

标记-清除（Mark-Sweep）
标记-压缩（Mark-Compact）
收集（Copying）
分代（Generational）

解释和示例代码：

标记-清除（Mark-Sweep）：这是垃圾收集算法中最基本的一个算法，分为“标记”和“清除”两个阶段。首先先标记出所有需要回收的对象，然后进行清除回收。




public void markSweep() {
    // 标记
    mark();
    // 清除
    sweep();
}
 
private void mark() {
    // 标记过程，比如可以设置对象头的某一位来表示对象是否被标记
}
 
private void sweep() {
    // 清除被标记的对象
}

标记-压缩（Mark-Compact）：在标记-清除的基础上，增加了一个压缩的过程，即清除后进行对象空间的压缩整理。




public void markCompact() {
    // 标记
    mark();
    // 压缩
    compact();
}
 
private void compact() {
    // 移动所有存活的对象，使得对象空间连续
}

收集（Copying）：将可用的内存空间分为两块，每次只使用其中一块，当这一块用完了，就将存活的对象复制到另一块上，然后把已使用的内存空间清理掉。




public void copying() {
    // 假设有两块空间 from 和 to
    AddressSpace from = getFromSpace();
    AddressSpace to = getToSpace();
    // 复制存活对象
    for (Address a : from) {
        if (a.getObject() != null) {
            to.copyFrom(a);
        }
    }
    // 交换两块空间的角色，完成收集
    swap(from, to);
}

分代（Generational）：基于对象生命周期的不同将内存划分为几个区域，分别采用最适合其特点的收集算法。比如新生代可以采用复制算法，而老年代可以采用标记-压缩或标记-清除算法。




public void generational() {
    // 新生代使用复制算法
    newGeneration.copying();
    // 老年代使用标记-压缩或标记-清除
    oldGeneration.markCompact();
}

以上代码仅为示例，实际的垃圾收集器实现会更复杂，包含更多细节处理。

- 阅读更多 -