分类 java 下的文章

2024-08-09

在Windows上安装多个JDK并实现自由切换的方法如下：

下载多个JDK版本的安装包，并按顺序安装到不同路径。
设置环境变量。在系统的环境变量中，可以为每个JDK版本设置不同的JAVA_HOME变量和更新Path变量。

例如，安装了JDK 8和JDK 11后：

JDK 8:
- JAVA\_HOME: C:\Program Files\Java\jdk1.8.0_202
- Path: 添加 %JAVA_HOME%\bin
JDK 11:
- JAVA\_HOME: C:\Program Files\Java\jdk-11.0.2
- Path: 添加 %JAVA_HOME%\bin

通过直接修改系统的环境变量可以实现JDK的切换。要切换到JDK 8，只需将JAVA\_HOME环境变量改为C:\Program Files\Java\jdk1.8.0_202，并重启命令行窗口或编辑器。

注意：确保Path变量中只包含当前JDK版本的bin目录。

这样，你可以根据需要通过修改JAVA\_HOME来自由切换不同版本的JDK。

[C++] 多态 -- 多态原理 -- 动静态绑定

2024-08-08

在C++中，多态性是通过虚函数实现的，虚函数允许在派生类中被重写（override）。当基类指针或引用指向派生类对象时，调用虚函数会根据实际指向的对象类型执行相应的函数版本。

动态绑定（Dynamic Binding）：在运行时确定函数调用的对象类型，并调用相应版本的虚函数。

静态绑定（Static Binding）：在编译时确定函数调用的版本，基于指针或引用的类型。




class Base {
public:
    virtual void display() {
        std::cout << "Base display" << std::endl;
    }
};
 
class Derived : public Base {
public:
    void display() override {
        std::cout << "Derived display" << std::endl;
    }
};
 
int main() {
    Base* ptr = new Derived(); // 基类指针指向派生类对象
    ptr->display(); // 动态绑定，输出 "Derived display"
 
    Base& ref = *ptr; // 基类引用引用基类对象
    ref.display(); // 静态绑定，输出 "Base display"
 
    delete ptr;
    return 0;
}

在上述代码中，ptr->display() 使用了动态绑定，因为 ptr 指向的是 Derived 类型的对象，所以调用的是 Derived 类中的 display 函数。而 ref.display() 使用了静态绑定，因为 ref 是基类引用，它引用的是基类对象，所以调用的是 Base 类中的 display 函数。

CGLIB与JDK代理的终极对决！

2024-08-08

CGLIB和JDK动态代理是Java中实现AOP的两种常见方式。CGLIB是通过继承的方式生成代理类，而JDK动态代理则是通过实现接口的方式进行代理。

在某些情况下，你可能需要选择使用哪种代理方式。例如，如果你要代理的类是一个抽象类，那么你无法使用JDK动态代理，因为JDK动态代理不能用来代理抽象类。在这种情况下，CGLIB是一个很好的选择，因为它可以代理抽象类和具体类。

另一方面，如果你要代理的类实现了一个接口，那么你可以选择JDK动态代理，因为它是基于接口的。在这种情况下，CGLIB不是一个合适的选择，因为CGLIB需要代理的类不能是最终类。

综上所述，选择CGLIB还是JDK动态代理取决于你要代理的类的特性。在大多数情况下，如果类实现了接口，你应该优先选择JDK动态代理，因为它是标准的方式，而且性能更好。只有在无法实现接口的情况下（例如代理抽象类或者无法访问源码的类），你才会考虑使用CGLIB。

【Java学习】-Java JDK 1.8与17版本比较

2024-08-08

JDK 1.8 和 JDK 17 是 Java 语言的两个不同的版本。JDK 是 Java Development Kit 的缩写，它是用于开发 Java 应用程序的软件开发工具包。

JDK 1.8，也称为 Java 8，于2014年3月发布，引入了许多新特性，如 Lambda 表达式、流（Streams） API、日期时间 API (java.time package) 等。

JDK 17，也称为 Java 17，于2021年9月发布，是一个长期支持（LTS）版本，支持期至2026年9月。Java 17 包含了许多新特性和改进，例如：

模式匹配（Pattern Matching） for instanceof
文本块（Text Blocks）
密码执行器（crypto）
外部内存访问 API (Foreign-Memory Access API)
删除 RMI 活化和反活化的序列化

以下是一个简单的代码示例，展示了在 Java 8 和 Java 17 中使用 Lambda 表达式和流（Streams） API 对集合进行操作的不同。

Java 8:




List<String> items = Arrays.asList("apple", "banana", "cherry", "date");
 
// 使用 Lambda 表达式过滤集合
List<String> filteredItems = items.stream()
    .filter(item -> item.length() > 3)
    .collect(Collectors.toList());
 
filteredItems.forEach(System.out::println);

Java 17:




List<String> items = List.of("apple", "banana", "cherry", "date"); // Java 17 提供了更简洁的List创建方式
 
// 使用 Lambda 表达式过滤集合
List<String> filteredItems = items.stream()
    .filter(item -> item.length() > 3)
    .toList(); // Java 17 中的 Stream 增加了 toList() 方法，使得操作更加简洁
 
filteredItems.forEach(System.out::println);

在这两个示例中，我们都使用了 Lambda 表达式来过滤长度大于 3 的字符串，并将结果输出。在 Java 17 中，Stream API 进一步简化，去除了 collect 方法，并增加了 toList 等实用的新方法。

2024-08-08




import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
 
public class StreamApiCollectExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
 
        // 1. 将流中元素收集到List
        List<Integer> collectedToList = numbers.stream()
                .collect(Collectors.toList());
        System.out.println(collectedToList);
 
        // 2. 将流中元素收集到Set
        // 注意：Set会过滤重复元素
        List<Integer> collectedToSet = numbers.stream()
                .collect(Collectors.toSet());
        System.out.println(collectedToSet);
 
        // 3. 将流中元素收集到Map
        // 使用对象的某个属性作为key，其它属性或者对象本身作为value
        List<String> collectedToMap = Arrays.asList("Hello", "World", "Hello", "Java");
        Map<String, Long> wordCount = collectedToMap.stream()
                .collect(Collectors.toMap(
                        s -> s, // key为字符串本身
                        s -> (long) s.length(), // value为字符串长度
                        (s1, s2) -> s1 // 如果有重复的key，则选择第一个
                ));
        System.out.println(wordCount);
 
        // 4. 收集流中对象的属性到一个Collection
        List<Person> people = Arrays.asList(new Person("John", 30), new Person("Sarah", 25));
        List<String> names = people.stream()
                .map(Person::getName) // 获取每个Person的name
                .collect(Collectors.toList());
        System.out.println(names);
 
        // 5. 计算流中元素的统计信息
        IntSummaryStatistics stats = numbers.stream()
                .collect(Collectors.summarizingInt(Integer::intValue));
        System.out.println("最小值：" + stats.getMin());
        System.out.println("最大值：" + stats.getMax());
        System.out.println("平均值：" + stats.getAverage());
        System.out.println("总和：" + stats.getSum());
        System.out.println("个数：" + stats.getCount());

SpringBoot整合Mybatis+人大金仓（kingbase8）

2024-08-08

要在Spring Boot中整合MyBatis和人大金仓(kingbase8)，你需要按照以下步骤操作：

在pom.xml中添加依赖：




<!-- Spring Boot Starter -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>
 
<!-- MyBatis Starter -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.4</version>
</dependency>
 
<!-- 人大金仓数据库驱动 -->
<dependency>
    <groupId>com.kingbase8</groupId>
    <artifactId>kingbase8-jdbc</artifactId>
    <version>你的版本号</version>
</dependency>
 
<!-- 数据库连接池 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>你的版本号</version>
</dependency>

配置application.properties或application.yml文件：




# 数据库配置
spring.datasource.url=jdbc:kingbase8://localhost:54321/yourdb
spring.datasource.username=yourusername
spring.datasource.password=yourpassword
spring.datasource.driver-class-name=com.kingbase8.Driver
 
# MyBatis 配置
mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package=com.yourpackage.model

创建Mapper接口和XML文件：




// src/main/java/com/yourpackage/mapper/YourMapper.java
package com.yourpackage.mapper;
 
public interface YourMapper {
    // 定义你的数据库操作方法
}




<!-- src/main/resources/mapper/YourMapper.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yourpackage.mapper.YourMapper">
    <!-- 定义SQL映射 -->
</mapper>

配置MyBatis的Mapper扫描路径，在Spring Boot启动类或配置类中添加：




// src/main/java/com/yourpackage/YourApplication.java
package com.yourpackage;
 
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
@MapperScan("com.yourpackage.mapper")
public class YourApplication {
    public static void main(String[] args) {
        SpringApplication.run(YourApplication.class, args);
    }
}

确保数据库URL、用户名、密码等配置信息正确，并将com.yourpackage.mapper替

Ubuntu安装Java并且配置JAVA_HOME

2024-08-08

在Ubuntu上安装Java并配置JAVA_HOME环境变量可以通过以下步骤完成：

打开终端。
更新包列表：
```
sudo apt update
```
安装Java开发工具包（JDK），你可以安装默认的JDK或者Oracle JDK。默认JDK可以通过以下命令安装：
```
sudo apt install default-jdk
```
如果你需要安装Oracle JDK，可以从Oracle官网下载.tar.gz安装包，然后手动解压和配置。
安装完成后，确定java和javac命令可用：
```
java -version
javac -version
```
配置JAVA_HOME环境变量。编辑~/.bashrc或者~/.profile文件，在文件末尾添加以下行：
```
export JAVA_HOME=/usr/lib/jvm/default-java
export PATH=$JAVA_HOME/bin:$PATH
```
替换/usr/lib/jvm/default-java为你的JDK安装路径，如果你安装的是Oracle JDK，路径可能不同。
保存文件并执行以下命令来应用更改：
```
source ~/.bashrc
```
验证JAVA_HOME是否配置正确：
```
echo $JAVA_HOME
```

以上步骤会在Ubuntu系统上安装Java并配置JAVA_HOME环境变量。

2024-08-08

报错信息 "Name for argument of type [java.lang.String] not specified" 通常出现在使用Spring Boot 3.2.0版本时，尝试在Controller中使用一个方法参数，但没有为其指定名称。在Spring Boot中，如果你在Controller的一个请求映射方法中使用了一个参数，并且这个参数不是一个简单类型（比如int, long等），你需要为它提供一个名称，这样Spring框架就可以通过名称来从请求中获取对应的值。

例如，如果你有以下的Controller方法：




@GetMapping("/greet")
public String greet(@RequestParam String name) {
    return "Hello, " + name;
}

在这个例子中，参数name就需要一个名称，这里我们使用了@RequestParam注解来指定参数名称为name。

如果你没有提供参数名称，比如下面这样：




@GetMapping("/greet")
public String greet(@RequestParam String) {
    return "Hello, " + name;
}

你就会遇到 "Name for argument of type [java.lang.String] not specified" 的错误。

解决方法是在方法参数前使用@RequestParam注解并指定一个参数名称，如下所示：




@GetMapping("/greet")
public String greet(@RequestParam("name") String name) {
    return "Hello, " + name;
}

这样，Spring就可以通过参数名name来匹配HTTP请求中的参数值了。

【Java SE】如何解读Java的继承和多态的特性？

2024-08-08

在Java中，理解继承和多态的特性是非常重要的。

继承：

继承是面向对象编程中的一个核心特性，它允许我们定义一个新的类，它从另一个已经存在的类继承其属性和方法。被继承的类称为父类或超类，新的类称为子类。




public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}
 
public class Dog extends Animal {
    // Dog类继承了Animal类的eat方法
}
 
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 输出：Animal is eating
    }
}

多态：

多态是指在不同的类中定义了相同名称的方法，这个方法在这些类的实例中表现出不同的行为特征。多态的主要有两种形式：方法重载（Overloading）和方法覆盖（Overriding）。

方法重载：在同一个类中，允许存在多个同名方法，但这些方法的参数类型和/或参数数量不同。




public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
 
    public double add(double a, double b) {
        return a + b;
    }
}

方法覆盖：子类可以定义与父类完全相同的方法，从而允许在运行时选择不同的行为。这就是多态性的实现方式。




public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}
 
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
}
 
public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.eat(); // 输出：Animal is eating
 
        Animal dog = new Dog();
        dog.eat(); // 输出：Dog is eating
    }
}

在多态中，我们可以通过父类的引用指向子类的对象，并调用子类中覆盖（重写）的方法，这样就能在运行时动态地决定调用哪个版本的方法。这是面向对象编程中实现代码复用和提高系统灵活性的重要手段。

【JAVA】 javaSE中的数组|数组的概念&使用

2024-08-08

在Java中，数组是一种数据结构，用于存储相同类型的多个元素。数组是一种效率较高的存储和随机访问数据的方式。

数组的定义：

在Java中，数组必须先定义才能使用。你可以使用下面的语法来定义一个数组：




dataType[] arrayRefVar;  // 首选的方式

或




dataType arrayRefVar[];  // 效果与上面相同，但不是首选的方式

例如，定义一个整型数组：




int[] myArray;

数组的初始化：

Java中有两种初始化数组的方式：

静态初始化：在定义数组的同时给数组赋值。




int[] myArray = {1, 2, 3, 4, 5};

动态初始化：先定义数组的大小，然后再赋值。




int[] myArray = new int[5];
myArray[0] = 1;
myArray[1] = 2;
myArray[2] = 3;
myArray[3] = 4;
myArray[4] = 5;

数组的访问：

在Java中，数组是从0开始索引的，最后一个元素的索引是数组长度减一。你可以使用数组索引来访问数组元素。




int firstElement = myArray[0];
int lastElement = myArray[myArray.length - 1];

数组的遍历：

你可以使用for循环来遍历数组的所有元素。




for(int i = 0; i < myArray.length; i++) {
    System.out.println(myArray[i]);
}

数组的基本概念和使用就是这些，更多高级特性和用法可以参考Java官方文档。