AuroraLilis

Spring框架

Tue, 18 Mar 2025 00:00:00 GMT

Spring 框架

Java Spring Boot是一个基于Spring框架的开源项目，旨在简化Spring应用的创建、配置和部署过程。以下是Spring Boot中的主要概念：

Spring Boot Starter：
- Spring Boot Starter是一系列依赖描述符，用于简化依赖管理。例如，spring-boot-starter-web包含了构建Web应用所需的所有依赖。
自动配置（Auto-Configuration）：
- Spring Boot通过自动配置尝试根据类路径设置、其他bean和各种属性设置来配置Spring应用。这样可以减少或消除需要手动编写的配置。
嵌入式服务器：
- Spring Boot支持嵌入式服务器，如Tomcat、Jetty或Undertow，使得开发人员可以轻松地将应用打包为独立的JAR文件，直接运行。
Spring Boot CLI：
- Spring Boot CLI是一个命令行工具，用于快速开发和测试Spring Boot应用。它支持Groovy脚本，使得编写Spring应用更加简洁。
Actuator：
- Spring Boot Actuator提供了生产级别的功能，如健康检查、审计、指标收集和HTTP跟踪等，帮助监控和管理应用。
Properties和YAML配置：
- Spring Boot允许使用.properties或.yaml文件来外部化配置，使得配置管理更加灵活。
Profile：
- Profile是Spring Boot中用于在不同环境中配置应用的方式。例如，可以有不同的配置文件用于开发、测试和生产环境。
Spring Boot Starter Parent：
- spring-boot-starter-parent是一个特殊的 Starter，它提供了默认的配置，如Maven依赖管理、插件配置等。
Spring Boot Maven/Gradle插件：
- 这些插件提供了打包、运行和测试Spring Boot应用的便捷方式。
主类（Main Class）：
- Spring Boot应用通常包含一个主类，使用@SpringBootApplication注解，并包含一个main方法来启动应用。
SpringApplicationBuilder：
- SpringApplicationBuilder用于以编程方式配置和启动Spring Boot应用。
事件和监听器：
- Spring Boot提供了事件和监听器机制，允许在应用的生命周期中执行特定操作。
安全性（Security）：
- Spring Boot集成了Spring Security，提供了安全认证和授权的功能。
数据访问：
- Spring Boot支持多种数据访问技术，如JPA、JDBC、MongoDB等，并通过Starter简化配置。
Thymeleaf：
- Thymeleaf是Spring Boot推荐的模板引擎，用于构建动态Web页面。
RESTful API：
- Spring Boot使得创建RESTful API变得简单，通过Controller来处理HTTP请求。
AOP（面向切面编程）：
- Spring Boot支持AOP，允许开发者在不修改核心代码的情况下添加新功能。
测试：
- Spring Boot提供了丰富的测试支持，包括单元测试、集成测试和端到端测试。
日志：
- Spring Boot集成了日志框架，如Logback、Log4j2等，提供了灵活的日志配置。
国际化（i18n）：
- Spring Boot支持国际化，允许根据用户的语言和地区设置显示不同的内容。这些概念共同构成了Spring Boot框架，使得Java开发更加高效、简洁和强大。

核心概念

控制反转： Inversion Of Control，简称IOC。对象的创建控制权由程序自身转移到外部（容器），这种思想称为控制反转。
- 对象的创建权由程序员主动创建转移到容器(由容器创建、管理对象)。这个容器称为：IOC容器或Spring容器。
依赖注入： Dependency Injection，简称DI。容器为应用程序提供运行时，所依赖的资源，称之为依赖注入。
- 程序运行时需要某个资源，此时容器就为其提供这个资源。
- 例：EmpController程序运行时需要EmpService对象，Spring容器就为其提供并注入EmpService对象。
**bean对象：**IOC容器中创建、管理的对象，称之为：bean对象。

要把某个对象交给IOC容器管理，需要在类上添加一个注解：@Component

而Spring框架为了更好的标识web应用程序开发当中，bean对象到底归属于哪一层，又提供了@Component的衍生注解：

注解	说明	位置
@Component	声明bean的基础注解	不属于以下三类时，用此注解
@Controller	@Component的衍生注解	标注在控制层类上
@Service	@Component的衍生注解	标注在业务层类上
@Repository	@Component的衍生注解	标注在数据访问层类上（由于与mybatis整合，用的少）

HTTP协议

Tue, 18 Mar 2025 00:00:00 GMT

基本介绍

HTTP：Hyper Text Transfer Protocol(超文本传输协议)，规定了浏览器与服务器之间数据传输的规则。

基于TCP协议: 面向连接

TCP是一种面向连接的(建立连接之前是需要经过三次握手)、可靠的、基于字节流的传输层通信协议，在数据传输方面更安全

基于请求-响应模型: 一次请求对应一次响应（先请求后响应）

请求和响应是一一对应关系，没有请求，就没有响应

HTTP协议是无状态协议: 对于数据没有记忆能力。每次请求-响应都是独立的

无状态指的是客户端发送HTTP请求给服务端之后，服务端根据请求响应数据，响应完后，不会记录任何信息。

缺点: 多次请求间不能共享数据

优点: 速度快

请求之间无法共享数据会引发的问题：

如：京东购物。加入购物车和去购物车结算是两次请求

由于HTTP协议的无状态特性，加入购物车请求响应结束后，并未记录加入购物车是何商品

发起去购物车结算的请求后，因为无法获取哪些商品加入了购物车，会导致此次请求无法正确展示数据

具体使用的时候，我们发现京东是可以正常展示数据的，原因是Java早已考虑到这个问题，并提出了使用会话技术(Cookie、Session)来解决这个问题。具体如何来做，我们后面课程中会讲到。

请求

**请求协议：**浏览器将数据以请求格式发送到服务器。包括：请求行、请求头、请求体

GET

请求行 ：HTTP请求中的第一行数据。由：请求方式、资源路径、协议/版本组成（之间使用空格分隔）
- 请求方式：GET
- 资源路径：/brand/findAll?name=OPPO&status=1
  - 请求路径：/brand/findAll
  - 请求参数：name=OPPO&status=1
    - 请求参数是以key=value形式出现
    - 多个请求参数之间使用&连接
  - 请求路径和请求参数之间使用?连接
- 协议/版本：HTTP/1.1
请求头：第二行开始，上图黄色部分内容就是请求头。格式为key: value形式
- http是个无状态的协议，所以在请求头设置浏览器的一些自身信息和想要响应的形式。

请求头	含义
Host	表示请求的主机名
User-Agent	浏览器版本。例如：Chrome浏览器的标识类似Mozilla/5.0 ...Chrome/79 ，IE浏览器的标识类似Mozilla/5.0 (Windows NT ...)like Gecko
Accept	表示浏览器能接收的资源类型，如text/，image/或者/表示所有；
Accept-Language	表示浏览器偏好的语言，服务器可以据此返回不同语言的网页；
Accept-Encoding	表示浏览器可以支持的压缩类型，例如gzip, deflate等。
Content-Type	请求主体的数据类型
Content-Length	数据主体的大小（单位：字节）

请求体：存储请求参数
- GET请求的请求参数在请求行中，故不需要设置请求体

POST

请求行：包含请求方式、资源路径、协议/版本
- 请求方式：POST
- 资源路径：/brand
- 协议/版本：HTTP/1.1
请求头
请求体 ：存储请求参数
- 请求体和请求头之间是有一个空行隔开（作用：用于标记请求头结束）

GET请求和POST请求的区别：

区别方式	GET请求	POST请求
请求参数	请求参数在请求行中。<br/>例：/brand/findAll?name=OPPO&status=1	请求参数在请求体中
请求参数长度	请求参数长度有限制(浏览器不同限制也不同)	请求参数长度没有限制
安全性	安全性低。原因：请求参数暴露在浏览器地址栏中。	安全性相对高

示例

@RestController
public class RequestController {

    /**
     * 请求路径 http://localhost:8080/request?name=Tom&age=18
     * @param request
     * @return
     */
    @RequestMapping("/request")
    public String request(HttpServletRequest request){
        //1.获取请求参数 name, age
        String name = request.getParameter("name");
        String age = request.getParameter("age");
        System.out.println("name = " + name + ", age = " + age);
        
        //2.获取请求路径
        String uri = request.getRequestURI();
        String url = request.getRequestURL().toString();
        System.out.println("uri = " + uri);
        System.out.println("url = " + url);
        
        //3.获取请求方式
        String method = request.getMethod();
        System.out.println("method = " + method);
        
        //4.获取请求头
        String header = request.getHeader("User-Agent");
        System.out.println("header = " + header);
        return "request success";
    }

}

常见状态码

状态码	英文描述	解释
200	OK	客户端请求成功，即处理成功，这是我们最想看到的状态码
302	Found	指示所请求的资源已移动到由Location响应头给定的 URL，浏览器会自动重新访问到这个页面
304	Not Modified	告诉客户端，你请求的资源至上次取得后，服务端并未更改，你直接用你本地缓存吧。隐式重定向
400	Bad Request	客户端请求有语法错误，不能被服务器所理解
403	Forbidden	服务器收到请求，但是拒绝提供服务，比如：没有权限访问相关资源
404	Not Found	请求资源不存在，一般是URL输入有误，或者网站资源被删除了
405	Method Not Allowed	请求方式有误，比如应该用GET请求方式的资源，用了POST
428	Precondition Required	服务器要求有条件的请求，告诉客户端要想访问该资源，必须携带特定的请求头
429	Too Many Requests	指示用户在给定时间内发送了太多请求（“限速”），配合 Retry-After(多长时间后可以请求)响应头一起使用
431	Request Header Fields Too Large	请求头太大，服务器不愿意处理请求，因为它的头部字段太大。请求可以在减少请求头域的大小后重新提交。
500	Internal Server Error	服务器发生不可预期的错误。服务器出异常了，赶紧看日志去吧
503	Service Unavailable	服务器尚未准备好处理请求，服务器刚刚启动，还未初始化好

YAML配置文件

Tue, 18 Mar 2025 00:00:00 GMT

YAML配置文件详解 YAML是“YAML Ain't Markup Language”（递归缩写为“YAML不是标记语言”）的缩写，原意是强调这种语言以数据做为中心，而不是标记语言。YAML是一种直观的能够被电脑读取的数据序列化格式，也易于人类阅读。它常被用于配置文件、数据交换、数据存储等场景。

一、基本语法

大小写敏感：YAML对大小写是敏感的，key和value的大小写需要一致。
缩进表示层级：YAML使用缩进来表示数据层级关系，缩进只能使用空格，不能使用Tab键。通常建议每个层级缩进两个空格。
冒号后有空格：key: value中的:后面必须有一个空格。
支持注释：YAML允许使用#进行注释，从#开始到行尾的所有内容都将被视为注释。
在yml格式的配置文件中，如果配置项是以0开头的，需要以''引起来，因为0开头在yml中表示8进制的数据。

二、数据类型

YAML支持多种数据类型，包括：

纯量（Scalar）：单个的、不可再分的值，如字符串、布尔值、整数、浮点数等。
- 字符串：可以直接书写，也可以使用引号包裹。
- 布尔值：用true、false表示。
- 数值：直接书写，支持整数和浮点数。
序列（Sequence）：一组按顺序排列的值，类似于数组或列表。使用-表示每个元素。
```
list:
  - item1
  - item2
  - item3
```
映射（Mapping）：键值对集合，类似于字典或哈希表。使用key: value表示。
```
dictionary:
  key1: value1
  key2: value2
  key3: value3
```

嵌套：YAML支持数据的嵌套，可以组合使用序列和映射。

nested:
  - key1: value1
    key2: value2
  - key3: value3
    key4: value4

三、特殊语法

引用：使用&定义锚点，使用*引用锚点。

anchor: &commonSetting
  setting1: value1
  setting2: value2
ref1:
  <<: *commonSetting
  additionalSetting: value3
ref2:
  <<: *commonSetting
  anotherSetting: value4

合并：使用<<表示合并其他映射的内容。

base:
  setting1: value1
  setting2: value2
override:
  <<: *base
  setting2: newValue

多行字符串：使用|或>表示多行字符串。|保留换行符，>折叠换行符。

multiLineString1: |
  This is a multi-line string
  with preserved newlines.
multiLineString2: >
  This is another multi-line string
  with folded newlines.

四、示例

以下是一个完整的YAML配置文件示例：

# 这是注释
name: Example Configuration
description: This is an example YAML configuration file.
settings:
  debug: true
  verbosity: 2
database:
  host: localhost
  port: 3306
  username: user
  password: pass
servers:
  - id: 1
    name: server1
    ip: 192.168.1.1
  - id: 2
    name: server2
    ip: 192.168.1.2
anchors:
  &defaultPorts
    http: 80
    https: 443
ports:
  <<: *defaultPorts
  ssh: 22

在这个示例中，我们定义了配置文件的名称、描述、一些设置、数据库连接信息、服务器列表以及端口号。我们还展示了如何使用锚点和引用来复用数据。

五、使用场景

YAML常用于以下场景：

配置文件：如Docker-compose、Kubernetes、Ansible等工具的配置文件。
数据交换：在不同系统间交换数据。
数据存储：存储结构化数据，如配置信息、用户数据等。 六、注意事项
缩进：务必使用空格进行缩进，不要使用Tab键。
引号：虽然YAML允许不使用引号包裹字符串，但在某些特殊情况下（如字符串包含冒号、换行符等）需要使用引号。
兼容性：不同的YAML解析器可能存在细微的兼容性问题，建议查阅相关文档以确保兼容性。通过以上介绍，相信您对YAML配置文件有了更深入的了解。在实际使用中，请根据具体需求和场景选择合适的语法和结构。

virtual在使用中的问题

Sun, 16 Mar 2025 00:00:00 GMT

virtual在使用中的问题

想要重写基类的方法，应该将基类方法上加入关键字virtual。

如果不加，在重写父类方法时可能会有问题，虽然编译器不会报错，但是使用多态时，会调用到基类的方法。

#include<iostream>  
using namespace std;
class Animal{
    public:
    void say(){
        cout<<"Animal say"<<endl;
    }
};
class Cat:public Animal{
    public:
    void say(){
        cout<<"Cat say"<<endl;
    }
};

int main(){
    Animal *a=new Animal();
    Cat *c=new Cat();
    a->say();
    c->say();
    Animal *ac=new Cat();
    ac->say();
    return 0;
}

输出：

Animal say
Cat say
Animal say

父类方法使用virtual关键字之后，仍然可以通过父类获取到父类的方法，但是使用多态时不会出现问题。

#include<iostream>  
using namespace std;
class Animal{
    public:
    virtual void say(){
        cout<<"Animal say"<<endl;
    }
};
class Cat:public Animal{
    public:
    void say(){
        cout<<"Cat say: ";
        Animal::say();
    }
};

int main(){
    Animal *a=new Animal();
    Cat *c=new Cat();
    a->say();
    c->say();
    cout << endl;
    Animal *ac=new Cat();
    ac->say();
    return 0;
}

输出：

Animal say
Cat say: Animal say

Cat say: Animal say

C++在编译类时，会创建一个包含类中所有方法的二进制对象。在非虚的情况下，将控制交给正确的方法的代码是硬编码，此时会根据编译时的类型调用方法。这成为静态绑定(static binding)，也成为早绑定(early binding)。

如果方法声明为virtual，会使用名为虚表(vtable)的特定内存区域调用正确的实现。每个具有一个或多个虚方法的类都有一张虚表，这种类的每个对象都包含指向虚表的指针，这个虚表包含指向虚方法实现的指针。通过这种方法，当使用某个对象调用方法时，指针也进入虚表，然后根据实际的对象类型执行正确版本的方法。这成为动态绑定(dynamic binding)或晚绑定(late binding)。

纯虚方法和抽象基类

纯虚方法是在类定义中显示说明该方法不需要定义。如果将某个方法设置为纯虚方法，就是告诉编译器当前类中不存在这个方法的定义。具有至少一个纯虚方法的类称为抽象类。

纯虚方法定义：

virtual void set() = 0;

抽象类不能够被直接实例化，需要实现了纯虚方法的继承类。

override关键字

override是C++11引入的关键字，用于显式地指出某个函数是重写基类中的虚函数。它的主要目的是增加代码的可读性和维护性，同时让编译器能够检查重写是否正确。 基本用法：当在派生类中重写基类的一个虚函数时，可以在函数声明后加上override关键字。这样，编译器会检查该函数是否真的重写了基类的某个虚函数，即函数签名（包括函数名、参数列表、常量性等）是否与基类中的虚函数完全匹配。示例：

class Base {
public:
    virtual void func(int) const {}
};
class Derived : public Base {
public:
    void func(int) const override {}  // 正确：显式指出重写基类的func函数
};

作用：

编译器检查：如上所述，override让编译器能够检查重写是否正确。如果派生类中的函数没有正确重写基类的虚函数（例如，参数列表不匹配），编译器会报错。
提高代码可读性：通过使用override，其他阅读代码的人可以很容易地知道这个函数是重写基类的虚函数，而不是派生类特有的函数。
维护性：如果基类中的虚函数签名发生变化，而派生类没有相应更新，使用override的代码会在编译时出错，从而提醒开发者进行修正。 注意事项：

override只能用于派生类中的函数声明或定义上，且该函数必须重写基类的虚函数。
如果基类中的函数不是虚函数，则在派生类中使用override会编译错误。
override关键字应该紧跟在函数声明后，逗号与函数声明之间不能有空格。 错误示例：

class Base {
public:
    void func(int) {}  // 不是虚函数
};
class Derived : public Base {
public:
    void func(int) override {}  // 错误：基类中的func不是虚函数
};

override关键字是C++11中一个非常有用的特性，它提高了代码的健壮性、可读性和维护性。在实际开发中，建议总是使用override来显式指出重写基类的虚函数。

虚基类

在C++中，虚基类（Virtual Base Class）是多重继承中用于解决菱形继承问题的一种机制。所谓菱形继承问题，是指一个派生类从两个或多个基类继承，而这些基类又共同继承自同一个更高级的基类，导致派生类中出现了多份高级基类的实例，引起潜在的二义性和资源浪费。虚基类的引入就是为了解决这一问题。通过将共同基类声明为虚基类，C++确保在派生类中只存在一份虚基类的实例，从而避免了数据重复和二义性。以下是虚基类的一个简单示例：

class A {
public:
    int a;
};
class B : virtual public A {
public:
    int b;
};
class C : virtual public A {
public:
    int c;
};
class D : public B, public C {
public:
    int d;
};

在这个例子中，类B和类C都从类A虚继承，而类D又从类B和类C继承。由于类A是虚基类，所以类D中只会有一个类A的实例，避免了菱形继承问题。虚基类的实现机制相对复杂，它通常通过虚基类表（Vtbl）来维护虚基类的指针，从而确保在派生类中只存在一份虚基类的实例。在使用虚基类时，需要注意构造函数的调用顺序和初始化，因为虚基类的构造函数会在派生类的构造过程中被调用，以确保虚基类的正确初始化。

C++用户自定义字面量

Sun, 16 Mar 2025 00:00:00 GMT

C++11引入了用户自定义字面量（User-Defined Literals）的概念，允许开发者自定义字面量的后缀，以便于创建更直观、更符合特定领域需求的字面量。用户自定义字面量通过在常量后面添加特定的后缀来实现，这些后缀与相应的函数关联，这些函数负责将字面量转换为所需的类型。

用户自定义字面量的基本语法

用户自定义字面量是通过在标识符后面添加operator""后缀来定义的。例如：

long double operator"" _km(long double val) {
    return val * 1000.0;
}
long double operator"" _m(long double val) {
    return val;
}
long double operator"" _cm(long double val) {
    return val / 100.0;
}

在这个例子中，我们定义了三个用户自定义字面量后缀：_km、_m和_cm，它们分别用于表示千米、米和厘米。

使用用户自定义字面量

一旦定义了用户自定义字面量，就可以在代码中直接使用它们：

long double distance = 1.5_km; // 等同于 1500.0
long double length = 100_cm;   // 等同于 1.0

这样，代码的可读性得到了提高，因为字面量直接表达了其物理意义。

用户自定义字面量的类型

用户自定义字面量可以用于以下类型：

整型字面量：unsigned long long
浮点字面量：long double
字符串字面量：const char*
字符字面量：char
C++11中还支持原始字符串字面量：const char* 例如，定义一个用于字符串字面量的自定义后缀：

std::string operator"" _hello(const char* str, size_t len) {
    return std::string(str, len) + " hello";
}
int main() {
    std::string greeting = "World"_hello; // 结果为 "World hello"
    return 0;
}

注意事项

用户自定义字面量函数必须是静态成员函数或全局函数。
字面量运算符函数不能有默认参数。
字符串字面量运算符函数必须接受两个参数：一个const char*和一个size_t，后者表示字符串的长度。
用户自定义字面量可以提高代码的可读性和维护性，但应避免过度使用，以免造成混淆。

实际应用

用户自定义字面量在实际开发中可以用于多种场景，如单位转换、货币转换、字符串处理等。它们使得代码更加直观，减少了转换错误的可能性。

系统自带的字面量

auto str1 = "hello"_s;
// std::string
auto str2 = "hello";
// const char*

C++可变参数

Sun, 16 Mar 2025 00:00:00 GMT

在C++中，使用可变参数主要有两种方式：一种是通过C风格的变参函数，另一种是利用C++11引入的初始化列表和变参模板。

C风格的变参函数

C风格的变参函数使用stdarg.h头文件中的宏来实现。下面是一个简单的例子：

#include <iostream>
#include <cstdarg>
void printNumbers(int count, ...) {
    va_list args;
    va_start(args, count);
    for (int i = 0; i < count; ++i) {
        int num = va_arg(args, int);
        std::cout << num << " ";
    }
    va_end(args);
    std::cout << std::endl;
}
int main() {
    printNumbers(3, 1, 2, 3);  // 输出: 1 2 3
    printNumbers(5, 4, 5, 6, 7, 8);  // 输出: 4 5 6 7 8
    return 0;
}

在这个例子中，printNumbers函数可以接受任意数量的整数参数。第一个参数count指定了后面参数的数量。va_list、va_start、va_arg和va_end是处理可变参数的宏。

#include <iostream>
#include <cstdarg> // C++中应使用cstdarg而不是stdarg.h

// 计算所有参数的和
double sum(int count, ...) {
    va_list args;
    va_start(args, count); // 初始化args来存储参数

    double total = 0;
    for (int i = 0; i < count; ++i) {
        total += va_arg(args, double); // 获取下一个参数
    }

    va_end(args); // 清理工作
    return total;
}

int main() {
    std::cout << "Sum: " << sum(3, 1.1, 2.2, 3.3) << std::endl; // 输出应该是6.6
    return 0;
}

C++11的初始化列表和变参模板

C++11引入了更加现代化和类型安全的方法来处理可变参数，即使用初始化列表和变参模板。下面是一个例子：

#include <iostream>
#include <initializer_list>
void printNumbers(std::initializer_list<int> args) {
    for (int num : args) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
}
int main() {
    printNumbers({1, 2, 3});  // 输出: 1 2 3
    printNumbers({4, 5, 6, 7, 8});  // 输出: 4 5 6 7 8
    return 0;
}

在这个例子中，printNumbers函数接受一个initializer_list<int>类型的参数，它可以包含任意数量的整数。此外，C++11还支持变参模板，允许模板接受任意数量的参数。下面是一个使用变参模板的例子：

#include <iostream>
template<typename... Args>
void printNumbers(Args... args) {
    (std::cout << ... << args) << std::endl;
}
int main() {
    printNumbers(1, " ", 2, " ", 3);  // 输出: 1 2 3
    printNumbers(4, " ", 5, " ", 6, " ", 7, " ", 8);  // 输出: 4 5 6 7 8
    return 0;
}

在这个例子中，printNumbers是一个变参模板函数，可以接受任意类型和数量的参数。参数展开使用折叠表达式(std::cout << ... << args)实现。这两种方法都可以在C++中实现可变参数的功能，但C++11的初始化列表和变参模板提供了更好的类型安全和便利性。

#include <iostream>
#include <tuple>

// 变参模板函数的递归终止条件
template<typename T>
T sum(T last) {
    return last;
}

// 变参模板函数
template<typename T, typename... Args>
T sum(T first, Args... args) {
    return first + sum(args...); // 递归调用
}

int main() {
    std::cout << "Sum: " << sum(1, 2, 3, 4, 5) << std::endl; // 输出应该是15
    return 0;
}

折叠表达式

折叠表达式是C++17引入的一种特性，用于在变参模板中简化对参数包的处理。在上述例子中，(std::cout << ... << args)就是一个折叠表达式。

折叠表达式的语法

折叠表达式的语法如下：

(op ...)：一元右折叠
(... op)：一元左折叠
(init op ...)：二元右折叠
(... op init)：二元左折叠其中：
op 是一个二元操作符，如+、<<等。
... 表示参数包。
init 是一个初始值。

折叠表达式的工作原理

折叠表达式会将参数包中的每个参数依次与操作符op结合，最终得到一个结果。具体来说：

一元右折叠：从右向左结合，例如(a + ... + z)等价于a + (b + (c + ... + z))。
一元左折叠：从左向右结合，例如(... + a + b + c)等价于((a + b) + c)。
二元右折叠：从右向左结合，每个参数都与init结合，例如(init + ... + z)等价于init + (a + (b + (c + ... + z)))。
二元左折叠：从左向右结合，每个参数都与init结合，例如(... + a + b + c + init)等价于(((a + b) + c) + init)。

在例子中的应用

在上述例子中，(std::cout << ... << args)是一个一元左折叠表达式。它的工作原理如下：

从左向右开始，首先将args中的第一个参数与std::cout结合，使用<<操作符输出。
然后将结果（即更新后的std::cout）与args中的第二个参数结合，再次使用<<操作符输出。
重复上述过程，直到所有参数都被输出。最终，这个折叠表达式会依次将所有参数输出到标准输出流std::cout中。

优点

使用折叠表达式处理变参模板参数具有以下优点：

简洁：避免了冗长的递归函数或循环。
直观：直接表达了参数的处理方式。
高效：编译器可以优化折叠表达式的实现。

以下是一些使用C17折叠表达式处理可变参数的例子：

例子1：打印多个值

#include <iostream>
#include <string>
template<typename... Args>
void print(Args... args) {
    (std::cout << ... << args) << std::endl;
}
int main() {
    print("Hello, ", "world!", " The answer is ", 42);
    // 输出: Hello, world! The answer is 42
    return 0;
}

例子2：计算多个数的和

#include <iostream>
template<typename... Args>
auto sum(Args... args) {
    return (args + ...);
}
int main() {
    std::cout << "The sum is: " << sum(1, 2, 3, 4, 5) << std::endl;
    // 输出: The sum is: 15
    return 0;
}

例子3：连接字符串

#include <iostream>
#include <string>
template<typename... Args>
std::string concatenate(Args... args) {
    return (args + ...);
}
int main() {
    std::cout << "Concatenated string: " << concatenate(std::string("Hello, "), "world", "!")
              << std::endl;
    // 输出: Concatenated string: Hello, world!
    return 0;
}

例子4：检查所有参数是否满足某个条件

#include <iostream>
template<typename... Args>
bool all(Args... args) {
    return (... && args);
}
int main() {
    std::cout << std::boolalpha; // 打印布尔值而非0或1
    std::cout << "All true: " << all(true, true, true) << std::endl;
    // 输出: All true: true
    std::cout << "All true: " << all(true, false, true) << std::endl;
    // 输出: All true: false
    return 0;
}

例子5：使用初始化列表和折叠表达式创建数组

#include <iostream>
#include <array>
template<typename T, typename... Args>
auto createArray(T first, Args... args) {
    return std::array<T, 1 + sizeof...(Args)>{first, args...};
}
int main() {
    auto arr = createArray(1, 2, 3, 4, 5);
    std::cout << "Array elements: ";
    for (auto elem : arr) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;
    // 输出: Array elements: 1 2 3 4 5
    return 0;
}

这些例子展示了折叠表达式在处理不同类型和数量的参数时的灵活性和强大功能。通过折叠表达式，我们可以编写更简洁、更直观的代码来处理可变参数。

C++类型别名

Sun, 16 Mar 2025 00:00:00 GMT

在C++中，类型别名（Type Alias） 和 typedef 都用于为现有类型创建别名，但它们的语法、功能和使用场景有所不同。

1. 基本概念

typedef：C++早期引入的机制，用于为类型创建别名，语法较为古老。
类型别名（using）：C++11引入的现代语法，功能更强大，语法更直观。

2. 语法区别

typedef 的语法

typedef 原类型 别名名;

例如：

typedef int MyInt;          // 基本类型别名
typedef void (*FuncPtr)(int); // 函数指针别名
typedef std::vector<int> IntVec; // 标准库类型别名

using 的语法

using 别名名 = 原类型;

例如：

using MyInt = int;          // 基本类型别名
using FuncPtr = void (*)(int); // 函数指针别名
using IntVec = std::vector<int>; // 标准库类型别名

区别：

using 的语法更接近赋值操作（=），可读性更高。
typedef 的语法更冗长，尤其在复杂类型（如函数指针、模板）中更难理解。

3. 复杂类型的处理

函数指针

typedef：

typedef void (*FuncPtr)(int); // 需要写成 `(*FuncPtr)(int)`

using：

using FuncPtr = void (*)(int); // 直接声明，语法更清晰

多维数组

typedef：

typedef int (*Array2D)[10]; // 二维数组指针

using：

using Array2D = int (*)[10]; // 更直观

模板类型

typedef：

typedef std::map<std::string, std::vector<int>>::iterator StrVecIter;

（嵌套模板时，语法复杂，容易出错）

using：

using StrVecIter = std::map<std::string, std::vector<int>>::iterator;

（语法更简洁）

4. 模板别名（Template Aliases）

using 支持定义模板别名，而 typedef 无法直接实现这一点。

using 的模板别名

template<typename T>
using MyVector = std::vector<T>; // 定义模板别名

MyVector<int> vec; // 等价于 std::vector<int>

typedef 的局限性

无法直接定义模板别名：

// 错误！typedef 无法直接定义模板别名
template<typename T>
typedef std::vector<T> MyVector; // 编译报错

5. 匿名类型

两者均不能为匿名类型创建别名：

// 错误！匿名结构体无法通过 typedef 或 using 创建别名
typedef struct { int x; } Point; // 必须命名结构体
using Point = struct { int x; }; // 同样错误

6. 可读性和现代性

using 更符合现代C++风格：
- 语法更直观（= 赋值操作）。
- 在复杂类型（如函数指针、模板）中更易读。
typedef 语法更冗长，尤其在复杂类型中难以一眼看出类型结构。

7. 其他特性

using 支持模板参数推导：

template<typename T>
using Pair = std::pair<const T, T>;

Pair<int> p(1, 2); // 等价于 std::pair<const int, int>

typedef 无法直接支持模板参数推导。

总结：何时使用？

场景	推荐使用	原因
基本类型或简单类型别名	`using`	语法更简洁直观。
函数指针或复杂类型	`using`	`typedef` 的语法易混淆，`using` 更清晰。
模板别名	`using`	`typedef` 无法直接定义模板别名。
向后兼容旧代码	`typedef`	如果代码需要兼容C或旧C++标准，可能需要保留 `typedef`。

示例对比

// 传统 typedef
typedef std::map<std::string, int>::iterator StringIntIter;

// 现代 using
using StringIntIter = std::map<std::string, int>::iterator;

// 模板别名（仅 using 支持）
template<typename Key, typename Value>
using MyMap = std::map<Key, Value>;

MyMap<std::string, int> myMap;

通过使用 using，代码的可读性和现代性显著提升，尤其在处理复杂类型时。而 typedef 更适合兼容旧代码或简单类型别名。

explicit关键字

Sat, 15 Mar 2025 00:00:00 GMT

explicit是C++中的一个关键字，用于修饰构造函数或转换函数，以防止隐式类型转换。它的主要目的是增加代码的清晰性和避免潜在的错误。

`explicit`与构造函数

在C++中，当某个类有一个单参数的构造函数时，这个构造函数通常会被用作从参数类型到该类的隐式类型转换。有时这种隐式转换可能会导致意外的结果或错误。 示例：

class MyClass {
public:
    MyClass(int value) { /* ... */ }
};
void func(MyClass obj) { /* ... */ }
int main() {
    func(10);  // 隐式地将int转换为MyClass
    return 0;
}

在上面的代码中，func(10)会隐式地调用MyClass的构造函数，将int类型的10转换为MyClass类型的对象。 使用explicit： 为了防止这种隐式转换，可以使用explicit关键字来修饰构造函数：

class MyClass {
public:
    explicit MyClass(int value) { /* ... */ }
};
void func(MyClass obj) { /* ... */ }
int main() {
    func(10);  // 错误：无法隐式地将int转换为MyClass
    func(MyClass(10));  // 正确：显式地调用构造函数
    return 0;
}

在这个修改后的版本中，func(10)会导致编译错误，因为MyClass的构造函数被声明为explicit，从而阻止了隐式类型转换。但你可以通过显式地调用构造函数来创建一个MyClass对象，如func(MyClass(10))。

`explicit`与转换函数

除了构造函数，explicit还可以用于修饰转换函数（即类型转换运算符）。 示例：

class MyClass {
public:
    operator int() const { /* ... */ return 0; }
};
void func(int value) { /* ... */ }
int main() {
    MyClass obj;
    func(obj);  // 隐式地将MyClass转换为int
    return 0;
}

在上面的代码中，func(obj)会隐式地调用MyClass的转换函数，将MyClass类型的obj转换为int类型。 使用explicit： 为了防止这种隐式转换，可以使用explicit关键字来修饰转换函数：

class MyClass {
public:
    explicit operator int() const { /* ... */ return 0; }
};
void func(int value) { /* ... */ }
int main() {
    MyClass obj;
    func(obj);  // 错误：无法隐式地将MyClass转换为int
    func(static_cast<int>(obj));  // 正确：显式地调用转换函数
    return 0;
}

在这个修改后的版本中，func(obj)会导致编译错误，因为MyClass的转换函数被声明为explicit，从而阻止了隐式类型转换。但你可以通过显式地使用static_cast来执行类型转换，如func(static_cast<int>(obj))。

为什么使用`explicit`？

避免意外行为：隐式类型转换有时会导致意外的行为，特别是当转换不是程序员预期的时候。
提高代码可读性：显式类型转换使得代码的意图更明确，其他阅读代码的人可以更容易地理解类型转换的目的是什么。
调试更简单：当出现类型转换相关的问题时，如果使用了explicit，编译器通常会提供更明确的错误信息，从而使得调试更简单。总之，explicit关键字是C++中一个非常有用的工具，可以帮助程序员编写更清晰、更健壮的代码。

JUnit

Sat, 15 Mar 2025 00:00:00 GMT

JUnit是一个Java语言的单元测试框架。它广泛用于测试小型到大型代码库，以确保代码的正确性和稳定性。以下是JUnit的详细用法：

JUnit 基本用法

添加依赖

首先，你需要在项目的pom.xml文件中添加JUnit的依赖：

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>unit-jupiter</artifactId>
    <version>5.9.1</version>
    <scope>test</scope>
</dependency>

编写测试类

使用@Test注解标记测试方法。
使用assertEquals、assertTrue、assertFalse等断言方法验证结果。

import org.junit.Test;
import static org.junit.Assert.*;
public class CalculatorTest {
    @Test
    public void testAdd() {
        Calculator calculator = new Calculator();
        int result = calculator.add(2, 3);
        assertEquals(5, result);
    }
}

命名规则：
- 类名：XXXXTest
- 方法名：testXXXX

运行测试

使用IDE的测试运行器。
使用构建工具（如Maven或Gradle）运行测试。

JUnit 高级特性

注解

注解	说明	备注
@Test	测试类中的方法用它修饰才能成为测试方法，才能启动执行	单元测试
@BeforeEach	用来修饰一个实例方法，该方法会在每一个测试方法执行之前执行一次。	初始化资源(准备工作)
@AfterEach	用来修饰一个实例方法，该方法会在每一个测试方法执行之后执行一次。	释放资源(清理工作)
@BeforeAll	用来修饰一个静态方法，该方法会在所有测试方法之前只执行一次。	初始化资源(准备工作)
@AfterAll	用来修饰一个静态方法，该方法会在所有测试方法之后只执行一次。	释放资源(清理工作)
@ParameterizedTest	参数化测试的注解 (可以让单个测试运行多次，每次运行时仅参数不同)	用了该注解，就不需要@Test注解了
@ValueSource	参数化测试的参数来源，赋予测试方法参数	与参数化测试注解配合使用
@DisplayName	指定测试类、测试方法显示的名称（默认为类名、方法名）

public class CalculatorTest {
    @Before
    public void setUp() {
        // 初始化代码
    }
    @Test
    public void testAdd() {
        // 测试代码
    }
    @After
    public void tearDown() {
        // 清理代码
    }
}

断言

Assertions下的静态方法：

assertEquals(expected, actual): 检查两个值是否相等。
assertTrue(condition): 检查条件是否为真。
assertFalse(condition): 检查条件是否为假。
assertNull(object): 检查对象是否为null。
assertNotNull(object): 检查对象是否不为null。
assertSame(expected, actual): 检查两个对象是否引用相同。
assertNotSame(expected, actual): 检查两个对象是否引用不同。

每个方法最后都可以传入一个String类型的message用于错误的提示

JUnit 的新特性

JUnit 5架构

JUnit 5由三个主要模块组成：

JUnit Platform: 为在JVM上启动测试提供基础设施。
JUnit Jupiter: JUnit 5的新测试引擎，提供注解、断言等。
JUnit Vintage: 允许在JUnit 5中运行JUnit 3和JUnit 4的测试。

注解改进

@BeforeEach: 替代了JUnit 4的@Before。
@AfterEach: 替代了JUnit 4的@After。
@BeforeAll: 替代了JUnit 4的@BeforeClass。
@AfterAll: 替代了JUnit 4的@AfterClass。
@DisplayName: 为测试类或方法提供显示名称。
@Nested: 允许编写嵌套的测试类。

断言改进

assertAll(): 组合多个断言，即使某个断言失败，也能执行所有断言。
assertThrows(): 检查代码是否抛出特定的异常。

public class CalculatorTest {
    @Test
    public void testAdd() {
        Calculator calculator = new Calculator();
        assertAll(
            () -> assertEquals(2, calculator.add(1, 1)),
            () -> assertEquals(4, calculator.add(2, 2))
        );
    }
    @Test
    public void testDivide() {
        Calculator calculator = new Calculator();
        assertThrows(ArithmeticException.class, () -> calculator.divide(1, 0));
    }
}

参数化测试改进

JUnit 5提供了更简洁的参数化测试方式。

public class ParameterizedTest {
    @ParameterizedTest
    @CsvSource({
        "1, 1, 2",
        "2, 2, 4",
        "3, 3, 6"
    })
    public void testAdd(int numberA, int numberB, int expected) {
        Calculator calculator = new Calculator();
        assertEquals(expected, calculator.add(numberA, numberB));
    }
}

示例

package com.auroralilis;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;

import static org.junit.jupiter.api.Assertions.assertEquals;

public class demoTest {

    @Test
    public void testDemo(){
        int a = 1;
    }
    @Test
    public void testAsert(){
        int a = 1;
        assertEquals(a,1, "这是一个提示信息");
    }
    @Test
    public void testException(){
        Assertions.assertThrows(ArithmeticException.class, () -> {
            int i = 1, b = 0;
            int i1 = i / b;
        });
    }
    @ParameterizedTest
    @CsvSource({
            "1, 1, 2",
            "2, 2, 4",
            "3, 3, 6"
    })
    public void testAdd(int numberA, int numberB, int expected) {
        assertEquals(expected, (numberA + numberB));
    }
    @DisplayName("输出输入数字")
    @ParameterizedTest
    @ValueSource(ints = {1, 2, 3})
    public void testSub(int numberA) {
        System.out.println(numberA);
    }
}

C++右值及相关用法

Fri, 14 Mar 2025 00:00:00 GMT

右值和右值引用

基本概念

左值（Lvalue）：

可以出现在赋值语句的左边。
有持久性的内存地址，可以取地址。
例如：变量、对象等。

右值（Rvalue）：

只能出现在赋值语句的右边。
没有持久性的内存地址，不能取地址。
例如：字面量、临时对象、表达式结果等。

右值引用

右值引用是C++11引入的新特性，使用&&表示。它允许我们引用即将被销毁的临时对象，从而避免不必要的拷贝，提高程序性能。语法：

Type&& 右值引用变量 = 右值;

示例：

int a = 10;
int&& rref = 20; // 20是右值，rref是右值引用

右值引用的作用

避免不必要的拷贝：

在函数参数传递、返回值等场景中，使用右值引用可以避免临时对象的拷贝，提高效率。

实现移动语义：

通过右值引用，可以定义移动构造函数和移动赋值运算符，实现资源的移动而不是拷贝。

完美转发：

在模板函数中，使用右值引用可以实现参数的完美转发，保持参数的原始类型（左值或右值）。

移动语义

移动构造函数：

用于初始化新对象，将另一个对象的资源“移动”到新对象中。
语法：ClassName::ClassName(ClassName&& other)。

移动赋值运算符：

用于将一个对象的资源“移动”到另一个对象中。
语法：ClassName& ClassName::operator=(ClassName&& other)。

示例：

class MyString {
public:
    MyString(MyString&& other) { // 移动构造函数
        // 移动资源
    }
    MyString& operator=(MyString&& other) { // 移动赋值运算符
        // 移动资源
        return *this;
    }
};

完美转发

完美转发是指在进行函数参数传递时，保持参数的原始类型（左值或右值）。语法：

使用std::forward函数模板实现完美转发。示例：

template<typename T>
void func(T&& param) {
    anotherFunc(std::forward<T>(param));
}
void anotherFunc(int& a) { // 接收左值
    // ...
}
void anotherFunc(int&& a) { // 接收右值
    // ...
}

注意事项

右值引用本身是左值，可以取地址。
右值引用延长了临时对象的生命周期。
避免对同一右值引用进行多次移动操作。

应用场景

容器操作（如std::vector的push_back）。
智能指针（如std::unique_ptr、std::shared_ptr）。
函数返回值优化（RVO）和命名返回值优化（NRVO）。

完美转发

完美转发（Perfect Forwarding）是C++11引入的一种技术，它允许我们在函数模板中传递参数时，保持参数的原始类型（无论是左值还是右值），同时避免不必要的拷贝。这种技术主要利用了右值引用和std::forward函数模板。

为什么需要完美转发？

在C++中，函数参数默认是按值传递的，这意味着无论传递的是左值还是右值，都会发生拷贝。但是，有时候我们希望传递参数时能够保持其原始类型，以便能够利用移动语义（对于右值）来避免不必要的拷贝，从而提高性能。

如何实现完美转发？

完美转发主要通过以下两个关键点实现：

右值引用：使用T&&类型的参数来接收传递进来的参数。这种类型的参数可以绑定到任何类型的实参上，包括左值和右值。
std::forward：这是一个函数模板，用于将参数“完美”地转发给另一个函数。它能够保持参数的原始类型（左值或右值）。

示例

以下是一个简单的示例，展示了如何使用完美转发：

#include <iostream>
#include <utility> // for std::forward
void process(int& x) {
    std::cout << "Processing lvalue: " << x << std::endl;
}
void process(int&& x) {
    std::cout << "Processing rvalue: " << x << std::endl;
}
template<typename T>
void wrapper(T&& param) {
    process(std::forward<T>(param)); // 完美转发
}
int main() {
    int a = 10;
    wrapper(a);  // 传递左值
    wrapper(20); // 传递右值
    return 0;
}

在这个示例中：

wrapper函数模板接收一个类型为T&&的参数，这意味着它可以接收任何类型的实参。
在wrapper内部，我们使用std::forward<T>(param)将参数转发给process函数。std::forward会根据param的原始类型（左值或右值）来决定是进行左值转发还是右值转发。输出结果如下：

Processing lvalue: 10
Processing rvalue: 20

这表明wrapper函数成功地保持了参数的原始类型，并将它们“完美”地转发给了process函数。

完美转发在C++中有很多具体的应用场景，它允许开发者编写更通用、更高效的代码。以下是一些常见的应用场景：

泛型编程

在泛型编程中，我们经常需要编写可以接受任何类型参数的函数模板。完美转发允许这些函数模板在接收参数时保持参数的原始类型，从而可以正确地处理左值和右值。 示例：

template<typename T>
void universalFunction(T&& arg) {
    // 处理arg...
}

封装转发函数

有时我们需要封装一个函数，使其能够接受任意类型的参数，并将这些参数转发给另一个函数。完美转发可以实现这一点，而不丢失参数的原始类型信息。 示例：

void underlyingFunction(int& x) {
    // 处理左值...
}
void underlyingFunction(int&& x) {
    // 处理右值...
}
template<typename T>
void wrapperFunction(T&& arg) {
    underlyingFunction(std::forward<T>(arg));
}

智能指针

智能指针（如std::unique_ptr和std::shared_ptr）在内部使用完美转发来传递资源所有权。这允许智能指针在构造时接受左值或右值，从而实现资源的移动或拷贝。 示例：

std::unique_ptr<int> ptr1 = std::make_unique<int>(10);
std::unique_ptr<int> ptr2 = std::move(ptr1); // 移动所有权

容器操作

标准库容器（如std::vector）在插入元素时使用完美转发来避免不必要的拷贝。例如，push_back和emplace_back方法可以利用完美转发来插入元素。 示例：

std::vector<std::string> vec;
vec.push_back("Hello"); // 拷贝
vec.emplace_back(std::string("World")); // 移动

绑定器和解引用器

在函数绑定（如std::bind）和延迟调用（如std::function）的场景中，完美转发可以确保传递给绑定函数的参数保持其原始类型。 示例：

auto func = std::bind(underlyingFunction, std::placeholders::_1);
func(10); // 传递右值
int x = 20;
func(x); // 传递左值

高级工厂函数

在工厂模式中，完美转发可以用于创建对象，并根据传递的参数类型（左值或右值）来决定是拷贝还是移动资源。 示例：

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

自定义控制结构

在编写自定义的控制结构（如循环、条件语句等）时，完美转发可以确保传递给这些结构的参数保持其原始类型。 示例：

template<typename Func, typename... Args>
void customControlStructure(Func&& func, Args&&... args) {
    if (/* some condition */) {
        func(std::forward<Args>(args)...);
    }
}

“完美转发允许这些函数模板在接收参数时保持参数的原始类型” 这句话的意思是，在使用完美转发的情况下，当函数模板接收参数时，无论这些参数是左值还是右值，它们都能保持其原始的类型信息。这样，函数模板就可以根据参数的原始类型来决定如何处理这些参数，例如，对于右值参数，可以采用移动语义来避免不必要的拷贝，从而提高性能。

不使用完美转发会丢失原始类型吗？ 是的，如果不使用完美转发，那么在函数模板中接收参数时，可能会丢失参数的原始类型信息。具体来说：

按值传递：如果函数模板的参数是按值传递的，那么无论传递的是左值还是右值，都会被拷贝成一个新的左值。这样，原始的右值类型信息就会丢失，无法利用移动语义。
按引用传递：如果函数模板的参数是按引用传递的，那么可以保持参数的左值或右值属性，但需要编写两个重载版本（一个用于左值引用，一个用于右值引用），这会增加代码的复杂性。.

完美转发的优势：

保持原始类型：完美转发可以保持参数的原始类型信息，无论是左值还是右值。
通用性：通过使用函数模板和完美转发，可以编写通用的代码，处理各种类型的参数。
性能优化：利用移动语义，可以避免不必要的拷贝，提高程序的性能。

移动语义

背景

在 C++11 之前，资源管理主要依赖于拷贝构造函数和拷贝赋值运算符。然而，这种机制在处理一些资源（如动态内存、文件句柄等）时，效率并不高。为了解决这个问题，C++11 引入了移动语义。

移动语义的基本概念

移动语义允许将资源从一个对象“移动”到另一个对象，而不是复制。这样做的好处是可以提高资源管理的效率，减少不必要的内存分配和释放。

移动构造函数

移动构造函数是一种特殊的构造函数，用于初始化新对象，使其接管另一个对象的资源。移动构造函数的声明形式如下：

ClassName(ClassName&& other);

这里，ClassName&& 表示右值引用。右值引用可以绑定到即将被销毁的临时对象上，从而允许移动构造函数“窃取”这些资源。

移动赋值运算符

移动赋值运算符与移动构造函数类似，但用于将一个对象的资源移动到另一个已存在的对象。其声明形式如下：

ClassName& operator=(ClassName&& other);

右值引用

右值引用是移动语义的核心。它允许我们区分左值和右值，从而实现资源的移动。左值是具有持久性的对象，而右值是临时对象，如函数返回值或表达式结果。

std::move

std::move 是一个用于将左值转换为右值引用的函数。它并不真正移动任何资源，而是告诉编译器我们希望进行移动操作。例如：

ClassName obj1;
ClassName obj2 = std::move(obj1); // 调用移动构造函数

应用场景

动态内存管理：当对象包含指向动态分配内存的指针时，使用移动语义可以避免不必要的内存复制。
容器操作：如 std::vector 的 push_back 方法，当插入右值时，可以避免复制元素。
函数返回值：当函数返回一个局部对象时，使用移动语义可以避免复制该对象。

注意事项

资源管理：确保在移动构造函数和移动赋值运算符中正确管理资源，避免内存泄漏。
自赋值安全：移动赋值运算符应处理自赋值情况，以避免破坏对象状态。
兼容性：确保移动构造函数和移动赋值运算符与拷贝构造函数和拷贝赋值运算符兼容。

示例

以下是一个简单的示例，展示如何为包含动态内存的对象实现移动语义：

#include <iostream>
#include <string>
class MyString {
public:
    // 构造函数
    MyString(const char* str) {
        size = strlen(str);
        data = new char[size + 1];
        strcpy(data, str);
    }
    // 移动构造函数
    MyString(MyString&& other) noexcept : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }
    // 移动赋值运算符
    MyString& operator=(MyString&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }
    // 析构函数
    ~MyString() {
        delete[] data;
    }
    void print() const {
        std::cout << data << std::endl;
    }
private:
    char* data;
    size_t size;
};
int main() {
    MyString str1("Hello");
    MyString str2 = std::move(str1); // 调用移动构造函数
    str2.print(); // 输出 "Hello"
    MyString str3("World");
    str3 = std::move(str2); // 调用移动赋值运算符
    str3.print(); // 输出 "Hello"
    return 0;
}

在这个示例中，MyString 类实现了移动构造函数和移动赋值运算符，以高效地管理动态内存。

`std::move`的应用示例

如何在类对象中使用移动语义来优化性能

#include <iostream>
#include <vector>
#include <utility> // for std::move

using namespace std;

class MyClass {
public:
    vector<int> data;

    // 默认构造函数
    MyClass() {
        cout << "Default constructor" << endl;
    }

    // 移动构造函数
    MyClass(MyClass&& other) noexcept : data(std::move(other.data)) {
        cout << "Move constructor" << endl;
    }

    // 移动赋值运算符
    MyClass& operator=(MyClass&& other) noexcept {
        cout << "Move assignment operator" << endl;
        if (this != &other) {
            data = std::move(other.data);
        }
        return *this;
    }
};

MyClass createObject() {
    MyClass obj;
    obj.data.push_back(1);
    obj.data.push_back(2);
    obj.data.push_back(3);
    return obj;
}

int main() {
    MyClass obj1 = createObject(); // 使用移动构造函数
    MyClass obj2 = std::move(obj1); // 使用移动赋值运算符

    cout << "obj1 data size: " << obj1.data.size() << endl; // obj1 的数据已被转移
    cout << "obj2 data size: " << obj2.data.size() << endl; // obj2 拥有 obj1 的数据

    return 0;
}

std::move实现一个高效的swap函数

#include <utility> // for std::move

template <typename T>
void swap(T& a, T& b) {
    T temp = std::move(a); // 将a的状态转移到temp
    a = std::move(b);      // 将b的状态转移到a
    b = std::move(temp);   // 将temp的状态转移到b
}

这种方式和传统使用临时变量（temp）的方式的主要区别在于性能和资源管理：

性能：使用std::move的swap函数可以避免不必要的复制操作。在传统的方式中，对象的复制可能涉及到深拷贝，特别是当对象管理着资源（如动态分配的内存）时。而std::move通过转移资源的所有权来避免复制，这通常是一个更快的操作。
资源管理：当对象包含资源（如动态内存、文件句柄等）时，使用std::move可以确保资源正确地从一个对象转移到另一个对象，而不会发生资源的双重释放或者泄漏。在传统的方式中，资源的复制和释放可能会导致性能损失或者资源管理错误。
异常安全：使用std::move的swap函数在异常安全方面通常更好。因为移动操作通常不会抛出异常（除非移动构造函数或移动赋值运算符被显式定义为可能抛出异常），所以这种方式提供的swap函数在异常情况下更不容易出错。
适用性：使用std::move的swap函数适用于任何支持移动语义的类型，包括那些不支持拷贝语义但支持移动语义的类型（如某些只能移动不能复制的对象）。

从代码表面上看，使用std::move的swap函数和传统使用临时变量的swap函数都定义了一个临时变量，并且似乎都有额外的内存开销。然而，这里的区别在于对象的状态转移方式，而不是是否使用了临时变量。

在传统的方式中，每次赋值操作都可能涉及到对象的拷贝构造函数，如果对象包含大量数据或复杂资源，这将导致显著的性能开销。

在使用std::move的方式中，赋值操作涉及到的是对象的移动构造函数或移动赋值运算符。这些函数的设计目的是转移对象的状态而不是复制它，因此它们通常不涉及深拷贝，而是进行浅拷贝或资源所有权的转移。这意味着性能开销通常远小于深拷贝。

关键区别：

拷贝 vs. 移动：传统方式中发生的是拷贝，而std::move方式中发生的是移动。移动操作通常比拷贝操作更高效，尤其是对于资源密集型的对象。
资源管理：移动语义允许更安全的资源管理，因为它减少了资源复制和释放的次数，从而降低了出错的可能性。 关于临时变量的内存开销：
在两种方式中，临时变量的内存开销是相似的，但是这个开销通常很小，特别是与可能避免的深拷贝开销相比。
对于某些类型，编译器可能能够优化临时变量的使用，例如通过使用返回值优化（RVO）或命名返回值优化（NRVO）。总之，虽然两种方式都使用了临时变量，但使用std::move的swap函数在性能和资源管理方面通常更优，因为它利用了移动语义来减少不必要的拷贝操作。

Java多线程

Fri, 14 Mar 2025 00:00:00 GMT

线程

实现多线程方式一：继承Thread类

方法介绍

方法名说明

void run() 在线程开启后，此方法将被调用执行

void start() 使此线程开始执行，Java虚拟机会调用run方法()
实现步骤
- 定义一个类MyThread继承Thread类
- 在MyThread类中重写run()方法
- 创建MyThread类的对象
- 启动线程

方法名	说明
void run()	在线程开启后，此方法将被调用执行
void start()	使此线程开始执行，Java虚拟机会调用run方法()

代码演示

public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
      //start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
        my1.start();
        my2.start();
  }
}

两个小问题
- 为什么要重写run()方法？
  
  因为run()是用来封装被线程执行的代码
- run()方法和start()方法的区别？
  
  run()：封装线程执行的代码，直接调用，相当于普通方法的调用
  
  start()：启动线程；然后由JVM调用此线程的run()方法
缺点：单继承，不能再继承其它类

实现多线程方式二：实现Runnable接口

Thread构造方法

方法名说明

Thread(Runnable target) 分配一个新的Thread对象

Thread(Runnable target, String name) 分配一个新的Thread对象
实现步骤
- 定义一个类MyRunnable实现Runnable接口
- 在MyRunnable类中重写run()方法
- 创建MyRunnable类的对象
- 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
- 启动线程

方法名	说明
Thread(Runnable target)	分配一个新的Thread对象
Thread(Runnable target, String name)	分配一个新的Thread对象

代码演示

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class MyRunnableDemo {
    public static void main(String[] args) {
        //创建MyRunnable类的对象
        MyRunnable my = new MyRunnable();

        //创建Thread类的对象，把MyRunnable对象作为构造方法的参数
        //Thread(Runnable target)
//        Thread t1 = new Thread(my);
//        Thread t2 = new Thread(my);
        //Thread(Runnable target, String name)
        Thread t1 = new Thread(my,"坦克");
        Thread t2 = new Thread(my,"飞机");

        //启动线程
        t1.start();
        t2.start();
    }
}

在Java中，Thread.yield() 是一个静态方法，用于使当前正在执行的线程让出CPU时间片，允许其他线程（如果有）在当前线程之前被调度执行。调用yield()方法的线程会从运行状态（Running）转到可运行状态（Runnable），即就绪状态，并有可能在下一个线程调度周期中被再次选中执行。 yield()方法的主要目的是提高线程之间的执行效率，它是一种非阻塞的线程调度方式。当当前线程认为它需要让出CPU以允许其他线程运行时，可以调用此方法。这通常用于实现某种程度的线程间协作，尤其是在多处理器系统中。然而，需要注意的是，yield()方法的行为依赖于具体的线程调度器实现，不同的操作系统和JVM实现可能会有不同的行为。因此，yield()方法的效果可能并不总是如预期的那样明显或一致。在实际应用中，yield()方法的使用并不常见，因为它的行为可能难以预测，并且通常有更好的方法来实现线程间的协作和同步，例如使用wait()/notify()机制或java.util.concurrent包中的高级并发工具。

实现多线程方式三: 实现Callable接口

第一、第二的方式没办法获取到多线程运行的结果，本方法可以。

方法介绍

方法名	说明
V call()	计算结果，如果无法计算结果，则抛出一个异常
FutureTask(Callable<V> callable)	创建一个 FutureTask，一旦运行就执行给定的 Callable
V get()	如有必要，等待计算完成，然后获取其结果

实现步骤
- 定义一个类MyCallable实现Callable接口
- 在MyCallable类中重写call()方法
- 创建MyCallable类的对象
- 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
- 创建Thread类的对象，把FutureTask对象作为构造方法的参数
- 启动线程
- 再调用get方法，就可以获取线程结束之后的结果。

代码演示

public class MyCallable implements Callable<Integer> {
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        //返回值就表示线程运行完毕之后的结果
        return sum;
    }
}
public class demoCallable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程开启之后需要执行里面的call方法
      myCallable mc = new myCallable();
        //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
      FutureTask<Integer> ft = new FutureTask<>(mc);
        //创建线程对象
        Thread t1 = new Thread(ft);
      //开启线程
        t1.start();
        int s = ft.get();
      System.out.println(s);
    }
}

三种实现方式的对比
- 实现Runnable、Callable接口
  - 好处: 扩展性强，实现该接口的同时还可以继承其他的类
  - 缺点: 编程相对复杂，不能直接使用Thread类中的方法，如果需要使用，需要现获取到Thread的对象(通过静态方法)
- 继承Thread类
  - 好处: 编程比较简单，可以直接使用Thread类中的方法
  - 缺点: 可以扩展性较差，不能再继承其他的类

设置和获取线程名称

方法介绍

方法名	说明
void setName(String name)	将此线程的名称更改为等于参数name
String getName()	返回此线程的名称
Thread currentThread()	返回对当前正在执行的线程对象的引用

代码演示

public class MyThread extends Thread {
    public MyThread() {}
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+":"+i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();

        //void setName(String name)：将此线程的名称更改为等于参数 name
        my1.setName("高铁");
        my2.setName("飞机");

        //Thread(String name)
        MyThread my1 = new MyThread("高铁");
        MyThread my2 = new MyThread("飞机");

        my1.start();
        my2.start();

        //static Thread currentThread() 返回对当前正在执行的线程对象的引用
        System.out.println(Thread.currentThread().getName());
    }
}

Thread类中的常用方法

下面是一个表格，列出了Java中Thread类的一些常用方法，包括方法的名称、描述和简单的用法示例：

方法名称	描述	用法示例
`start()`	启动线程，调用线程的`run()`方法。	`thread.start();`
`run()`	线程的执行体，包含线程要执行的代码。	`public void run() { // code to execute }`
`join()`	等待调用该方法的线程结束（进程插队）。	`thread.join();`
`static void sleep(long millis)`	使当前线程暂停执行指定的时间（毫秒）。	`Thread.sleep(1000);` // 暂停1秒
`interrupt()`	中断线程，如果线程处于阻塞状态，会抛出`InterruptedException`。	`thread.interrupt();`
`isAlive()`	检查线程是否处于活动状态。	`if (thread.isAlive()) { // code }`
`getName()`	获取线程的名称。	`String name = thread.getName();`
`setName(String name)`	设置线程的名称。	`thread.setName("MyThread");`
`getPriority()`	获取线程的优先级。	`int priority = thread.getPriority();`
`setPriority(int newPriority)`	设置线程的优先级。	`thread.setPriority(Thread.MAX_PRIORITY);`
`currentThread()`	获取当前正在执行的线程对象。	`Thread currentThread = Thread.currentThread();`
`isDaemon()`	检查线程是否为守护线程。	`if (thread.isDaemon()) { // code }`
`setDaemon(boolean on)`	将线程设置为守护线程或用户线程。	`thread.setDaemon(true);` // 设置为守护线程
`yield()`	让出线程	可以让线程的调度更加均衡
`static Thread currentThread()`	获取到当前线程的对象
请注意，这个表格并不包含`Thread`类中的所有方法，只是列出了一些常用的方法。此外，使用这些方法时需要考虑到线程安全、同步等问题，以避免潜在的并发问题。

线程优先级

线程调度
- 两种调度方式
  - 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
  - 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些
- Java使用的是抢占式调度模型
- 随机性
  
  假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

优先级相关方法

方法名	说明
final int getPriority()	返回此线程的优先级
final void setPriority(int newPriority)	更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10

代码演示

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
        return "线程执行完毕了";
    }
}
public class Demo {
    public static void main(String[] args) {
        //优先级: 1 - 10 默认值:5
        MyCallable mc = new MyCallable();

        FutureTask<String> ft = new FutureTask<>(mc);

        Thread t1 = new Thread(ft);
        t1.setName("飞机");
        t1.setPriority(10);
        //System.out.println(t1.getPriority());//5
        t1.start();

        MyCallable mc2 = new MyCallable();

        FutureTask<String> ft2 = new FutureTask<>(mc2);

        Thread t2 = new Thread(ft2);
        t2.setName("坦克");
        t2.setPriority(1);
        //System.out.println(t2.getPriority());//5
        t2.start();
    }
}

守护线程

相关方法

方法名说明

void setDaemon(boolean on) 将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

方法名	说明
void setDaemon(boolean on)	将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

代码演示

public class MyThread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + "---" + i);
        }
    }
}
public class MyThread2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "---" + i);
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();

        t1.setName("A");
        t2.setName("B");

        //把第二个线程设置为守护线程
        //当普通线程执行完之后,那么守护线程也没有继续运行下去的必要了.
        t2.setDaemon(true);

        t1.start();
        t2.start();
    }
}

**守护线程（Daemon Thread）**是一种特殊的线程，它的主要作用是服务于其他线程，并且在程序中不会阻止JVM的退出。当所有的非守护线程（也称为用户线程）都执行完毕后，无论守护线程是否还在运行，JVM都会退出。 守护线程的用途：

后台任务：守护线程通常用于执行一些后台任务，如垃圾回收、内存管理等，这些任务不需要用户显式地干预。
辅助功能：它们可以用于实现一些辅助功能，比如在服务器应用程序中，守护线程可以用来监控内存使用情况或清理临时文件。
非关键任务：任何不需要在程序结束后继续执行的任务都可以作为守护线程运行。
定时任务：守护线程可以用于执行定时任务，比如定时备份、日志记录等。 守护线程的特点：

生命周期：守护线程的生命周期依赖于用户线程，当所有的用户线程结束时，JVM会退出，无论守护线程是否完成。
中断：守护线程在JVM退出时会被中断，因此不应该在守护线程中执行重要的、不能中断的任务。
资源释放：由于守护线程可能在任何时候被中断，因此它们不应该持有任何需要显式释放的资源，如打开的文件句柄或数据库连接。 如何创建守护线程： 在Java中，可以通过调用Thread对象的setDaemon(true)方法将线程设置为守护线程。这个方法必须在线程启动之前调用。

Thread daemonThread = new Thread(new Runnable() {
    public void run() {
        // 守护线程的任务
    }
});
daemonThread.setDaemon(true);
daemonThread.start();

注意事项：

不要在守护线程中执行重要的业务逻辑，因为它们可能会在没有完成任务的情况下被终止。
守护线程不应该访问共享资源，除非采取了适当的同步措施，以避免数据不一致或资源泄露。
守护线程通常用于执行那些即使不完成也不会对程序造成重大影响的任务。

线程同步

在Java中，多线程同步可以通过多种方式实现，主要包括使用synchronized关键字、Lock接口及其实现类（如ReentrantLock）、以及使用原子类等。

使用synchronized实现线程同步

假设有一个共享的资源，例如一个计数器，多个线程需要对其进行增加操作。为了保证线程安全，可以使用synchronized关键字来同步访问这个共享资源。

public class syncDemo1 {
    public class Counter {
        private int count = 0;
        // 同步方法
        public synchronized void increment() {
            System.out.println(Thread.currentThread().getName() + ": " + ++count);
        }
        public int getCount() {
            return count;
        }
    }

    public static void main(String[] args) {
        syncDemo1 demo = new syncDemo1();
        Counter counter = demo.new Counter();
        // 创建多个线程
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 100; j++) {
                        counter.increment();
                    }
                }
            }).start();
        }
        // 等待所有线程执行完毕
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 输出最终的计数结果
        System.out.println("Final count is " + counter.getCount());
    }
}

使用synchronized代码块实现线程同步

public class Counter {
    static int count = 0;
    // 同步方法
    public void increment() {
        synchronized (this) {
            // 非静态使用this，静态使用ClassName.class
            System.out.println(Thread.currentThread().getName() + ": " + ++count);
        }
    }
    public int getCount() {
        return count;
    }
}

public class syncDemo2 {

    public static void main(String[] args) {
        syncDemo2 demo = new syncDemo2();
        // 创建多个线程
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Counter counter = new Counter();
                    for (int j = 0; j < 100; j++) {
                        counter.increment();
                    }
                }
            }).start();
        }
        // 等待所有线程执行完毕
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

ReadWriteLock 是 Java 中的一种高级线程同步机制，它允许多个读线程同时访问资源，但在写线程访问时，所有读线程和其他写线程都会被阻塞。这种锁适用于读多写少的场景，可以提高并发性能。 ReadWriteLock 接口的主要实现是 ReentrantReadWriteLock。下面通过一个例子来展示如何使用 ReadWriteLock。

`ReentrantLock`

ReentrantLock 是 Java 中 java.util.concurrent.locks 包下的一种可重入锁，它提供了与 synchronized 关键字类似的同步功能，但功能更强大、更灵活。以下是 ReentrantLock 的一些基本用法：

创建 `ReentrantLock` 实例

ReentrantLock lock = new ReentrantLock();

尽量使用static，确保锁唯一

加锁

使用 lock() 方法获取锁：

lock.lock();
try {
    // 执行需要同步的代码
} finally {
    // 释放锁
    lock.unlock();
}

解锁

使用 unlock() 方法释放锁，通常放在 finally 块中以确保锁被释放：

finally {
    lock.unlock();
}

可中断的锁获取

使用 lockInterruptibly() 方法可以在获取锁的过程中响应中断：

try {
    lock.lockInterruptibly();
    try {
        // 执行需要同步的代码
    } finally {
        lock.unlock();
    }
} catch (InterruptedException e) {
    // 当前线程被中断
}

尝试非阻塞获取锁

使用 tryLock() 方法尝试获取锁，无论成功与否立即返回：

if (lock.tryLock()) {
    try {
        // 执行需要同步的代码
    } finally {
        lock.unlock();
    }
} else {
    // 获取锁失败
}

带有超时时间的锁获取

使用 tryLock(long timeout, TimeUnit unit) 方法在指定时间内尝试获取锁：

try {
    if (lock.tryLock(1, TimeUnit.SECONDS)) {
        try {
            // 执行需要同步的代码
        } finally {
            lock.unlock();
        }
    } else {
        // 获取锁失败
    }
} catch (InterruptedException e) {
    // 当前线程被中断
}

公平锁

创建 ReentrantLock 时可以指定为公平锁，公平锁倾向于将锁赋予等待时间最长的线程：

ReentrantLock fairLock = new ReentrantLock(true);

条件变量

ReentrantLock 可以与 Condition 对象一起使用，以实现线程之间的等待/通知机制：

Condition condition = lock.newCondition();
// 等待
lock.lock();
try {
    condition.await();
    // 执行后续操作
} finally {
    lock.unlock();
}



// 通知
lock.lock();
try {
    condition.signal();
    // 或者通知所有等待的线程：condition.signalAll();
} finally {
    lock.unlock();
}

注意事项

务必在 finally 块中释放锁，以避免死锁。
不要在持有锁的情况下调用 await()，否则可能导致死锁。
ReentrantLock 是可重入的，即同一个线程可以多次获取同一把锁，而不会造成死锁。
性能考虑：ReentrantLock 在某些情况下可能比 synchronized 更高效，尤其是在高竞争环境下。通过以上基本用法，可以灵活地控制多线程之间的同步和协作。ReentrantLock 提供的强大功能使其在多线程编程中非常有用。

`ReadWriteLock`

假设我们有一个共享的资源，例如一个地图（Map），多个线程可能同时读取这个地图，但写入操作需要独占访问。

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class SharedMap {
    private final Map<String, String> map = new HashMap<>();
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    // 读操作
    public String get(String key) {
        lock.readLock().lock();
        try {
            return map.get(key);
        } finally {
            lock.readLock().unlock();
        }
    }
    // 写操作
    public void put(String key, String value) {
        lock.writeLock().lock();
        try {
            map.put(key, value);
        } finally {
            lock.writeLock().unlock();
        }
    }
    // 其他操作...
}
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        SharedMap sharedMap = new SharedMap();
        // 创建多个读线程
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                System.out.println("Reading: " + sharedMap.get("key"));
            }).start();
        }
        // 创建一个写线程
        new Thread(() -> {
            sharedMap.put("key", "value");
            System.out.println("Written: value");
        }).start();
    }
}

解释

ReadWriteLock 接口：定义了获取读锁和写锁的方法。
ReentrantReadWriteLock：ReadWriteLock 接口的一个实现，提供了可重入的读写锁。
readLock() 和 writeLock()：分别用于获取读锁和写锁。
lock() 和 unlock()：用于锁定和解锁。在 SharedMap 类中，我们定义了 get 和 put 方法，分别用于读取和写入操作。读操作使用读锁，允许多个线程同时进行；写操作使用写锁，确保在写入时没有其他读或写操作。在 ReadWriteLockDemo 类的 main 方法中，我们创建了多个读线程和一个写线程来演示 ReadWriteLock 的使用。

注意事项

在使用 ReadWriteLock 时，要确保锁的获取和释放总是在 try-finally 块中进行，以防止在发生异常时锁未被释放。
读锁不支持条件变量，如果需要在读锁下使用条件变量，可以考虑其他同步机制。
写锁是独占的，即使没有读线程，其他写线程也会被阻塞。通过使用 ReadWriteLock，可以有效地提高读多写少场景下的并发性能。

死锁

概述

线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行
什么情况下会产生死锁
1. 资源有限
2. 同步嵌套

代码演示

public class Demo {
    public static void main(String[] args) {
        Object objA = new Object();
        Object objB = new Object();

        new Thread(()->{
            while(true){
                synchronized (objA){
                    //线程一
                    synchronized (objB){
                        System.out.println("A");
                    }
                }
            }
        }).start();

        new Thread(()->{
            while(true){
                synchronized (objB){
                    //线程二
                    synchronized (objA){
                        System.out.println("B");
                    }
                }
            }
        }).start();
    }
}

等待唤醒机制

Java多线程中的等待唤醒机制是一种用于线程间通信的重要机制，它允许线程在某些条件下挂起执行，并在条件满足时被唤醒继续执行。这种机制主要基于Object类中的wait(), notify(), 和notifyAll()方法实现。

`wait()`, `notify()`, `notifyAll()`方法

wait()方法：
- 调用wait()方法的线程会释放它持有的对象锁，并进入等待状态，直到其他线程调用同一个对象的notify()或notifyAll()方法。
- wait()方法可以带有一个超时参数，指定线程等待的最长时间。
- wait()方法必须在同步代码块或同步方法中调用，否则会抛出IllegalMonitorStateException异常。
notify()方法：
- 调用notify()方法的线程会随机唤醒一个正在等待该对象锁的线程。
- 如果没有线程在等待，则notify()方法不执行任何操作。
- notify()方法也必须在同步代码块或同步方法中调用。
notifyAll()方法：
- 调用notifyAll()方法的线程会唤醒所有正在等待该对象锁的线程。
- 这些线程将竞争对象锁，获得锁的线程将继续执行。

等待唤醒机制的工作原理

线程进入等待状态：
- 线程在执行过程中遇到wait()方法调用时，会释放它持有的对象锁，并进入等待状态。
- 其他线程可以获取该对象锁并执行同步代码块或同步方法。
线程被唤醒：
- 当其他线程调用同一个对象的notify()或notifyAll()方法时，等待的线程有机会被唤醒。
- 被唤醒的线程将重新竞争对象锁，获得锁的线程将继续执行。
线程继续执行：
- 获得对象锁的线程从wait()方法返回，继续执行后续代码。

示例代码

以下是一个简单的示例，展示了等待唤醒机制的使用：

public class WaitNotifyExample {
    private static final Object lock = new Object();
    private static boolean condition = false;
    public static void main(String[] args) {
        Thread waiter = new Thread(new Waiter());
        Thread notifier = new Thread(new Notifier());
        waiter.start();
        notifier.start();
    }
    static class Waiter implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                while (!condition) {
                    try {
                        System.out.println("Waiter is waiting...");
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("Waiter is awake!");
            }
        }
    }
    static class Notifier implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                System.out.println("Notifier is notifying...");
                condition = true;
                lock.notifyAll();
            }
        }
    }
}

在这个示例中，Waiter线程在条件不满足时进入等待状态，Notifier线程在改变条件后唤醒等待的线程。

注意事项

正确使用条件变量：在wait()方法的使用中，通常需要配合一个条件变量来判断是否满足继续执行的条件。在上面的示例中，condition就是这样一个变量。
避免虚假唤醒：wait()方法可能会因为意外的原因被唤醒（虚假唤醒），因此推荐使用while循环来检查条件，而不是if语句。
同步代码块：wait(), notify(), notifyAll()方法必须在同步代码块或同步方法中调用，以确保线程安全。

与其他并发机制的对比

与sleep()方法的区别：sleep()方法不会释放对象锁，只是让当前线程暂停执行一段时间。
与Lock和Condition的区别：Lock和Condition提供了更灵活的锁定和等待唤醒机制，但使用起来相对复杂。理解并正确使用Java多线程中的等待唤醒机制是开发高效、线程安全的应用程序的关键。

阻塞队列实现

阻塞队列（BlockingQueue）是Java并发包（java.util.concurrent）中提供的一种线程安全的队列，它支持多线程间的阻塞式数据交换。使用阻塞队列可以简化多线程编程中的等待唤醒机制，因为它内部已经实现了这些机制。下面是如何使用阻塞队列来实现等待唤醒机制的示例：

阻塞队列的基本操作

put(E e)：将元素插入队列，如果队列已满，则阻塞直到有空间可用。
take()：从队列中移除并返回头部元素，如果队列为空，则阻塞直到有元素可用。
offer(E e)：将元素插入队列，如果队列已满，则返回false，不会阻塞。
poll()：从队列中移除并返回头部元素，如果队列为空，则返回null，不会阻塞。
peek()：返回队列头部元素，但不移除，如果队列为空，则返回null。

使用阻塞队列实现生产者-消费者模式

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class ProducerConsumerExample {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(5); // 创建容量为5的阻塞队列
        Thread producer = new Thread(new Producer(queue));
        Thread consumer = new Thread(new Consumer(queue));
        producer.start();
        consumer.start();
    }
}
class Producer implements Runnable {
    private BlockingQueue<Integer> queue;
    public Producer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                System.out.println("Produced: " + i);
                queue.put(i); // 如果队列满，会阻塞等待
                Thread.sleep(1000); // 模拟生产时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Consumer implements Runnable {
    private BlockingQueue<Integer> queue;
    public Consumer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }
    @Override
    public void run() {
        while (true) {
            try {
                Integer taken = queue.take(); // 如果队列空，会阻塞等待
                System.out.println("Consumed: " + taken);
                Thread.sleep(1000); // 模拟消费时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

工作原理

生产者线程：生产者尝试将产品放入阻塞队列。如果队列已满，put()方法会阻塞生产者线程，直到队列中有可用空间。
消费者线程：消费者尝试从阻塞队列中取出产品。如果队列为空，take()方法会阻塞消费者线程，直到队列中有产品可取。通过使用阻塞队列，我们不需要显式地使用wait(), notify(), notifyAll()方法来管理线程的等待和唤醒，因为阻塞队列内部已经帮我们实现了这些复杂的同步控制。

优点

简化代码：使用阻塞队列可以大大简化多线程编程的复杂性，避免直接处理线程同步和唤醒的细节。
线程安全：阻塞队列是线程安全的，可以在多线程环境中安全使用。
灵活性和可扩展性：Java提供了多种类型的阻塞队列，如ArrayBlockingQueue, LinkedBlockingQueue, PriorityBlockingQueue等，可以根据具体需求选择合适的队列实现。通过阻塞队列实现的生产者-消费者模式是并发编程中的经典模式，它能够有效地解耦生产者和消费者，提高程序的并发性能和可维护性。

线程池

Java的线程池是一种用于管理和复用线程的机制，它可以有效地提高程序的性能和响应速度。线程池的核心思想是预先创建一定数量的线程，这些线程在需要执行任务时被分配任务，执行完毕后并不销毁，而是返回线程池中等待下一次的任务分配。

线程池的好处

降低资源消耗：通过复用已存在的线程，减少线程创建和销毁所带来的开销。
提高响应速度：任务到达时，无需等待线程创建即可立即执行。
提高线程的可管理性：线程池可以统一管理、分配、调优和监控线程。
提供更多更强大的功能：线程池支持定时、周期性执行任务等功能。

Java中的线程池实现

在Java中，线程池主要通过java.util.concurrent包中的Executor框架实现。Executor是一个接口，它定义了执行任务的单一方法execute(Runnable command)。其子接口ExecutorService添加了更多管理线程池的方法，如shutdown()、submit()等。 ThreadPoolExecutor是ExecutorService的一个实现，它提供了线程池的具体实现。另外，Executors工厂类提供了几种常见配置的线程池的快速实现方法。

常见的线程池类型

FixedThreadPool：固定数量的线程池。适用于负载较重的服务器。
CachedThreadPool：一个根据需要创建新线程的线程池。适用于执行大量短生命周期的异步任务（最多到int上限的线程）。
SingleThreadExecutor：单线程的Executor。保证所有任务都在同一线程中按顺序执行。
ScheduledThreadPool：用于执行定时任务和周期性任务。

ThreadPoolExecutor的重要参数

corePoolSize：核心线程数，即线程池中始终存活的线程数。
maximumPoolSize：最大线程数，线程池中允许的最大线程数。
keepAliveTime：非核心线程的空闲存活时间。
unit：keepAliveTime的时间单位。
workQueue：工作队列，用于存放任务。
threadFactory：线程工厂，用于创建线程。
rejectedExecutionHandler：拒绝策略，当任务太多无法处理时，如何拒绝新任务。

拒绝策略

以下均为ThreadPoolExecutor的子类。

AbortPolicy：直接抛出异常，默认策略。
CallerRunsPolicy：调用线程自己执行该任务。
DiscardPolicy：直接丢弃任务，不做任何处理。
DiscardOldestPolicy：丢弃队列中最老的任务。

使用示例

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        
        // 提交任务
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + " is running-" + i);
                }
            });
        }
        
        // 关闭线程池
        fixedThreadPool.shutdown();
    }
}

自定义线程池：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MyThreadPoolDemo3 {
//    参数一：核心线程数量
//    参数二：最大线程数
//    参数三：空闲线程最大存活时间
//    参数四：时间单位
//    参数五：任务队列
//    参数六：创建线程工厂
//    参数七：任务的拒绝策略
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
            2,
            5,
            2,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(10), // LinkedBlockingQueue等阻塞队列
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy()
        );
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());

        pool.shutdown();
    }
}

注意事项

合理配置线程池大小：根据任务的性质和系统资源进行配置。
注意任务与线程的匹配：避免线程空闲或过度竞争。
正确关闭线程池：避免程序无法正常结束。

手动实现线程池

实现思路：

创建一个线程池类(ThreadPool)
在该类中定义两个成员变量poolSize(线程池初始化线程的个数) , BlockingQueue<Runnable>(任务容器)
通过构造方法来创建两个线程对象(消费者线程)，并且启动
使用内部类的方式去定义一个线程类(TaskThread),可以提供一个构造方法用来初始化线程名称
两个消费者线程需要不断的从任务容器中获取任务，如果没有任务，则线程处于阻塞状态。
提供一个方法(submit)向任务容器中添加任务
定义测试类进行测试

线程池类

public class ThreadPool {

    // 初始化线程个数
    private static final int DEFAULT_POOL_SIZE = 2 ;

    // 在该类中定义两个成员变量poolSize(线程池初始化线程的个数) , BlockingQueue<Runnable>(任务容器)
    private int poolSize = DEFAULT_POOL_SIZE ;
    private BlockingQueue<Runnable> blockingQueue = new LinkedBlockingQueue<Runnable>() ;

    // 无参构造方法
    public ThreadPool(){
        this.initThread();
    }

    // 有参构造方法，通过构造方法来创建两个线程对象(消费者线程)，并且启动
    public ThreadPool(int poolSize) {
        if(poolSize > 0) {
            this.poolSize = poolSize ;
        }
        this.initThread();
    }

    // 初始化线程方法
    public void initThread(){
        for(int x = 0 ; x < poolSize ; x++) {
            new TaskThread("线程--->" + x).start();
        }
    }

    // 提供一个方法(submit)向任务容器中添加任务
    public void submit(Runnable runnable) {

        try {
            blockingQueue.put(runnable);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    // 使用内部类的方式去定义一个线程类
    public class TaskThread extends Thread {

        // 提供一个构造方法，用来初始化线程名称
        public TaskThread(String name) {
            super(name);
        }

        @Override
        public void run() {

            while(true) {

                try {

                    // 两个消费者线程需要不断的从任务容器中获取任务，如果没有任务，则线程处于阻塞状态。
                    Runnable task = blockingQueue.take();
                    task.run();

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }

        }
    }

}

测试类

public class ThreadPoolDemo01 {

    public static void main(String[] args) {

        // 创建线程池对象,无参构造方法创建
        // ThreadPool threadPool = new ThreadPool();
        ThreadPool threadPool = new ThreadPool(5);

        // 提交任务
        for(int x = 0 ; x < 10 ; x++) {
            threadPool.submit( () -> {
                System.out.println(Thread.currentThread().getName() + "---->>>处理了任务");
            });
        }

    }

}

线程数量设置

获取操作系统分配资源：最大并行数(Maximum parallel quantity, MPQ)

int count = Runtime.getRuntime().availableProcessors();
System.out.println(count);
// 16

CPU密集型：$$MPQ+1 $$（某个出问题，后面的可以补上，所以+1）
IO密集型：$$ MPQ * CPU_{utilization} * \frac{Computation_{time} +Waiting_{time}}{Computation_{time}}$$

例如：4核8线程：$$8 * 100% * \frac{4_s}{2_s} = 16 $$

（需要通过其它工具计算得到计算时间和IO的等待时间）

线程的状态

线程状态	具体含义
NEW	一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程象，没有线程特征。
RUNNABLE	当我们调用线程对象的start方法，那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程，线程一经启动并不是立即得到执行，线程的运行与否要听令与CPU的调度，那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格，但是并没有真正的执行起来而是在等待CPU的度。
BLOCKED	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
WAITING	一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种，分别是调用Object.wait()、join()方法。处于等待状态的线程，正在等待其他线程去执行一个特定的操作。例如：因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll()；一个因为join()而等待的线程正在等待另一个线程结束。
TIMED_WAITING	一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种，分别是：Thread.sleep(long)，Object.wait(long)、join(long)。
TERMINATED	一个完全运行完成的线程的状态。也称之为终止状态、结束状态

volatile关键字

基本概念

在Java中，volatile是一个用于修饰变量的关键字。当一个变量被声明为volatile时，它具备了两层主要含义：

可见性：对一个volatile变量的读写操作，总是能直接反映到主内存中。换句话说，一个线程对volatile变量的修改，对其他线程是立即可见的。
有序性：volatile可以防止指令重排序。在多线程环境中，为了提高执行效率，编译器和处理器可能会对指令进行重排序。但使用volatile后，可以保证其前后操作的执行顺序。

工作原理

volatile的工作原理主要基于内存屏障（Memory Barrier）：

写屏障：在写入volatile变量后，会插入一个写屏障，确保该变量的新值对其他线程立即可见。
读屏障：在读取volatile变量前，会插入一个读屏障，确保读取的是该变量的最新值。通过这两道屏障，volatile实现了其可见性和有序性的保证。

使用场景

volatile主要适用于以下场景：

状态标记：用于标记某个状态，如线程的启动、停止等。
```
volatile boolean running = true;
while (running) {
    // do something
}
```

双重检查锁定：在单例模式中，用于确保只创建一个实例。

public class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

局限性

尽管volatile很有用，但它也有局限性：

不保证原子性：volatile不能保证复合操作（如自增、自减）的原子性。
```
volatile int count = 0;
count++; // 这个操作不是原子性的
```
不适合复杂的状态管理：对于复杂的状态管理，使用volatile可能会变得复杂且难以维护。

与synchronized的区别

volatile和synchronized都是Java中用于多线程同步的关键字，但它们有明显的区别：

功能：volatile主要保证可见性和有序性，而synchronized还可以保证原子性。
使用方式：volatile用于修饰变量，而synchronized可以用于修饰方法或代码块。
性能：通常情况下，volatile的性能优于synchronized，因为它不会引入线程阻塞。

Java的动态代理

Fri, 14 Mar 2025 00:00:00 GMT

Java中的动态代理是一种强大的机制，允许在运行时创建接口的代理实例。这种代理实例能够动态地拦截对接口方法的调用，从而可以在调用前后添加自定义的逻辑，而不需要修改原有的代码。动态代理在AOP（面向切面编程）、远程方法调用、事务管理等领域有着广泛的应用。

动态代理的基本概念

代理对象：在运行时创建的用于替代真实对象的代理。 InvocationHandler：一个接口，其实现类负责处理代理对象的方法调用。每个代理实例都有一个关联的InvocationHandler。 Proxy类：Java提供的用于创建动态代理的类，它有一个静态方法newProxyInstance，用于生成代理对象。

创建动态代理的步骤

定义接口：首先定义一个或多个接口，代理类将会实现这些接口。

public interface MyInterface {
    void doSomething();
}

public class MyInterfaceImpl implements MyInterface{
    ...
        void doSomething();
    ...
}

实现InvocationHandler：创建一个实现InvocationHandler接口的类，该类中的invoke方法将会在代理对象的方法被调用时执行。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class MyInvocationHandler implements InvocationHandler {
    private Object target; // 真实对象
    public MyInvocationHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            /*
             * 参数一：代理的对象
             * 参数二：要运行的方法,如果有多个,可以都写在数组中
             * 参数三：调用方法时，传递的实参
             * */
        // 在调用真实对象的方法前可以添加自定义逻辑
        System.out.println("Before method execution");
        // 调用真实对象的方法
        Object result = method.invoke(target, args);
        // 在调用真实对象的方法后可以添加自定义逻辑
        System.out.println("After method execution");
        return result;
    }
}

创建代理对象：使用Proxy.newProxyInstance方法创建代理对象。

public class ProxyDemo {
    public static void main(String[] args) {
        MyInterface realObject = new MyInterfaceImpl();
        MyInvocationHandler handler = new MyInvocationHandler(realObject);
        // 创建代理对象
        MyInterface proxyObject = (MyInterface) Proxy.newProxyInstance(
            MyInterface.class.getClassLoader(),
            new Class<?>[] {MyInterface.class},
            handler // 用来指定生成的代理对象要干什么事情, 可以直接写匿名类new InvocationHandler(){}
        );
        // 通过代理对象调用方法
        proxyObject.doSomething();
    }
}

在这个例子中，MyInterfaceImpl是MyInterface的一个实现类。

动态代理的工作原理

当通过代理对象调用方法时，会调用InvocationHandler的invoke方法。在这个方法中，可以添加自定义的逻辑，然后调用真实对象的方法。invoke方法的参数包括：

proxy：代理对象本身。
method：被调用的方法对象。
args：方法调用时传入的参数数组。

动态代理的优势

动态创建：代理类在运行时动态创建，不需要手动编写代理类。
解耦：通过代理可以添加额外的逻辑，而不需要修改原有的代码，实现了关注点的分离。
灵活：可以在运行时决定代理的行为。

动态代理的局限性

只能代理接口：Java的动态代理只能为接口创建代理，不能为具体的类创建代理。
性能开销：相比于直接调用，通过代理调用会有额外的性能开销。

应用场景

AOP：在Spring等框架中，动态代理用于实现AOP，例如事务管理、日志记录等。
远程方法调用：在RMI（远程方法调用）中，动态代理用于代表远程对象。
数据绑定和校验：在Web应用中，动态代理可以用于数据绑定和校验。总之，Java中的动态代理是一种非常灵活和强大的机制，能够在不修改原有代码的情况下，动态地添加额外的逻辑。

黑马的案例

public class Test {
    public static void main(String[] args) {
    /*
        需求：
            外面的人想要大明星唱一首歌
             1. 获取代理的对象
                代理对象 = ProxyUtil.createProxy(大明星的对象);
             2. 再调用代理的唱歌方法
                代理对象.唱歌的方法("只因你太美");
     */
        //1. 获取代理的对象
        BigStar bigStar = new BigStar("鸡哥");
        Star proxy = ProxyUtil.createProxy(bigStar);

        //2. 调用唱歌的方法
        String result = proxy.sing("只因你太美");
        System.out.println(result);
    }
}

/*
*
* 类的作用：
*       创建一个代理
*
* */
public class ProxyUtil {
    /*
    *
    * 方法的作用：
    *       给一个明星的对象，创建一个代理
    *
    *  形参：
    *       被代理的明星对象
    *
    *  返回值：
    *       给明星创建的代理
    *
    *
    *
    * 需求：
    *   外面的人想要大明星唱一首歌
    *   1. 获取代理的对象
    *      代理对象 = ProxyUtil.createProxy(大明星的对象);
    *   2. 再调用代理的唱歌方法
    *      代理对象.唱歌的方法("只因你太美");
    * */
    public static Star createProxy(BigStar bigStar){
       /* java.lang.reflect.Proxy类：提供了为对象产生代理对象的方法：
        public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
        参数一：用于指定用哪个类加载器，去加载生成的代理类
        参数二：指定接口，这些接口用于指定生成的代理长什么，也就是有哪些方法
        参数三：用来指定生成的代理对象要干什么事情
        */
        
        Star star = (Star) Proxy.newProxyInstance(
                ProxyUtil.class.getClassLoader(),//参数一：用于指定用哪个类加载器，去加载生成的代理类
                new Class[]{Star.class},//参数二：指定接口，这些接口用于指定生成的代理长什么，也就是有哪些方法
                //参数三：用来指定生成的代理对象要干什么事情
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        /*
                        * 参数一：代理的对象
                        * 参数二：要运行的方法 sing
                        * 参数三：调用sing方法时，传递的实参
                        * */
                        if("sing".equals(method.getName())){
                            System.out.println("准备话筒，收钱");
                        }else if("dance".equals(method.getName())){
                            System.out.println("准备场地，收钱");
                        }
                        //去找大明星开始唱歌或者跳舞
                        //代码的表现形式：调用大明星里面唱歌或者跳舞的方法
                        return method.invoke(bigStar,args);
                    }
                }
        );
        return star;
    }
}

public interface Star {
    //我们可以把所有想要被代理的方法定义在接口当中
    //唱歌
    public abstract String sing(String name);
    //跳舞
    public abstract void dance();
}

public class BigStar implements Star {
    private String name;


    public BigStar() {
    }

    public BigStar(String name) {
        this.name = name;
    }

    //唱歌
    @Override
    public String sing(String name){
        System.out.println(this.name + "正在唱" + name);
        return "谢谢";
    }

    //跳舞
    @Override
    public void dance(){
        System.out.println(this.name + "正在跳舞");
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    public String toString() {
        return "BigStar{name = " + name + "}";
    }
}

Java反射

Fri, 14 Mar 2025 00:00:00 GMT

Java反射是Java语言的一个重要特性，它允许程序在运行时获取任意类的内部信息，并可以操作这些信息。这种机制使得Java具有了动态获取类信息以及动态调用对象方法的能力。

反射的基本概念

反射（Reflection）是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过类名来获取任意一个类的内部信息，包括成员变量、构造方法、成员方法等，并可以操作这些成员。

反射的主要用途

动态加载类：在运行时根据需要加载类。
动态创建对象：通过反射来创建对象，无需知道具体的类名。
访问和修改私有成员：可以访问和修改类的私有成员变量和方法。
获取类型信息：在运行时获取类的类型信息。

反射的核心类

Java反射主要涉及以下核心类：

Class：代表一个类或接口的类型信息。
Field：代表类的成员变量（字段）。
Method：代表类的方法。
Constructor：代表类的构造方法。

获取`Class`对象

获取Class对象有三种方式：

通过对象获取：Class clazz = obj.getClass();
通过类名获取：Class clazz = ClassName.class;
通过全限定类名获取：Class clazz = Class.forName("com.example.ClassName");

使用反射操作类

获取成员变量

Field field = clazz.getDeclaredField("fieldName"); // 获取私有成员变量
field.setAccessible(true); // 取消访问权限检查
Object value = field.get(obj); // 获取成员变量的值
field.set(obj, newValue); // 设置成员变量的值

获取方法

Method method = clazz.getDeclaredMethod("methodName", paramClass1, paramClass2, ...); // 获取私有方法
// getMthods();会获取包含父类在内的所有方法
method.setAccessible(true); // 取消访问权限检查
Object result = method.invoke(obj, param1, param2, ...); // 调用方法

获取构造方法

Constructor constructor = clazz.getDeclaredConstructor(paramClass1, paramClass2, ...); // 获取私有构造方法
constructor.setAccessible(true); // 取消访问权限检查
Object instance = constructor.newInstance(param1, param2, ...); // 创建对象

反射的优缺点

优点：

增加程序的灵活性和扩展性。
可以实现动态创建对象和动态调用方法。缺点：
性能开销大：反射操作需要类型检查和解析，因此比直接代码慢。
安全性问题：反射可以访问和修改私有成员，可能会破坏封装性。
代码可读性差：使用反射的代码通常难以理解。

反射的使用场景

框架开发：如Spring、Hibernate等框架大量使用反射来实现依赖注入、对象关系映射等功能。
动态代理：如AOP（面向切面编程）中使用的动态代理。
编译时无法确定类型的场景。

注意事项

反射会破坏类的封装性，应谨慎使用。
反射操作可能会抛出ClassNotFoundException、NoSuchFieldException、NoSuchMethodException、IllegalAccessException、InvocationTargetException等异常，需要进行异常处理。

反射与泛型的关系

Java 5引入了泛型，但泛型信息在运行时会被擦除，即所谓的类型擦除。然而，可以通过反射获取到泛型的类型信息，这通常用于框架开发中。

反射的性能优化

尽量缓存Class、Field、Method、Constructor等反射对象。
减少反射的使用，只在必要的时候使用。
使用setAccessible(true)来提高访问私有成员的速度。通过以上讲解，相信您对Java反射有了更深入的理解。反射是Java中一个非常强大的工具，但使用时需要谨慎，以避免带来不必要的性能问题和安全问题。

示例1：获取Class对象

public class ReflectionExample {
    public static void main(String[] args) {
        // 通过对象获取Class对象
        Person person = new Person();
        Class<?> clazz1 = person.getClass();
        // 通过类名获取Class对象
        Class<?> clazz2 = Person.class;
        // 通过全限定类名获取Class对象
        try {
            Class<?> clazz3 = Class.forName("com.example.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println(clazz1 == clazz2); // 输出true，表示是同一个Class对象
    }
}
class Person {
    // Person类的定义
}

示例2：创建对象

public class ReflectionCreateObject {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("com.example.Person");
            // 调用无参构造方法创建对象
            Person person = (Person) clazz.newInstance();
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}
class Person {
    public Person() {
        // 无参构造方法
    }
}

示例3：访问和修改字段

public class ReflectionFieldAccess {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("com.example.Person");
            Person person = (Person) clazz.newInstance();
            // 获取字段
            Field nameField = clazz.getDeclaredField("name");
            // 设置可访问性
            nameField.setAccessible(true);
            // 修改字段值
            nameField.set(person, "Alice");
            // 获取字段值
            String name = (String) nameField.get(person);
            System.out.println(name); // 输出Alice
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | NoSuchFieldException e) {
            e.printStackTrace();
        }
    }
}
class Person {
    private String name;
    public Person() {
        this.name = "Unknown";
    }
}

示例4：调用方法

public class ReflectionMethodInvoke {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("com.example.Person");
            Person person = (Person) clazz.newInstance();
            // 获取方法
            Method sayHelloMethod = clazz.getDeclaredMethod("sayHello", String.class);
            // 设置可访问性
            sayHelloMethod.setAccessible(true);
            // 调用方法
            sayHelloMethod.invoke(person, "Bob");
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}
class Person {
    public void sayHello(String name) {
        System.out.println("Hello, " + name);
    }
}

示例5：获取构造方法并创建对象

public class ReflectionConstructor {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("com.example.Person");
            // 获取有参构造方法
            Constructor<?> constructor = clazz.getConstructor(String.class, int.class);
            // 创建对象
            Person person = (Person) constructor.newInstance("Charlie", 30);
        } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}
class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

示例6: 获取类所有的方法

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Parameter;
import java.lang.reflect.Type;

public class ReflectionAPITable {

    public static void printAPITable(Object obj) {
        Class<?> clazz = obj.getClass();
        Method[] methods = clazz.getMethods(); // 获取所有公共方法

        // 打印表头
        System.out.printf("%-20s %-50s %-20s %-10s%n", "方法名称", "参数列表", "返回类型", "修饰符");

        // 遍历所有方法
        for (Method method : methods) {
            // 获取方法名称
            String methodName = method.getName();

            // 获取参数类型
            Parameter[] parameters = method.getParameters();
            StringBuilder paramsBuilder = new StringBuilder();
            for (Parameter parameter : parameters) {
                if (paramsBuilder.length() > 0) paramsBuilder.append(", ");
                paramsBuilder.append(parameter.getType().getSimpleName()).append(" ").append(parameter.getName());
            }
            String params = paramsBuilder.toString();

            // 获取返回类型
            Type returnType = method.getGenericReturnType();
            String returnTypeName = returnType.getTypeName();

            // 获取修饰符
            String modifiers = Modifier.toString(method.getModifiers());

            // 打印方法信息
            System.out.printf("%-20s %-50s %-20s %-10s%n", methodName, params, returnTypeName, modifiers);
        }
    }

    public static void main(String[] args) {
        // 示例对象
        Person person = new Person("Alice", 30);

        // 打印API表格
        printAPITable(person);
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void sayHello() {
        System.out.println("Hello, my name is " + name);
    }
}

Java网络

Fri, 14 Mar 2025 00:00:00 GMT

InetAddress

InetAddress：此类表示Internet协议（IP）地址

方法名	说明
static InetAddress getByName(String host)	确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址
String getHostName()	获取此IP地址的主机名
String getHostAddress()	返回文本显示中的IP地址字符串

UDP

UDP发送数据

Java中的UDP通信
- UDP协议是一种不可靠的网络协议，它在通信的两端各建立一个Socket对象，但是这两个Socket只是发送，接收数据的对象，因此对于基于UDP协议的通信双方而言，没有所谓的客户端和服务器的概念
- Java提供了DatagramSocket类作为基于UDP协议的Socket

构造方法

方法名	说明
DatagramSocket()	创建数据报套接字并将其绑定到本机地址上的任何可用端口
DatagramPacket(byte[] buf,int len,InetAddress add,int port)	创建数据包,发送长度为len的数据包到指定主机的指定端口

相关方法

方法名说明

void send(DatagramPacket p) 发送数据报包

void close() 关闭数据报套接字

void receive(DatagramPacket p) 从此套接字接受数据报包
发送数据的步骤
- 创建发送端的Socket对象(DatagramSocket)
- 创建数据，并把数据打包
- 调用DatagramSocket对象的方法发送数据
- 关闭发送端

方法名	说明
void send(DatagramPacket p)	发送数据报包
void close()	关闭数据报套接字
void receive(DatagramPacket p)	从此套接字接受数据报包

代码演示

public class udpSend {
    public static void main(String[] args) throws IOException {
        //创建发送端的Socket对象(DatagramSocket)
        // DatagramSocket() 构造数据报套接字并将其绑定到本地主机上的任何可用端口
        // 空参: 在所有可用端口中随机选择一个使用
        DatagramSocket ds = new DatagramSocket();
        //创建数据，并把数据打包
        //DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        //构造一个数据包，发送长度为 length的数据包到指定主机上的指定端口号。
        byte[] bys = "hello,udp,我来了".getBytes();
        DatagramPacket dp = new DatagramPacket(
                bys,bys.length, InetAddress.getByName("127.0.0.1"),12345);
        //调用DatagramSocket对象的方法发送数据
        //void send(DatagramPacket p) 从此套接字发送数据报包
        ds.send(dp);
        //关闭发送端
        //void close() 关闭此数据报套接字
        ds.close();
    }
}

UDP接收数据

接收数据的步骤
- 创建接收端的Socket对象(DatagramSocket)
- 创建一个数据包，用于接收数据
- 调用DatagramSocket对象的方法接收数据
- 解析数据包，并把数据在控制台显示
- 关闭接收端
构造方法

方法名说明

DatagramPacket(byte[] buf, int len) 创建一个DatagramPacket用于接收长度为len的数据包
相关方法

方法名说明

byte[] getData() 返回数据缓冲区

int getLength() 返回要发送的数据的长度或接收的数据的长度

方法名	说明
DatagramPacket(byte[] buf, int len)	创建一个DatagramPacket用于接收长度为len的数据包

方法名	说明
byte[] getData()	返回数据缓冲区
int getLength()	返回要发送的数据的长度或接收的数据的长度

示例代码

public class updRecv {
    public static void main(String[] args) throws IOException {
        DatagramSocket ds = new DatagramSocket(12345);
        //创建一个数据包，用于接收数据
        byte[] bys = new byte[1024];
        DatagramPacket dp = new DatagramPacket(bys, bys.length);
        //调用DatagramSocket对象的方法接收数据
        ds.receive(dp);
        //解析数据包，并把数据在控制台显示
        System.out.println("数据是：" +
                new String(dp.getData(), 0, dp.getLength()));
        System.out.println("" + dp.getAddress()+dp.getPort());
        ds.close();
    }
}

UDP通信程序练习

案例需求

UDP发送数据：数据来自于键盘录入，直到输入的数据是886，发送数据结束

UDP接收数据：因为接收端不知道发送端什么时候停止发送，故采用死循环接收

代码实现

/*
    UDP发送数据：
        数据来自于键盘录入，直到输入的数据是886，发送数据结束
 */
public class SendDemo {
    public static void main(String[] args) throws IOException {
        //创建发送端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket();
        //键盘录入数据
        Scanner sc = new Scanner(System.in);
        while (true) {
          	String s = sc.nextLine();
            //输入的数据是886，发送数据结束
            if ("886".equals(s)) {
                break;
            }
            //创建数据，并把数据打包
            byte[] bys = s.getBytes();
            DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.1.66"), 12345);

            //调用DatagramSocket对象的方法发送数据
            ds.send(dp);
        }
        //关闭发送端
        ds.close();
    }
}

/*
    UDP接收数据：
        因为接收端不知道发送端什么时候停止发送，故采用死循环接收
 */
public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        //创建接收端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket(12345);
        while (true) {
            //创建一个数据包，用于接收数据
            byte[] bys = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bys, bys.length);
            //调用DatagramSocket对象的方法接收数据
            ds.receive(dp);
            //解析数据包，并把数据在控制台显示
            System.out.println("数据是：" + new String(dp.getData(), 0, dp.getLength()));
        }
        //关闭接收端
//        ds.close();
    }
}

UDP三种通讯方式

单播

单播用于两个主机之间的端对端通信
组播

组播用于对一组特定的主机进行通信
广播

广播用于一个主机对整个局域网上所有主机上的数据通信

UDP组播实现

实现步骤
- 发送端
  1. 创建发送端的Socket对象(DatagramSocket)
  2. 创建数据，并把数据打包(DatagramPacket)
  3. 调用DatagramSocket对象的方法发送数据(在单播中,这里是发给指定IP的电脑但是在组播当中,这里是发给组播地址)
  4. 释放资源
- 接收端
  1. 创建接收端Socket对象(MulticastSocket)
  2. 创建一个箱子,用于接收数据
  3. 把当前计算机绑定一个组播地址
  4. 将数据接收到箱子中
  5. 解析数据包,并打印数据
  6. 释放资源

代码实现

// 发送端
public class ClinetDemo {
    public static void main(String[] args) throws IOException {
        // 1. 创建发送端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket();
        String s = "hello 组播";
        byte[] bytes = s.getBytes();
        InetAddress address = InetAddress.getByName("224.0.1.0"); //指定主播地址
        int port = 10000;
        // 2. 创建数据，并把数据打包(DatagramPacket)
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port);
        // 3. 调用DatagramSocket对象的方法发送数据(在单播中,这里是发给指定IP的电脑但是在组播当中,这里是发给组播地址)
        ds.send(dp);
        // 4. 释放资源
        ds.close();
    }
}
// 接收端
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        // 1. 创建接收端Socket对象(MulticastSocket)
        MulticastSocket ms = new MulticastSocket(10000);
        // 2. 创建一个箱子,用于接收数据
        DatagramPacket dp = new DatagramPacket(new byte[1024],1024);
        // 3. 把当前计算机绑定一个组播地址,表示添加到这一组中.
        ms.joinGroup(InetAddress.getByName("224.0.1.0"));
        // 4. 将数据接收到箱子中
        ms.receive(dp);
        // 5. 解析数据包,并打印数据
        byte[] data = dp.getData();
        int length = dp.getLength();
        System.out.println(new String(data,0,length));
        // 6. 释放资源
        ms.close();
    }
}

UDP广播实现

实现步骤
- 发送端
  1. 创建发送端Socket对象(DatagramSocket)
  2. 创建存储数据的箱子,将广播地址封装进去
  3. 发送数据
  4. 释放资源
- 接收端
  1. 创建接收端的Socket对象(DatagramSocket)
  2. 创建一个数据包，用于接收数据
  3. 调用DatagramSocket对象的方法接收数据
  4. 解析数据包，并把数据在控制台显示
  5. 关闭接收端

代码实现

// 发送端
public class ClientDemo {
    public static void main(String[] args) throws IOException {
      	// 1. 创建发送端Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket();
		// 2. 创建存储数据的箱子,将广播地址封装进去
        String s = "广播 hello";
        byte[] bytes = s.getBytes();
        InetAddress address = InetAddress.getByName("255.255.255.255");
        int port = 10000;
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port);
		// 3. 发送数据
        ds.send(dp);
		// 4. 释放资源
        ds.close();
    }
}

// 接收端
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        // 1. 创建接收端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket(10000);
        // 2. 创建一个数据包，用于接收数据
        DatagramPacket dp = new DatagramPacket(new byte[1024],1024);
        // 3. 调用DatagramSocket对象的方法接收数据
        ds.receive(dp);
        // 4. 解析数据包，并把数据在控制台显示
        byte[] data = dp.getData();
        int length = dp.getLength();
        System.out.println(new String(data,0,length));
        // 5. 关闭接收端
        ds.close();
    }
}

TCP

TCP发送数据

Java中的TCP通信
- Java对基于TCP协议的的网络提供了良好的封装，使用Socket对象来代表两端的通信端口，并通过Socket产生IO流来进行网络通信。
- Java为客户端提供了Socket类，为服务器端提供了ServerSocket类

构造方法

方法名	说明
Socket(InetAddress address,int port)	创建流套接字并将其连接到指定IP指定端口号
Socket(String host, int port)	创建流套接字并将其连接到指定主机上的指定端口号

相关方法

方法名说明

InputStream getInputStream() 返回此套接字的输入流

OutputStream getOutputStream() 返回此套接字的输出流

方法名	说明
InputStream getInputStream()	返回此套接字的输入流
OutputStream getOutputStream()	返回此套接字的输出流

示例代码

public class Client {
    public static void main(String[] args) throws IOException {
        //TCP协议，发送数据
        //1.创建Socket对象
        //细节：在创建对象的同时会连接服务端
        //      如果连接不上，代码会报错
        Socket socket = new Socket("127.0.0.1",10000);
        //2.可以从连接通道中获取输出流
        OutputStream os = socket.getOutputStream();
        //写出数据
        os.write("aaa".getBytes());
        //3.释放资源
        os.close();
        socket.close();
    }
}

TCP接收数据

构造方法

方法名说明

ServletSocket(int port) 创建绑定到指定端口的服务器套接字
相关方法

方法名说明

Socket accept() 监听要连接到此的套接字并接受它
注意事项
1. accept方法是阻塞的,作用就是等待客户端连接
2. 客户端创建对象并连接服务器,此时是通过三次握手协议,保证跟服务器之间的连接
3. 针对客户端来讲,是往外写的,所以是输出流针对服务器来讲,是往里读的,所以是输入流
4. read方法也是阻塞的
5. 客户端在关流的时候,还多了一个往服务器写结束标记的动作
6. 最后一步断开连接,通过四次挥手协议保证连接终止
三次握手和四次挥手
- 三次握手确保连接建立
四次挥手确保连接通道里面的数据已经处理完毕

方法名	说明
ServletSocket(int port)	创建绑定到指定端口的服务器套接字

方法名	说明
Socket accept()	监听要连接到此的套接字并接受它

示例代码

public class Server {
    public static void main(String[] args) throws IOException {
        //TCP协议，接收数据

        //1.创建对象ServerSocker
        ServerSocket ss = new ServerSocket(10000);

        //2.监听客户端的链接
        Socket socket = ss.accept();

        //3.从连接通道中获取输入流读取数据
        InputStream is = socket.getInputStream();
        int b;
        while ((b = is.read()) != -1){
            System.out.println((char) b);
        }

        //4.释放资源
        socket.close();
        ss.close();
    }
}

TCP程序练习（传输中文）

发送端：

public class Client {
    public static void main(String[] args) throws IOException {
        //TCP协议，发送数据

        //1.创建Socket对象
        //细节：在创建对象的同时会连接服务端
        //      如果连接不上，代码会报错
        Socket socket = new Socket("127.0.0.1",10000);


        //2.可以从连接通道中获取输出流
        OutputStream os = socket.getOutputStream();
        //写出数据
        os.write("你好你好".getBytes());//12字节

        //3.释放资源
        os.close();
        socket.close();

    }
}

接收端：

public class Server {
    public static void main(String[] args) throws IOException {
        //TCP协议，接收数据

        //1.创建对象ServerSocker
        ServerSocket ss = new ServerSocket(10000);

        //2.监听客户端的链接
        Socket socket = ss.accept();

        //3.从连接通道中获取输入流读取数据
        InputStream is = socket.getInputStream();
        // 转换流,转为字符流
        InputStreamReader isr = new InputStreamReader(is);
        // 通过Buffer读取,提高效率
        BufferedReader br = new BufferedReader(isr);

        // BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

        int b;
        while ((b = br.read()) != -1){
            System.out.print((char) b);
        }

        //4.释放资源
        socket.close();
        ss.close();

    }
}

C++的构造函数

Thu, 13 Mar 2025 00:00:00 GMT

C++中的构造函数是一种特殊的成员函数，用于在创建对象时初始化对象。构造函数在对象被创建时自动调用，确保对象在使用前处于有效状态。C++支持多种形式的构造函数，以满足不同的初始化需求。以下是一些常见的构造函数类型：

默认构造函数

默认构造函数是没有参数的构造函数，或者所有参数都有默认值的构造函数。如果类中没有显式定义任何构造函数，编译器会自动生成一个默认构造函数。

class MyClass {
public:
    MyClass() { // 默认构造函数
        // 初始化代码
    }
};

参数化构造函数

参数化构造函数是带有参数的构造函数，允许在创建对象时传递初始化值。

class MyClass {
public:
    MyClass(int value) { // 参数化构造函数
        // 使用value初始化成员变量
    }
};

拷贝构造函数

拷贝构造函数用于创建一个新对象，作为另一个同类型对象的副本。拷贝构造函数的参数是同类型的引用。

class MyClass {
public:
    MyClass(const MyClass& other) { // 拷贝构造函数
        // 从other对象复制数据
    }
};

移动构造函数

移动构造函数用于转移另一个同类型对象的资源，而不是复制资源。它通常用于优化包含动态内存分配的类的性能。

class MyClass {
public:
    MyClass(MyClass&& other) noexcept { // 移动构造函数
        // 转移other对象的数据
    }
};

委托构造函数

委托构造函数是一种构造函数，它调用同一个类中的另一个构造函数来初始化对象。

class MyClass {
public:
    MyClass() : MyClass(0) { // 委托给参数化构造函数
        // 其他初始化代码
    }
    MyClass(int value) {
        // 使用value初始化成员变量
    }
};

列表初始化构造函数

列表初始化构造函数使用初始化列表来初始化成员变量，这通常比在构造函数体内赋值更高效。

class MyClass {
private:
    int a;
    double b;
public:
    MyClass(int aVal, double bVal) : a(aVal), b(bVal) { // 列表初始化
        // 构造函数体可以留空或包含其他代码
    }
};

显式构造函数

显式构造函数使用explicit关键字，防止构造函数被用于隐式类型转换。

class MyClass {
public:
    explicit MyClass(int value) { // 显式构造函数
        // 使用value初始化成员变量
    }
};

虚构造函数

在C++中，构造函数不能是虚函数，但可以调用虚函数。虚构造函数的概念通常用于指代在构造函数中调用虚函数的情况，这可能导致未定义行为，因为对象在构造过程中其虚表可能尚未完全初始化。

禁止赋值和按值传递

在C++中，如果你想要禁止一个类的对象被复制或按值传递，你需要删除拷贝构造函数和拷贝赋值运算符。此外，为了防止移动操作，你还可能需要删除移动构造函数和移动赋值运算符。这样可以确保类的对象不会被复制或移动。以下是如何实现这一点的示例：

class NonCopyable {
public:
    // 删除拷贝构造函数
    NonCopyable(const NonCopyable&) = delete;
    
    // 删除拷贝赋值运算符
    NonCopyable& operator=(const NonCopyable&) = delete;
    // 删除移动构造函数（可选，但推荐）
    NonCopyable(NonCopyable&&) = delete;
    
    // 删除移动赋值运算符（可选，但推荐）
    NonCopyable& operator=(NonCopyable&&) = delete;
    // 默认构造函数
    NonCopyable() {
        // 初始化代码
    }
    // 其他成员函数
    // ...
};
// 使用示例
int main() {
    NonCopyable obj1; // 正确：调用默认构造函数
    // NonCopyable obj2 = obj1; // 错误：拷贝构造函数被删除
    // NonCopyable obj3(obj1); // 错误：拷贝构造函数被删除
    // obj1 = obj2; // 错误：拷贝赋值运算符被删除
    return 0;
}

在这个示例中，NonCopyable类的拷贝构造函数和拷贝赋值运算符都被标记为delete，这意味着它们不能被使用，尝试复制NonCopyable对象将会导致编译错误。同样，移动构造函数和移动赋值运算符也被删除，这是为了防止通过移动语义来复制对象。虽然移动操作通常不涉及深拷贝，但在某些情况下，你可能仍然想要禁止移动以保持对象的唯一性。通过这种方式，你可以确保类的对象不会被复制或按值传递，这对于管理资源（如文件句柄、网络连接等）的类来说是非常有用的，因为这些资源通常不应该被共享或复制。

如果继承自一个已经删除了拷贝构造函数和拷贝赋值运算符的类（如NonCopyable），那么派生类也会继承这些特性，即派生类的对象同样不能被复制和按值传递。在C++中，如果基类中的某个成员函数被删除或声明为私有，那么在派生类中也无法使用该成员函数，除非派生类提供了自己的实现。由于拷贝构造函数和拷贝赋值运算符是特殊的成员函数，它们遵循同样的规则。以下是一个示例，展示了如何继承NonCopyable类，并说明派生类的对象也不能被复制和按值传递：

class NonCopyable {
public:
    // 删除拷贝构造函数
    NonCopyable(const NonCopyable&) = delete;
    // 删除拷贝赋值运算符
    NonCopyable& operator=(const NonCopyable&) = delete;
    // 默认构造函数
    NonCopyable() {
        // 初始化代码
    }
    // 其他成员函数
    // ...
};
// 派生类
class Derived : public NonCopyable {
public:
    // Derived类的构造函数
    Derived() {
        // 初始化代码
    }
    // 其他成员函数
    // ...
};
// 使用示例
int main() {
    Derived obj1; // 正确：调用默认构造函数
    // Derived obj2 = obj1; // 错误：拷贝构造函数被删除
    // obj1 = obj2; // 错误：拷贝赋值运算符被删除
    return 0;
}

在这个示例中，Derived类继承自NonCopyable类。由于NonCopyable类已经删除了拷贝构造函数和拷贝赋值运算符，因此Derived类的对象也不能被复制和按值传递。尝试这样做会导致编译错误。这种设计模式在C++中很常见，特别是当你想要确保类的对象是唯一的，或者当你想要防止资源的意外复制时。通过继承一个非拷贝able的基类，你可以很容易地传播这个特性到整个类层次结构中。

注意事项：

构造函数不能有返回类型，即使是void也不行。
构造函数可以重载，即可以定义多个构造函数，只要它们的参数列表不同。
如果类中没有显式定义构造函数，编译器会提供默认的构造函数、拷贝构造函数和移动构造函数（如果适用）。
如果类中定义了任何构造函数，编译器就不会提供默认构造函数。了解和正确使用这些构造函数类型是C++编程中的重要部分，它们有助于创建灵活、高效且易于维护的类。

java File类

Thu, 13 Mar 2025 00:00:00 GMT

构造函数

方法名	说明
public File(String pathname)	根据文件路径创建文件对象
public File(String parent, String child)	根据父路径和子路径创建文件对象
public File(File parent, String child)	根据父路径对应的文件对象和子路径创建文件对象

常用方法

public String getAbsolutePath() ：返回此File的绝对路径名字符串。
public String getPath() ：将此File转换为路径名字符串。
public String getName() ：返回由此File表示的文件或目录的名称。
public long length() ：返回由此File表示的文件的长度（字节）。

public long lastModified(): 返回文件的最后修改时间。

方法演示，代码如下：

public class FileGet {
    public static void main(String[] args) {
        File f = new File("d:/aaa/bbb.java");     
        System.out.println("文件绝对路径:"+f.getAbsolutePath());
        System.out.println("文件构造路径:"+f.getPath());
        System.out.println("文件名称:"+f.getName());
        System.out.println("文件长度:"+f.length()+"字节");

        File f2 = new File("d:/aaa");     
        System.out.println("目录绝对路径:"+f2.getAbsolutePath());
        System.out.println("目录构造路径:"+f2.getPath());
        System.out.println("目录名称:"+f2.getName());
        System.out.println("目录长度:"+f2.length());
    }
}
输出结果：
文件绝对路径:d:\aaa\bbb.java
文件构造路径:d:\aaa\bbb.java
文件名称:bbb.java
文件长度:636字节

目录绝对路径:d:\aaa
目录构造路径:d:\aaa
目录名称:aaa
目录长度:4096

API中说明：length()，表示文件的长度。但是File对象表示目录，则返回值未指定。若需要获取某个文件夹的大小，需要遍历文件夹下每个文件的大小，然后累计。

绝对路径：从盘符开始的路径，这是一个完整的路径。
相对路径：相对于项目目录的路径，这是一个便捷的路径，开发中经常使用。

public class FilePath {
    public static void main(String[] args) {
      	// D盘下的bbb.java文件
        File f = new File("D:\\bbb.java");
        System.out.println(f.getAbsolutePath());
      	
		// 项目下的bbb.java文件
        File f2 = new File("bbb.java");
        System.out.println(f2.getAbsolutePath());
    }
}
输出结果：
D:\bbb.java
D:\idea_project_test4\bbb.java

public boolean exists() ：此File表示的文件或目录是否实际存在。
public boolean isDirectory() ：此File表示的是否为目录。
public boolean isFile() ：此File表示的是否为文件。

方法演示，代码如下：

public class FileIs {
    public static void main(String[] args) {
        File f = new File("d:\\aaa\\bbb.java");
        File f2 = new File("d:\\aaa");
      	// 判断是否存在
        System.out.println("d:\\aaa\\bbb.java 是否存在:"+f.exists());
        System.out.println("d:\\aaa 是否存在:"+f2.exists());
      	// 判断是文件还是目录
        System.out.println("d:\\aaa 文件?:"+f2.isFile());
        System.out.println("d:\\aaa 目录?:"+f2.isDirectory());
    }
}
输出结果：
d:\aaa\bbb.java 是否存在:true
d:\aaa 是否存在:true
d:\aaa 文件?:false
d:\aaa 目录?:true

public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
public boolean delete() ：删除由此File表示的文件或目录。
public boolean mkdir() ：创建由此File表示的目录。
public boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录。

方法演示，代码如下：

public class FileCreateDelete {
    public static void main(String[] args) throws IOException {
        // 文件的创建
        File f = new File("aaa.txt");
        System.out.println("是否存在:"+f.exists()); // false
        System.out.println("是否创建:"+f.createNewFile()); // true
        System.out.println("是否存在:"+f.exists()); // true
		
     	// 目录的创建
      	File f2= new File("newDir");	
        System.out.println("是否存在:"+f2.exists());// false
        System.out.println("是否创建:"+f2.mkdir());	// true
        System.out.println("是否存在:"+f2.exists());// true

		// 创建多级目录
      	File f3= new File("newDira\\newDirb");
        System.out.println(f3.mkdir());// false
        File f4= new File("newDira\\newDirb");
        System.out.println(f4.mkdirs());// true
      
      	// 文件的删除
       	System.out.println(f.delete());// true
      
      	// 目录的删除
        System.out.println(f2.delete());// true
        System.out.println(f4.delete());// false
    }
}

API中说明：delete方法，如果此File表示目录，则目录必须为空才能删除。不走回收站。

目录的遍历

public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。

public class FileFor {
    public static void main(String[] args) {
        File dir = new File("d:\\java_code");
      
      	//获取当前目录下的文件以及文件夹的名称。
		String[] names = dir.list();
		for(String name : names){
			System.out.println(name);
		}
        //获取当前目录下的文件以及文件夹对象，只要拿到了文件对象，那么就可以获取更多信息
        File[] files = dir.listFiles();
        for (File file : files) {
            System.out.println(file);
        }
    }
}

调用listFiles方法的File对象，表示的必须是实际存在的目录，否则返回null，无法进行遍历。

public static File[] listRoots(): 获取系统中所有的盘符。

IO流

Thu, 13 Mar 2025 00:00:00 GMT

字节流

字节输出流：OutputStream

java.io.OutputStream 抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
public abstract void write(int b) ：将指定的字节输出流。

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileOutputStream类

java.io.FileOutputStream 类是文件输出流，用于将数据写出到文件。

构造方法

public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。
public FileOutputStream(String name)：创建文件输出流以指定的名称写入文件。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件，但父级文件夹必须存在。如果有这个文件，会清空这个文件的数据。

构造举例，代码如下：

public class FileOutputStreamConstructor throws IOException {
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileOutputStream fos = new FileOutputStream(file);
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("b.txt");
    }
}

写出字节数据

void write(int b)：一次写一个数据
void write(byte[] b)：写入数组的数据
void write(byte[] b, int off, int len)：写入数组数据带偏移量(是写入数组中的偏移量，不是目标的偏移量)

数据追加续写

public FileOutputStream(File file, boolean append)：创建文件输出流以写入由指定的 File对象表示的文件。
public FileOutputStream(String name, boolean append)：创建文件输出流以指定的名称写入文件。

这两个构造方法，参数中都需要传入一个boolean类型的值，true 表示追加数据，false 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt"，true);     
      	// 字符串转换为字节数组
      	byte[] b = "abcde".getBytes();
		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b);
      	// 关闭资源
        fos.close();
    }
}
文件操作前：cd
文件操作后：cdabcde

写出换行

Windows系统里，换行符号是\r\n 。以指定是否追加续写了，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");  
      	// 定义字节数组
      	byte[] words = {97,98,99,100,101};
      	// 遍历数组
        for (int i = 0; i < words.length; i++) {
          	// 写出一个字节
            fos.write(words[i]);
          	// 写出一个换行, 换行符号转成数组写出
            fos.write("\r\n".getBytes());
        }
      	// 关闭资源
        fos.close();
    }
}

输出结果：
a
b
c
d
e

回车符\r和换行符\n ：

回车符：回到一行的开头（return）。

换行符：下一行（newline）。

系统中的换行：

Windows系统里，每行结尾是 回车+换行 ，即\r\n；

Unix系统里，每行结尾只有 换行 ，即\n；

Mac系统里，每行结尾是 回车 ，即\r。从 Mac OS X开始与Linux统一。

字节输入流：InputStream

java.io.InputStream 抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
public abstract int read()：从输入流读取数据的下一个字节。
public int read(byte[] b)：从输入流中读取一些字节数，并将它们存储到字节数组 b中。

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileInputStream类

java.io.FileInputStream 类是文件输入流，从文件中读取字节。

构造方法

FileInputStream(File file)：通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
FileInputStream(String name)：通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出FileNotFoundException 。

构造举例，代码如下：

public class FileInputStreamConstructor throws IOException{
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileInputStream fos = new FileInputStream(file);
        // 使用文件名称创建流对象
        FileInputStream fos = new FileInputStream("b.txt");
    }
}

读取字节数据

读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象
       	FileInputStream fis = new FileInputStream("read.txt");
      	// 读取数据，返回一个字节
        int read = fis.read();
        System.out.println((char) read);
      	// 读取到末尾,返回-1
       	read = fis.read();
        System.out.println( read);
		// 关闭资源
        fis.close();
    }
}
输出结果：
a
-1

循环改进读取方式，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象
       	FileInputStream fis = new FileInputStream("read.txt");
      	// 定义变量，保存数据
        int b ；
        // 循环读取
        while ((b = fis.read())!=-1) {
            System.out.println((char)b);
        }
		// 关闭资源
        fis.close();
    }
}
输出结果：
a
b
c
d
e

虽然读取了一个字节，但是会自动提升为int类型。

流操作完毕后，必须释放系统资源，调用close方法。

使用字节数组读取：read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1 ，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象.
       	FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
      	// 定义变量，作为有效个数
        int len ；
        // 定义字节数组，作为装字节数据的容器   
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=-1) {
           	// 每次读取后,把数组变成字符串打印
            System.out.println(new String(b));
        }
		// 关闭资源
        fis.close();
    }
}

输出结果：
ab
cd
ed

错误数据d，是由于最后一次读取时，只读取一个字节e，数组中，上次读取的数据没有被完全替换，所以要通过len ，获取有效的字节，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象.
       	FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
      	// 定义变量，作为有效个数
        int len ；
        // 定义字节数组，作为装字节数据的容器   
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=-1) {
           	// 每次读取后,把数组的有效字节部分，变成字符串打印
            System.out.println(new String(b，0，len));//  len 每次读取的有效字节个数
        }
		// 关闭资源
        fis.close();
    }
}

输出结果：
ab
cd
e

使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使用。

字符流

字符流 = 字节流 + 对字符集的特殊处理

遇到中文时，一次会读入多个字节

FileReader

继承自Reader

public FileReader(File file)：创建字符输入流，关联本地文件
public FileReader(String path)：创建字符输入流，关联本地文件

读取数据

public int read()：读取数据，读到末尾返回-1
public int read(char[] buffer)：读取多个数据，读到末尾返回-1

按字节读取，遇到中文一次读取多个字节，读取后解码，返回一个整数，会转成十进制数据。如果需要字符数据，则需要使用(char)强制转换。

释放资源

public int close()：释放资源

FileReader fr = new FileReader("a.txt");
char[] chars = new char[2];
int len;
while((len = fr.read(chars))!=-1){
    System.out.print(new String(chars, 0, len));
}
fr.close();

FIleWriter

继承自Weiter

public FIleWriter(File file)：创建字符输出流，关联本地文件
public FIleWriter(String path)：创建字符输出流，关联本地文件
public FIleWriter(File file, boolean append)：创建字符输出流，关联本地文件，续写
public FIleWriter(String path, boolean append)：创建字符输出流，关联本地文件，续写

写入数据

public int write()
``public int write(String str)`
public int write(String str, int off, int len)
public int write(char[] buff)
public int write(char[] buff, int off, int len)

按字节读取，遇到中文一次读取多个字节，读取后解码，返回一个整数，会转成十进制数据。如果需要字符数据，则需要使用(char)强制转换。

释放资源

public int close()：释放资源

异常处理

传统写法

public class HandleException1 {
    public static void main(String[] args) {
        FileWriter fw = null;
        try {
            fw = new FileWriter("fw.txt");
            fw.write("aaa"); 
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fw != null) {
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

JDK7

public class HandleException2 {
    public static void main(String[] args) {
        try ( FileWriter fw = new FileWriter("fw.txt"); ) {
            // 需要实现AutoCloseable之后才行
            fw.write("aaa");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

JDK9

JDK9中try-with-resource 的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭，无需手动close。

public class TryDemo {
    public static void main(String[] args) throws IOException {
        final  FileReader fr  = new FileReader("in.txt");
        FileWriter fw = new FileWriter("out.txt");
        try (fr; fw) {
            int b;
          	while ((b = fr.read())!=-1) {
            	fw.write(b);
          	}
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文件复制

每次读取一个字节，写入新文件。

FileInputStream fis = new FileInputStream("read.txt");
FileOutputStream fos = new FileOutputStream("read.txt");
int b;
while((b = fis.read()) != -1){
    fos.write(b);
}
fis.close();
fos.close();

使用字节数组来拷贝：

public class Copy {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("test.jpg");
        FileOutputStream fos = new FileOutputStream("test_copy.jpg");
        byte[] b = new byte[1024*1024*4];
        int len;
        while ((len = fis.read(b))!=-1) {
            fos.write(b, 0 , len);
        }
        fos.close();
        fis.close();
    }
}

随机读写

在Java中，要在文件的指定位置写入数据，可以使用RandomAccessFile类，该类提供了对文件随机访问的功能，即可以读取或写入文件中的任意位置。下面是一个简单的示例，展示如何使用RandomAccessFile在文件的指定位置写入数据：

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
public class FileWriteAtPosition {
    public static void main(String[] args) {
        String filePath = "example.txt"; // 文件路径
        long position = 10; // 指定位置
        String dataToWrite = "Hello, World!"; // 要写入的数据
        try {
            // 创建File对象
            File file = new File(filePath);
            // 创建RandomAccessFile对象，模式为"rw"，即读写模式
            RandomAccessFile raf = new RandomAccessFile(file, "rw");
            // 移动文件指针到指定位置
            raf.seek(position);
            // 写入数据
            raf.write(dataToWrite.getBytes());
            // 关闭RandomAccessFile
            raf.close();
            System.out.println("Data written at position " + position);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，我们首先创建了一个File对象来表示要操作的文件。然后，我们创建了一个RandomAccessFile对象，并指定了模式为"rw"，表示我们可以读写文件。使用seek(long pos)方法将文件指针移动到指定的位置。然后，使用write(byte[] b)方法将数据写入文件。最后，不要忘记关闭RandomAccessFile以释放资源。请注意，如果指定的位置超出了文件当前的大小，那么在写入数据时，文件将会被扩展，并且在新写入数据与原有数据之间可能会出现未定义的数据。还要注意，直接在文件的中间位置写入数据可能会覆盖原有数据，所以使用这种方法时要小心，确保不会意外地覆盖重要信息。如果只是想插入数据而不覆盖原有数据，那么需要先读取插入点后的数据，插入新数据后，再写回原有数据。

缓冲流

缓冲流,也叫高效流，缓冲流是对基本流进行的封装，对4个基本的FileXxx 流的增强，所以也是4个流，按照数据类型分类：

字节缓冲流：BufferedInputStream，BufferedOutputStream
字符缓冲流：BufferedReader，BufferedWriter

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

字节缓冲流

构造方法

public BufferedInputStream(InputStream in) ：创建一个新的缓冲输入流。
public BufferedOutputStream(OutputStream out)：创建一个新的缓冲输出流。

构造举例，代码如下：

// 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));

效率测试

查询API，缓冲流读写方法与基本的流是一致的，我们通过复制大文件（375MB），测试它的效率。

基本流，代码如下：

public class BufferedDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // 记录开始时间
      	long start = System.currentTimeMillis();
		// 创建流对象
        try (
        	FileInputStream fis = new FileInputStream("jdk9.exe");
        	FileOutputStream fos = new FileOutputStream("copy.exe")
        ){
        	// 读写数据
            int b;
            while ((b = fis.read()) != -1) {
                fos.write(b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
		// 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("普通流复制时间:"+(end - start)+" 毫秒");
    }
}

十几分钟过去了...

缓冲流，代码如下：

public class BufferedDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // 记录开始时间
      	long start = System.currentTimeMillis();
		// 创建流对象
        try (
        	BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));
	     BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
        ){
        // 读写数据
            int b;
            while ((b = bis.read()) != -1) {
                bos.write(b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
		// 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("缓冲流复制时间:"+(end - start)+" 毫秒");
    }
}

缓冲流复制时间:8016 毫秒

如何更快呢？

使用数组的方式，代码如下：

public class BufferedDemo {
    public static void main(String[] args) throws FileNotFoundException {
      	// 记录开始时间
        long start = System.currentTimeMillis();
		// 创建流对象
        try (
			BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));
		 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
        ){
          	// 读写数据
            int len;
            byte[] bytes = new byte[8*1024];
            while ((len = bis.read(bytes)) != -1) {
                bos.write(bytes, 0 , len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
		// 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("缓冲流使用数组复制时间:"+(end - start)+" 毫秒");
    }
}
缓冲流使用数组复制时间:666 毫秒

字符缓冲流

构造方法

public BufferedReader(Reader in) ：创建一个新的缓冲输入流。
public BufferedWriter(Writer out)：创建一个新的缓冲输出流。

构造举例，代码如下：

// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

特有方法

字符缓冲流的基本方法与普通字符流调用方式一致，不再阐述，我们来看它们具备的特有方法。

BufferedReader：public String readLine(): 读一行文字。
BufferedWriter：public void newLine(): 写一行行分隔符,由系统属性定义符号。

readLine方法演示，代码如下：

public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
      	 // 创建流对象
        BufferedReader br = new BufferedReader(new FileReader("in.txt"));
		// 定义字符串,保存读取的一行文字
        String line  = null;
      	// 循环读取,读取到最后返回null
        while ((line = br.readLine())!=null) {
            System.out.print(line);
            System.out.println("------");
        }
		// 释放资源
        br.close();
    }
}

newLine方法演示，代码如下：

public class BufferedWriterDemo throws IOException {
  public static void main(String[] args) throws IOException  {
    	// 创建流对象
  	BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
    	// 写出数据
      bw.write("黑马");
    	// 写出换行
      bw.newLine();
      bw.write("程序");
      bw.newLine();
      bw.write("员");
      bw.newLine();
  	// 释放资源
      bw.close();
  }
}
输出效果:
黑马
程序
员

打印流

概述

平时我们在控制台打印输出，是调用print方法和println方法完成的，这两个方法都来自于java.io.PrintStream类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

PrintStream类

构造方法

public PrintStream(String fileName) ：使用指定的文件名创建一个新的打印流。

构造举例，代码如下：

PrintStream ps = new PrintStream("ps.txt")；

改变打印流向

System.out就是PrintStream类型的，只不过它的流向是系统规定的，打印在控制台上。不过，既然是流对象，我们就可以玩一个"小把戏"，改变它的流向。

public class PrintDemo {
    public static void main(String[] args) throws IOException {
		// 调用系统的打印流,控制台直接输出97
        System.out.println(97);
      
		// 创建打印流,指定文件的名称
        PrintStream ps = new PrintStream("ps.txt");
      	
      	// 设置系统的打印流流向,输出到ps.txt
        System.setOut(ps);
      	// 调用系统的打印流,ps.txt中输出97
        System.out.println(97);
    }
}

压缩流和解压缩流

压缩流：

负责压缩文件或者文件夹

解压缩流：

负责把压缩包中的文件和文件夹解压出来

public class ZipStreamDemo1 {
    public static void main(String[] args) throws IOException {
        //1.创建一个File表示要解压的压缩包
        File src = new File("D:\\aaa.zip");
        //2.创建一个File表示解压的目的地
        File dest = new File("D:\\");
        //调用方法
        unzip(src,dest);
    }

    //定义一个方法用来解压
    public static void unzip(File src,File dest) throws IOException {
        //解压的本质：把压缩包里面的每一个文件或者文件夹读取出来，按照层级拷贝到目的地当中
        //创建一个解压缩流用来读取压缩包中的数据
        ZipInputStream zip = new ZipInputStream(new FileInputStream(src));
        //要先获取到压缩包里面的每一个zipentry对象
        //表示当前在压缩包中获取到的文件或者文件夹
        ZipEntry entry;
        while((entry = zip.getNextEntry()) != null){
            System.out.println(entry);
            if(entry.isDirectory()){
                //文件夹：需要在目的地dest处创建一个同样的文件夹
                File file = new File(dest,entry.toString());
                file.mkdirs();
            }else{
                //文件：需要读取到压缩包中的文件，并把他存放到目的地dest文件夹中（按照层级目录进行存放）
                FileOutputStream fos = new FileOutputStream(new File(dest,entry.toString()));
                int b;
                while((b = zip.read()) != -1){
                    //写到目的地
                    fos.write(b);
                }
                fos.close();
                //表示在压缩包中的一个文件处理完毕了。
                zip.closeEntry();
            }
        }
        zip.close();
    }
}

public class ZipStreamDemo2 {
    public static void main(String[] args) throws IOException {
        /*
         *   压缩流
         *      需求：
         *          把D:\\a.txt打包成一个压缩包
         * */
        //1.创建File对象表示要压缩的文件
        File src = new File("D:\\a.txt");
        //2.创建File对象表示压缩包的位置
        File dest = new File("D:\\");
        //3.调用方法用来压缩
        toZip(src,dest);
    }

    /*
    *   作用：压缩
    *   参数一：表示要压缩的文件
    *   参数二：表示压缩包的位置
    * */
    public static void toZip(File src,File dest) throws IOException {
        //1.创建压缩流关联压缩包
        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(new File(dest,"a.zip")));
        //2.创建ZipEntry对象，表示压缩包里面的每一个文件和文件夹
        //参数：压缩包里面的路径
        ZipEntry entry = new ZipEntry("aaa\\bbb\\a.txt");
        //3.把ZipEntry对象放到压缩包当中
        zos.putNextEntry(entry);
        //4.把src文件中的数据写到压缩包当中
        FileInputStream fis = new FileInputStream(src);
        int b;
        while((b = fis.read()) != -1){
            zos.write(b);
        }
        zos.closeEntry();
        zos.close();
    }
}

public class ZipStreamDemo3 {
    public static void main(String[] args) throws IOException {
        /*
         *   压缩流
         *      需求：
         *          把D:\\aaa文件夹压缩成一个压缩包
         * */
        //1.创建File对象表示要压缩的文件夹
        File src = new File("D:\\aaa");
        //2.创建File对象表示压缩包放在哪里（压缩包的父级路径）
        File destParent = src.getParentFile();//D:\\
        //3.创建File对象表示压缩包的路径
        File dest = new File(destParent,src.getName() + ".zip");
        //4.创建压缩流关联压缩包
        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(dest));
        //5.获取src里面的每一个文件，变成ZipEntry对象，放入到压缩包当中
        toZip(src,zos,src.getName());//aaa
        //6.释放资源
        zos.close();
    }

    /*
    *   作用：获取src里面的每一个文件，变成ZipEntry对象，放入到压缩包当中
    *   参数一：数据源
    *   参数二：压缩流
    *   参数三：压缩包内部的路径
    * */
    public static void toZip(File src,ZipOutputStream zos,String name) throws IOException {
        //1.进入src文件夹
        File[] files = src.listFiles();
        //2.遍历数组
        for (File file : files) {
            if(file.isFile()){
                //3.判断-文件，变成ZipEntry对象，放入到压缩包当中
                ZipEntry entry = new ZipEntry(name + "\\" + file.getName());//aaa\\no1\\a.txt
                zos.putNextEntry(entry);
                //读取文件中的数据，写到压缩包
                FileInputStream fis = new FileInputStream(file);
                int b;
                while((b = fis.read()) != -1){
                    zos.write(b);
                }
                fis.close();
                zos.closeEntry();
            }else{
                //4.判断-文件夹，递归
                toZip(file,zos,name + "\\" + file.getName());
                //     no1            aaa   \\   no1
            }
        }
    }
}

java学习笔记（7）

Thu, 13 Mar 2025 00:00:00 GMT

方法引用

引用处需要是函数式接口
被引用的方法已经存在（可以由java提供，也可以是第三方）
被引用的方法的参数和返回值要和抽象方法的参数返回值一致
核心：lambda表达式改写

例子：排序

public class sort {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(list);
        Collections.shuffle(list);
        Collections.sort(list, (o1, o2) -> o2 - o1);
        System.out.println(list);
        Collections.shuffle(list);
        Collections.sort(list, sort::sub);
        System.out.println(list);
    }
    public static int sub(int a, int b) {
        return b-a;
    }
}

引用静态方法

格式：ClassName::StaticMethodName
例子：Integer::parseInt

// list:{"1", "2", "3", "4"}
list.stream().map(Integer::parseInt).collect(Collectors.toList());

引用成员方法

格式：Object::MethodName
this::name
super::name

list.stream().filter(new Judge()::judge).collect(Collectors.toList());

引用构造方法

格式：ClassName::new

list.stream().map(Student::new).collect(Collectors.toList());

异常

异常继承自Throwable

idea快捷键：Ctrl+Alt+T

方法名	说明
public String getMessage()	返回此throwable的详细消息的字符串
public String toString()	返回此throwable的简短描述
public void printStackTrace()	打印异常的错误信息

printStackTrace()在系统底层使用System.err.println("")输出

捕获异常：

try{
    ...
}catch{
	...    
}

抛出异常：

public void function() throws Exception{
    throw new Exception();
}

throws: 告诉使用者，可能抛出哪些异常
throw：抛出异常

自定义异常

public class MyException extends RuntimeException{
    public MyException(){};
    public MyException(String message){
        super(message);
    }
}

运行时异常：RuntimeException
编译时异常：Exception

字符编码

在Java中，String的编解码主要涉及到字符集（Charset）的概念，字符集决定了如何将字符（例如字母、数字、符号等）映射为字节序列，以及如何将字节序列映射回字符。Java中的String是以UTF-16编码存储的，但是我们可以使用不同的字符集对其进行编码和解码。

编码（Encoding）

编码是将String对象转换为字节序列的过程。在Java中，可以使用String类的getBytes()方法来进行编码，这个方法可以指定使用的字符集。

String str = "你好，世界！";
byte[] bytes = str.getBytes("UTF-8"); // 使用UTF-8编码

在上面的例子中，str字符串被转换为字节序列bytes，使用的是UTF-8编码。如果不指定字符集，getBytes()方法会使用平台的默认字符集。

解码（Decoding）

解码是将字节序列转换回String对象的过程。在Java中，可以使用String类的构造方法来进行解码。

byte[] bytes = ...; // 假设这是某种编码的字节序列
String str = new String(bytes, "UTF-8"); // 使用UTF-8解码

在上面的例子中，bytes字节序列被转换回字符串str，使用的是UTF-8编码。同样，如果不指定字符集，会使用平台的默认字符集。

常见字符集

UTF-8：一种变长的编码方式，可以用1到4个字节表示一个字符，兼容ASCII码。
UTF-16：Java内部使用的是UTF-16编码，用2或4个字节表示一个字符。
GBK：中国的国家标准，兼容GB2312，用于中文编码。
ISO-8859-1：西欧语言的编码字符集。

编解码中的常见问题

乱码：如果编码和解码时使用的字符集不一致或者没有读完整个汉字，就会出现乱码。
字符集不支持：尝试使用不支持的字符集进行编解码会抛出UnsupportedEncodingException。

示例

下面是一个完整的示例，展示了如何进行编码和解码：

import java.io.UnsupportedEncodingException;
public class StringEncodingExample {
    public static void main(String[] args) {
        String originalString = "你好，世界！";
        try {
            // 编码
            byte[] utf8Bytes = originalString.getBytes("UTF-8");
            byte[] gbkBytes = originalString.getBytes("GBK");
            // 解码
            String utf8String = new String(utf8Bytes, "UTF-8");
            String gbkString = new String(gbkBytes, "GBK");
            // 输出结果
            System.out.println("原始字符串: " + originalString);
            System.out.println("UTF-8编码后解码: " + utf8String);
            System.out.println("GBK编码后解码: " + gbkString);
            // 错误的解码示例（会导致乱码）
            String wrongString = new String(utf8Bytes, "GBK");
            System.out.println("错误的解码: " + wrongString);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，我们首先将原始字符串originalString使用UTF-8和GBK编码，然后分别使用相同的字符集进行解码，最后输出结果。我们还展示了一个错误的解码示例，即使用错误的字符集解码，这会导致乱码。

C++中的友元（Friend）概念、用法及使用场景

Wed, 12 Mar 2025 00:00:00 GMT

概念

在C++中，友元是一种允许非成员函数或另一个类访问类的私有（private）和受保护（protected）成员的机制。友元可以打破类的封装性，使得特定的函数或类能够访问到类的内部实现细节。

用法

友元函数
- 定义：友元函数可以是普通的非成员函数，也可以是其他类的成员函数。
- 声明：在类的内部使用friend关键字来声明友元函数。
- 访问：友元函数可以访问类的所有成员，包括私有和受保护成员。
友元类
- 定义：一个类可以声明另一个类为它的友元，这样友元类的所有成员函数都可以访问第一个类的私有和受保护成员。
- 声明：在类的内部使用friend关键字来声明友元类。 示例代码：

#include <iostream>
class Box {
private:
    double width;
public:
    Box() : width(0) {}
    // 声明友元函数
    friend void setWidth(Box& b, double w);
    // 声明友元类
    friend class BoxFriend;
};
// 定义友元函数
void setWidth(Box& b, double w) {
    b.width = w;
}
class BoxFriend {
public:
    void displayWidth(const Box& b) {
        std::cout << "Width of box: " << b.width << std::endl;
    }
};
int main() {
    Box box;
    setWidth(box, 10.0); // 使用友元函数设置宽度
    BoxFriend bf;
    bf.displayWidth(box); // 使用友元类显示宽度
    return 0;
}

使用场景

操作符重载：在实现操作符重载时，常常需要访问类的私有成员，此时可以将重载函数声明为友元函数。
辅助函数：某些辅助函数需要直接访问类的内部状态，而不需要成为类的成员，此时可以使用友元函数。
类间协作：当两个类需要紧密协作，且其中一个类需要频繁访问另一个类的内部成员时，可以将其中一个类声明为另一个类的友元。
测试：在单元测试中，有时需要访问类的私有成员以进行更彻底的测试，此时可以使用友元。

注意事项

友元关系不是对称的，如果类A是类B的友元，并不意味着类B是类A的友元。
友元关系不能传递，如果类A是类B的友元，类B是类C的友元，并不意味着类A是类C的友元。
使用友元会破坏类的封装性，因此应谨慎使用，只有在确实需要时才使用。

总结：

友元是C++中一种强大的机制，允许特定的函数或类访问类的私有和受保护成员。尽管它提供了灵活性，但也会破坏封装性，因此应谨慎使用。在操作符重载、辅助函数、类间协作和测试等场景中，友元可以发挥重要作用。

const的用法

Wed, 12 Mar 2025 00:00:00 GMT

const是C++中的一个关键字，用于声明变量、函数参数、返回值或成员函数为常量，即它们的值在初始化后不能被修改。const的用法非常灵活，可以用于多种场景，以下是一些主要的用法：

常量变量

const int MAX_SIZE = 100;

这里，MAX_SIZE被声明为一个常量，其值在初始化后不能改变。

指向常量的指针

const int *ptr = &MAX_SIZE;

ptr是一个指向常量的指针，不能通过ptr来修改MAX_SIZE的值。

常量指针

int value = 10;
int *const ptr = &value;

ptr是一个常量指针，它始终指向value，但不能指向其他变量。

指向常量的常量指针

const int value = 10;
const int *const ptr = &value;

ptr既不能改变指向的值，也不能改变指向的地址。

常量引用

const int &ref = value;

ref是value的常量引用，不能通过ref来修改value。

常量成员函数

在类中，可以声明成员函数为const，表示这个函数不会修改类的成员变量。

class MyClass {
public:
    int getValue() const {
        return value;
    }
private:
    int value;
};

常量表达式

C++11引入了constexpr，用于声明常量表达式，这些表达式在编译时就能计算出来。

constexpr int factorial(int n) {
    return (n <= 1) ? 1 : n * factorial(n - 1);
}
constexpr int result = factorial(5); // 在编译时计算

对象常量

可以声明对象为常量，这样对象的成员就不能被修改。

const MyClass obj;

常量与多态

const成员函数可以用于多态，因为它们可以被子类覆盖，并且保持const属性。

class Base {
public:
    virtual void display() const {
        // ...
    }
};
class Derived : public Base {
public:
    void display() const override {
        // ...
    }
};

常量与模板

const可以与模板一起使用，以创建通用的常量类型。

template<typename T>
void print(const T& value) {
    // ...
}

保护参数

函数的参数可以加上const修饰，以避免无意识的修改const变量。

通过指针可以绕过const修饰，但这种方法不推荐，因为它破坏了const的语义，可能导致未定义行为。

示例：

void modifyValue(const int* value) {
    int* nonConstPtr = const_cast<int*>(value); // 强制转换去除const
    *nonConstPtr = 10; // 修改值
}

int main() {
    int a = 5;
    modifyValue(&a);
    std::cout << a << std::endl; // 输出10
    return 0;
}

注意： 使用const_cast时要非常小心，因为它破坏了常量性，可能导致未定义行为，特别是如果原始数据确实不应该被修改时。

注意事项：

const变量必须在声明时初始化，除非它是静态存储期变量。
const对象只能调用const成员函数。
const指针和const引用可以指向非const对象，但通过它们不能修改对象的值。
const在函数参数中用于表示参数不会被修改，这有助于提高代码的可读性和安全性。 const的这些用法有助于编写更安全、更可维护的代码，通过限制变量的可变性，可以避免一些常见的编程错误。

智能指针

Wed, 12 Mar 2025 00:00:00 GMT

C++中的智能指针

智能指针是C++中用于管理动态内存的一种机制，它封装了原始指针，提供了自动的内存管理功能，从而帮助程序员避免内存泄漏、指针越界等常见问题。C++11引入了三种主要的智能指针类型：unique_ptr、shared_ptr和weak_ptr。

1. `unique_ptr`

unique_ptr是独占式的智能指针，它确保同一时间只有一个智能指针可以指向某个动态分配的对象。当unique_ptr被销毁时，它所管理的对象也会被自动销毁。 基本用法：

#include <memory>
int main() {
    std::unique_ptr<int> ptr1(new int(10));  // 创建一个unique_ptr
    // std::unique_ptr<int> ptr2 = ptr1;  // 错误，不能复制unique_ptr
    std::unique_ptr<int> ptr3 = std::move(ptr1);  // 转移所有权
    if (ptr1 == nullptr) {
        // 此时ptr1不再拥有对象
    }
    // 使用ptr3
    *ptr3 = 20;
    return 0;  // ptr3自动释放内存
}

特点：

独占性：不能共享所管理的对象，不能进行复制操作，但可以转移所有权。
自动释放：当unique_ptr离开作用域时，自动释放所管理的对象。
高效：由于独占性，不需要引用计数，效率较高。

2. `shared_ptr`

shared_ptr是共享式的智能指针，允许多个智能指针共享同一个动态分配的对象。它通过引用计数来管理对象的生命周期，当引用计数为0时，对象被自动销毁。 基本用法：

#include <memory>
int main() {
    std::shared_ptr<int> ptr1(new int(10));  // 创建一个shared_ptr
    std::shared_ptr<int> ptr2 = ptr1;  // 复制shared_ptr，引用计数+1
    {
        std::shared_ptr<int> ptr3 = ptr1;  // 引用计数+1
        // 使用ptr3
    }  // ptr3离开作用域，引用计数-1
    // 使用ptr1和ptr2
    *ptr1 = 20;
    return 0;  // ptr1和ptr2离开作用域，引用计数为0，对象被销毁
}

特点：

共享性：多个shared_ptr可以共享同一个对象。
引用计数：内部维护一个引用计数，用于管理对象的生命周期。
自动释放：当引用计数为0时，自动释放对象。

3. `weak_ptr`

weak_ptr是一种弱引用智能指针，它不增加引用计数，主要用于解决shared_ptr可能引起的循环引用问题。 基本用法：

#include <memory>
int main() {
    std::shared_ptr<int> ptr1(new int(10));
    std::weak_ptr<int> weakPtr = ptr1;  // 创建一个weak_ptr
    if (std::shared_ptr<int> sharedPtr = weakPtr.lock()) {  // 尝试提升为shared_ptr
        // 对象存在，可以使用sharedPtr
    } else {
        // 对象已被销毁
    }
    return 0;  // ptr1离开作用域，对象被销毁，weakPtr变为空
}

特点：

弱引用：不增加引用计数，不会影响对象的生命周期。
提升：可以通过lock()方法尝试提升为shared_ptr，如果对象存在，则提升成功，否则返回空shared_ptr。
解决循环引用：常用于解决shared_ptr之间的循环引用问题。

智能指针的优势

自动管理内存：减少手动管理内存的需求，降低内存泄漏和指针错误的风险。
提高代码安全性：通过封装原始指针，提供更安全的操作方式。
简化代码：减少内存管理相关的代码，使代码更简洁易读。

注意事项

避免与原始指针混用：智能指针和原始指针混用可能导致未定义行为。
正确使用new和delete：使用智能指针后，应避免手动调用new和delete。
理解循环引用：在使用shared_ptr时，注意循环引用问题，必要时使用weak_ptr。智能指针是C++现代编程中非常重要的特性，合理使用智能指针可以大大提高代码的健壮性和可维护性。

使用`std::unique_ptr`

场景：当你想要确保只有一个指针拥有对动态分配对象的访问权时。示例：

#include <iostream>
#include <memory>
class Resource {
public:
    void use() {
        std::cout << "Using resource" << std::endl;
    }
    ~Resource() {
        std::cout << "Resource destroyed" << std::endl;
    }
};
int main() {
    // 创建一个unique_ptr管理Resource对象
    std::unique_ptr<Resource> resPtr(new Resource());
    // 使用资源
    resPtr->use();
    // 不需要手动删除资源，resPtr离开作用域时会自动删除
    return 0;
}

使用技巧：

使用std::make_unique（C++14起可用）来创建unique_ptr，避免内存分配和构造函数调用之间的异常安全问题。
- auto resPtr = std::make_unique<Resource>();
在函数中返回unique_ptr，以转移所有权。
在容器中存储unique_ptr，以管理动态数组。

使用`std::shared_ptr`

场景：当你需要多个指针共享对同一个动态分配对象的访问权时。示例：

#include <iostream>
#include <memory>
class Resource {
public:
    void use() {
        std::cout << "Using resource" << std::endl;
    }
    ~Resource() {
        std::cout << "Resource destroyed" << std::endl;
    }
};
int main() {
    // 创建shared_ptr
    std::shared_ptr<Resource> sharedRes = std::make_shared<Resource>();
    // 复制shared_ptr
    std::shared_ptr<Resource> anotherSharedRes = sharedRes;
    // 使用资源
    sharedRes->use();
    anotherSharedRes->use();
    // 当所有shared_ptr都离开作用域时，资源会被自动删除
    return 0;
}

使用技巧：

使用std::make_shared来创建shared_ptr，以提高效率。
注意避免循环引用，这会导致内存泄漏。
在需要共享资源的多线程环境中使用shared_ptr。

使用`std::weak_ptr`

场景：用于解决std::shared_ptr的循环引用问题，或者当你需要观察某个对象是否存在而不影响其生命周期时。示例：

#include <iostream>
#include <memory>
class Resource {
public:
    void use() {
        std::cout << "Using resource" << std::endl;
    }
    ~Resource() {
        std::cout << "Resource destroyed" << std::endl;
    }
};
int main() {
    std::shared_ptr<Resource> sharedRes = std::make_shared<Resource>();
    std::weak_ptr<Resource> weakRes = sharedRes;
    // 尝试提升weak_ptr到shared_ptr
    if (std::shared_ptr<Resource> tempRes = weakRes.lock()) {
        tempRes->use();
    } else {
        std::cout << "Resource is no longer available" << std::endl;
    }
    // 销毁shared_ptr
    sharedRes.reset();
    // 再次尝试提升
    if (weakRes.expired()) {
        std::cout << "Resource has been destroyed" << std::endl;
    }
    return 0;
}

使用技巧：

使用weak_ptr来打破shared_ptr的循环引用。
在需要观察对象是否存在时，使用weak_ptr而不影响对象的生命周期。
使用weak_ptr::lock来安全地访问对象，如果对象已被销毁，则返回一个空的shared_ptr。

C++的结构绑定

Wed, 12 Mar 2025 00:00:00 GMT

C++的结构绑定（Structure Binding）是C++17引入的一项新特性，它允许我们将一个聚合类型（如结构体、数组等）的成员直接绑定到一组变量上，从而简化了代码的编写和阅读。这项特性在很多情况下可以使代码更加简洁和直观。

基本概念

聚合类型：在C++中，聚合类型包括数组、结构体（struct）、联合体（union）以及类（class），但这些类必须满足一定的条件，比如没有私有或保护成员、没有用户定义的构造函数等。 结构绑定：允许我们创建一个或多个变量，这些变量直接绑定到聚合类型的成员上。

使用方法

1. 绑定结构体成员

假设我们有一个简单的结构体：

struct Point {
    int x;
    int y;
};

在没有结构绑定之前，如果我们想获取一个点对象的x和y值，我们可能需要这样做：

Point p = {1, 2};
int x = p.x;
int y = p.y;

使用结构绑定，我们可以这样写：

Point p = {1, 2};
auto [px, py] = p;

这里，px 和 py 分别绑定了 p.x 和 p.y。

2. 绑定数组元素

对于数组，结构绑定同样有效：

int arr[3] = {1, 2, 3};
auto [a, b, c] = arr;

这里，a、b 和 c 分别绑定了 arr[0]、arr[1] 和 arr[2]。

注意事项

类型推导：结构绑定使用 auto 关键字进行类型推导，因此编译器会自动推导出每个绑定变量的类型。
生命周期：绑定变量的生命周期与被绑定对象的生命周期相关联。如果被绑定对象销毁，绑定变量也将变得无效。
const属性：如果被绑定对象是 const 的，那么绑定变量也将是 const 的。
引用绑定：可以使用引用来绑定成员，这样对绑定变量的修改会反映到原始对象上。

Point p = {1, 2};
auto& [px, py] = p;
px = 3;  // 修改p.x的值

嵌套结构：结构绑定也支持嵌套结构。

struct Rect {
    Point top_left;
    Point bottom_right;
};
Rect r = {{1, 2}, {3, 4}};
auto [tl, br] = r;
auto [tlx, tly] = tl;

这里，tl 和 br 分别绑定了 r.top_left 和 r.bottom_right，而 tlx 和 tly 进一步绑定了 tl.x 和 tl.y。

应用场景

结构绑定在需要快速访问结构体或数组成员的场景中非常有用，比如：

返回多个值的函数。
遍历映射（map）或其他关联容器。
处理元组（tuple）数据。

#include<iostream>
using namespace std;
struct S {
    int a;
    int b;
};
auto f() {
    return S{1, 2};
}
int main(void) {
    auto [a, b] = f();
    cout << a << " " << b << endl;
    return 0;
}

这段代码展示了如何使用结构化绑定（structured bindings）来解构一个结构体，并输出其成员变量的值。定义了一个结构体 S，它包含两个整数成员变量a,b。然后，定义了一个函数 f()，该函数返回一个 S类型的对象，并初始化其成员变量a, b分别为 1 和 2。在main 函数中，使用了 C++17 引入的结构化绑定特性。通过 auto [a, b] = f();，可以将返回的类型对象的成员变量a和 b分别绑定到新的变量上。这样，便可以直接使用这些变量，而不需要通过结构体对象来访问其成员变量。

结论

结构绑定是C++17引入的一项强大特性，它简化了代码，提高了可读性。通过结构绑定，我们可以更直观地处理聚合类型的数据，使C++代码更加现代化和易于维护。

Stream API

Wed, 12 Mar 2025 00:00:00 GMT

Java 8引入了Stream API，这是一个用于处理集合的强大工具，它可以让你以声明式的方式处理数据。List是Java集合框架中的一个接口，表示一个有序的集合（也称为序列）。当你有一个List并且想要使用Stream来处理它时，你可以利用Stream API提供的各种操作来进行转换、过滤、排序、聚合等操作。

创建Stream

从List创建Stream非常简单，只需要调用stream()方法即可：

List<String> list = Arrays.asList("apple", "banana", "cherry");
Stream<String> stream = list.stream();

如果你想要并行处理，可以使用parallelStream()方法：

Stream<String> parallelStream = list.parallelStream();

只有单列集合才有stream，双列集合需要进一步操作：

HashMap<String, Integer> hm = new HashMap<>();
hm.keySet().stream();
hm.entrySet().stream;

数组获取stream：

int[] arr = {1, 2, 3, 4, 5, 6};
Arrays.stream(arr);

同时，stream中的静态方法of可以针对一些零散的数据获取stream流。

Stream.of(1, 2, 3, 4, 5, 6);
Srream.of(arr); // 可变参类型，如果传递的是数组，那么数组必须是引用类型

中间操作

中间操作会返回一个新的Stream，允许操作链继续下去。

注意：流中进行的修改不会影响原数据

常见的中间操作包括：

方法名	说明
Stream<T> filter(Predicate predicate)	用于对流中的数据进行过滤
Stream<T> limit(long maxSize)	返回此流中的元素组成的流，截取前指定参数个数的数据
Stream<T> skip(long n)	跳过指定参数个数的数据，返回由该流的剩余元素组成的流
static <T> Stream<T> concat(Stream a, Stream b)	合并a和b两个流为一个流
Stream<T> distinct()	返回由该流的不同元素（根据Object.equals(Object) ）组成的流
Stream<T> map(Function<T, R>)	转换元素。

例如：

// 过滤出长度大于4的字符串，并将其转换为大写
List<String> result = list.stream()
                          .filter(s -> s.length() > 4)
                          .map(String::toUpperCase)
                          .collect(Collectors.toList());
Stream.concat(list1.stream(), list2.stream()).collect(Collectors.toList());

list.stream().map(new Function<String, Integer>(){
    @Override
    public Integer apply(String s){
    	String[] arr = s.split("-");
        return Integer.parseInt(arr[1]);
    }
}).forEach(s -> System.out.println(s));

list.stream()
    .map(s -> Integer.parseInt(s.split("-")[1]))
    .forEach(s -> System.out.println(s));

终端操作

终端操作会触发Stream的执行，并产生一个结果或副作用。常见的终端操作包括：

collect(Collector<T, A, R>)：收集元素到另一个集合中。
toArray(IntFunction<? extends Object[]>): 转为数组。
reduce(T, BinaryOperator<T>)：将元素聚合为一个值。
forEach(Consumer<T>)：对每个元素执行操作。
count()：返回元素数量。
findFirst() / findAny()：返回第一个或任意一个元素。
anyMatch(Predicate<T>) / allMatch(Predicate<T>) / noneMatch(Predicate<T>)：检查是否有元素匹配给定条件。例如：

//计算所有字符串长度的总和
int totalLength = list.stream()
                      .mapToInt(String::length)
                      .count();

// toArray
String[] arr = list.stream().toArray(new IntFunction<String[]>(){
    @Override
    public String[] apply(int value){
        return new String[value];
    }
});

String[] arr = list.stream()
    .toArray(v->new String[value]);

List<String> newlist = list.stream()
    .filer(s->"男".equals(s))
    .collect(Collectors.toList());

//姓名-性别-ID
// 使用map，map中的键不能重复
Map<String, Integer> map = list.stream()
    .filter(s -> "男".equals(s.split("-")[1]))
    .collect(Collectors.toMap(new Function<String, String>(){
        @Override
        public String apply(String s) {
            return s.split("-")[0];
        }
    },new Function<String, Integer>(){
        @Override
        public Integer apply(String s) {
            return Integer.parseInt(s.split("-")[2]);
        }
    }));

Map<String, Integer> map = list.stream()
    .filter(s -> "男".equals(s.split("-")[1]))
    .collect(Collectors.toMap(
        s->s.split("-")[0],
        s-> Integer.parseInt(s.split("-")[2])));

短路操作

短路操作可以提前结束Stream的遍历。例如：

anyMatch(Predicate<T>)：只要有一个元素匹配就返回true，不再继续检查。
findFirst()：找到第一个元素就返回，不再继续查找。

使用示例

下面是一个完整的示例，展示了如何使用Stream来处理一个字符串列表：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamExample {
    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("apple", "banana", "cherry", "date", "fig", "grape");
        // 过滤出长度大于4的单词，转换为大写，并排序
        List<String> processedFruits = fruits.stream()
                                             .filter(fruit -> fruit.length() > 4)
                                             .map(String::toUpperCase)
                                             .sorted()
                                             .collect(Collectors.toList());
        // 输出结果
        processedFruits.forEach(System.out::println);
    }
}

这个示例中，我们首先过滤出长度大于4的单词，然后将它们转换为大写字母，接着对结果进行排序，并最终收集到一个新的列表中。

注意事项

Stream只能被消费一次，一旦进行了终端操作，就不能再使用这个Stream了。
Stream操作不会修改原始数据源，它们是惰性的，只有在终端操作时才会执行。
并行Stream可能会提高性能，但也可能导致线程安全问题，需要谨慎使用。通过Stream API，你可以以更简洁、更声明式的方式处理集合数据，这使得代码更易于理解和维护。

HashMap源码

Wed, 12 Mar 2025 00:00:00 GMT

内部定义

Node

基本哈希表的节点，用于大多数条目。哈希表内部存储键值对时，采用Node进行存储。

// Node节点实现Map.Entry接口
// 该接口主要包含以下方法：
// K getKey();
// V getValue();
// V setValue(V value);
// boolean equals(Object o);
static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;	// 键的哈希值
    final K key;	// 建
    V value;		// 值
    Node<K,V> next; // 下一个节点的地址
	...   
}

红黑树

当单个节点下挂载的链表长度超过一定值(8)时，会转换为红黑树。

 static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
     TreeNode<K,V> parent;  // red-black tree links
     TreeNode<K,V> left;
     TreeNode<K,V> right;
     TreeNode<K,V> prev;    // needed to unlink next upon deletion
     boolean red;
     ...
 }

内部节点表

HashMap内部存储数据的表，表在首次使用时初始化，并根据需要调整大小。分配后，长度始终为 2 的幂。

transient Node<K,V>[] table;

默认容量

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

默认加载因子

static final float DEFAULT_LOAD_FACTOR = 0.75f;

构造函数

public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

默认构造函数不会初始化内部的节点表，节点表在首次使用时才会进行初始化。

Put操作

操作定义如下：

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

如果覆盖了元素，则返回覆盖元素的值，否则返回null。

put方法中的hash函数的定义如下：

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

利用键计算出对应的hash值，并经过一系列位操作以优化哈希表的性能，最后把返回值作为键的哈希值。

put方法中putVal函数定义如下：

添加元素的时候至少考虑三种情况：

数组位置为null
数组位置不为null，键不重复，挂在下面形成链表或者红黑树
数组位置不为null，键重复，元素覆盖

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; //定义一个局部变量，用来记录哈希表中数组的地址值。
    Node<K,V> p; 	 //临时的第三方变量，用来记录键值对对象的地址值
    int n, i;		 //n表示当前数组的长度，i表示索引
    //把哈希表中数组的地址值，赋值给局部变量tab
    if ((tab = table) == null || (n = tab.length) == 0)
        //resize()函数执行以下操作：
        //1.如果当前是第一次添加数据，底层会创建一个默认长度为16，加载因子为0.75的数组
        //2.如果不是第一次添加数据，会看数组中的元素是否达到了扩容的条件
        //如果没有达到扩容条件，底层不会做任何操作
        //如果达到了扩容条件，底层会把数组扩容为原先的两倍，并把数据全部转移到新的哈希表中
        n = (tab = resize()).length;
    	//表示把当前数组的长度赋值给n
    
    //将数组的长度跟键的哈希值进行计算，计算出当前键值对对象，在数组中应存入的位置
    //获取数组中对应元素的数据
    if ((p = tab[i = (n - 1) & hash]) == null)
        //如果获取到的值是null，底层会创建一个键值对对象，直接放到数组当中
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            
            e = p;
        else if (p instanceof TreeNode)
            //判断数组中获取出来的键值对是不是红黑树中的节点
			//如果是，则调用方法putTreeVal，把当前的节点按照红黑树的规则添加到树当中。
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            //如果从数组中获取出来的键值对不是红黑树中的节点
			//表示此时下面挂的是链表
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    //此时就会创建一个新的节点，挂在下面形成链表
                    p.next = newNode(hash, key, value, null);
                    //判断当前链表长度是否超过8，如果超过8，就会调用方法treeifyBin
                    //treeifyBin方法的底层还会继续判断
                    //判断数组的长度是否大于等于64
                    //如果同时满足这两个条件，就会把这个链表转成红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                //如果哈希值一样（哈希碰撞），就会调用equals方法比较内部的属性值是否相同，若相同则break
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        //判断是否有元素的覆盖
        if (e != null) { // existing mapping for key 
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                // 仅修改数据，而不修改节点
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    //threshold：记录的就是数组的长度 * 0.75，哈希表的扩容时机  16 * 0.75 = 12
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    //表示当前没有覆盖任何元素，返回null
    return null;
}

参数：
- 键的哈希值
- 键
- 值
- 如果为true，则只有在键不存在时才插入新值。如果键已经存在，则不会替换现有的值。这个参数在putIfAbsent方法中会用到。
- 这个参数在putVal方法中的默认值为false。它在LinkedHashMap的子类中用于控制是否在插入后执行删除操作。在HashMap中，这个参数通常不被使用。
putVal方法的工作原理大致如下：
- 计算键的哈希值，并找到对应的桶（bucket）。
- 检查桶中是否已经有键值对。如果有，则根据键的相等性（equals方法）检查是否是同一个键。
- 如果是同一个键，根据onlyIfAbsent参数决定是否更新值。
- 如果不是同一个键，或者桶为空，则将新的键值对插入到桶中。
- 如果插入后桶的大小超过了负载因子与容量的乘积，则进行扩容操作。

这个方法的设计考虑了性能和线程安全（在ConcurrentHashMap中）。在HashMap中，它不是线程安全的，但在ConcurrentHashMap中，putVal方法会采用不同的策略来保证线程安全。

参考视频

java学习笔记（6）

Wed, 12 Mar 2025 00:00:00 GMT

注解

Java注解（Annotation）是一种用于提供元数据（metadata）的机制，它允许我们在代码中嵌入补充信息，这些信息可以在编译时、运行时或部署时被读取和使用。注解不会改变程序的运行逻辑，但可以改变程序的处理方式。

注解的基本概念

注解定义：注解是通过@interface关键字定义的。
注解使用：注解可以用于类、方法、字段、参数、局部变量等位置。
注解Retention：注解的保留策略，指定注解在什么时期有效（源码阶段、编译阶段、运行时）。
注解Target：注解的目标，指定注解可以用于哪些元素。

内置注解

Java提供了几种内置注解：

@Override：表示一个方法声明旨在重写超类中的另一个方法。
@Deprecated：表示不推荐使用该元素，通常是因为它很危险或存在更好的选择。
@SuppressWarnings：表示在编译期间忽略指定的警告。

自定义注解

可以创建自定义注解来满足特定需求：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface MyAnnotation {
    String value() default "default";
    int count() default 0;
}

注解元素

注解可以包含元素，类似于方法：

元素类型：可以是基本类型、String、Class、枚举、注解或这些类型的数组。
默认值：可以为元素提供默认值。

注解的使用

@MyAnnotation(value = "example", count = 10)
public class MyClass {
    @MyAnnotation
    public void myMethod() {
    }
}

注解处理

注解本身不包含行为，它们的行为是通过注解处理器来实现的。注解处理器可以在编译时或运行时读取注解并执行相应操作。

编译时处理：使用注解处理器（Annotation Processor）在编译时读取注解并生成代码或执行检查。
运行时处理：通过反射在运行时读取注解并执行操作。

示例：运行时注解处理

public class AnnotationProcessor {
    public static void main(String[] args) throws NoSuchMethodException {
        MyClass obj = new MyClass();
        if (obj.getClass().isAnnotationPresent(MyAnnotation.class)) {
            MyAnnotation annotation = obj.getClass().getAnnotation(MyAnnotation.class);
            System.out.println("Value: " + annotation.value());
            System.out.println("Count: " + annotation.count());
        }
    }
}

注解的优点

提供元数据：为代码提供额外的信息，而不改变代码本身。
简化代码：减少编写重复代码的需要。
增强功能：通过注解可以实现一些特殊功能，如依赖注入、权限控制等。

注解的局限性

性能影响：运行时注解处理可能影响性能。
复杂性：过度使用注解可能导致代码复杂度增加。注解是Java中一个非常强大和灵活的特性，它可以用于各种场景，如框架开发、代码生成、验证等。正确使用注解可以大大提高开发效率和代码质量。

FunctionalInterface

在Java中，FunctionalInterface是一个用于标注接口的注解，它表示该接口是一个函数式接口。函数式接口是Java 8引入的一个新概念，它是指只包含一个抽象方法的接口。这样的接口可以用来表示lambda表达式或者方法引用。

FunctionalInterface的特性

单一抽象方法：函数式接口只能有一个抽象方法。但是它可以包含多个默认方法（default method）和静态方法（static method）。
允许继承方法：如果接口继承了另一个接口的抽象方法，那么这个方法不会计入抽象方法的总数内。
Object类的方法：函数式接口可以包含Object类的方法，如toString()、equals()等，这些方法不会计入抽象方法的总数内。

FunctionalInterface的使用

使用@FunctionalInterface注解可以确保接口满足函数式接口的定义。如果接口中定义了超过一个抽象方法，编译器将会报错。

@FunctionalInterface
public interface SimpleFunction {
    // 单一抽象方法
    int apply(int value);
    // 默认方法，不会影响FunctionalInterface的单一抽象方法规则
    default void printValue(int value) {
        System.out.println(value);
    }
    // 静态方法，同样不会影响
    static void printMessage(String message) {
        System.out.println(message);
    }
    // Object类的方法，不会计入抽象方法总数
    @Override
    String toString();
}

FunctionalInterface的好处

保证接口的函数式特性：通过编译器检查，确保接口只有一个抽象方法，适合用于lambda表达式。
提高代码可读性：使用@FunctionalInterface注解的接口，其目的和用法更加明确，提高了代码的可读性。
支持泛型：函数式接口可以定义泛型方法，增加了接口的灵活性和适用性。

常见的FunctionalInterface

Java 8的java.util.function包中定义了许多常用的函数式接口，如：

Predicate<T>：用于表示一个参数的布尔表达式。
Consumer<T>：表示一个接受一个参数并且没有返回值的操作。
Function<T, R>：表示一个接受一个参数并且返回结果的操作。
Supplier<T>：表示一个没有参数但是返回结果的操作。
UnaryOperator<T>：表示一个接受一个参数并且返回相同类型结果的操作。
BinaryOperator<T>：表示一个接受两个相同类型的参数并且返回相同类型结果的操作。

示例

import java.util.function.Function;
public class FunctionalInterfaceExample {
    public static void main(String[] args) {
        // 使用lambda表达式实现Function接口
        Function<Integer, Integer> square = x -> x * x;
        System.out.println(square.apply(5)); // 输出25
    }
}

在这个示例中，我们定义了一个Function<Integer, Integer>类型的变量square，它接受一个Integer类型的参数并返回一个Integer类型的结果。我们使用lambda表达式x -> x * x来表示这个函数，它将输入的数平方后返回。通过@FunctionalInterface，Java提供了一种简洁、高效的方式来表示和操作函数式编程中的函数。这在Java 8及以后的版本中极大地增强了Java语言的表达能力和灵活性。

ArrayList初始化

在Java中，ArrayList 是一个常用的动态数组实现，它允许你存储和操作对象。当你想要在定义时给 ArrayList 赋值，你可以使用多种方法，包括使用匿名内部类、使用双括号初始化（注意可能带来的潜在问题）或者使用Java 9及以上版本的集合工厂方法。以下是一些示例：

1. 使用匿名内部类

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>() {{
            add("Apple");
            add("Banana");
            add("Cherry");
        }};
        System.out.println(list);
    }
}

2. 使用双括号初始化（不推荐用于多线程环境）

import java.util.ArrayList;
import java.util.List;
public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>() {{
            add("Apple");
            add("Banana");
            add("Cherry");
        }};
        System.out.println(list);
    }
}

注意：双括号初始化会创建一个匿名内部类，这可能会导致内存泄漏或者在序列化时出现问题。

3. 使用Java 9的集合工厂方法

如果你使用的是Java 9或更高版本，你可以使用List.of()方法来创建一个不可变的列表：

import java.util.List;
public class Main {
    public static void main(String[] args) {
        List<String> list = List.of("Apple", "Banana", "Cherry");
        System.out.println(list);
    }
}

注意：List.of()创建的列表是不可变的，即不能添加、删除或替换元素。

4. 使用Arrays.asList（注意返回的列表是固定大小的）

import java.util.Arrays;
import java.util.List;
public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Apple", "Banana", "Cherry");
        System.out.println(list);
    }
}

注意：Arrays.asList()返回的列表是固定大小的，不支持添加或删除操作，但可以修改元素。

HashMap初始化

是的，HashMap也有类似的写法。在Java中，HashMap是一个常用的键值对存储结构，你可以在定义时给它赋值。以下是一些示例：

1. 使用匿名内部类

import java.util.HashMap;
import java.util.Map;
public class Main {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>() {{
            put("key1", "value1");
            put("key2", "value2");
            put("key3", "value3");
        }};
        System.out.println(map);
    }
}

2. 使用双括号初始化（不推荐用于多线程环境）

import java.util.HashMap;
import java.util.Map;
public class Main {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>() {{
            put("key1", "value1");
            put("key2", "value2");
            put("key3", "value3");
        }};
        System.out.println(map);
    }
}

3. 使用Java 9及以上的集合工厂方法

import java.util.Map;
public class Main {
    public static void main(String[] args) {
        Map<String, String> map = Map.of(
            "key1", "value1",
            "key2", "value2",
            "key3", "value3"
        );
        System.out.println(map);
    }
}

注意：Map.of()创建的映射是不可变的，即不能添加、删除或替换键值对。

4. 使用Stream API（Java 8及以上）

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Main {
    public static void main(String[] args) {
        Map<String, String> map = Stream.of(
            new AbstractMap.SimpleEntry<>("key1", "value1"),
            new AbstractMap.SimpleEntry<>("key2", "value2"),
            new AbstractMap.SimpleEntry<>("key3", "value3")
        ).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
        System.out.println(map);
    }
}

5. 使用Collections.unmodifiableMap（创建不可变映射）

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
public class Main {
    public static void main(String[] args) {
        Map<String, String>modifiableMap = new HashMap<>();
        modifiableMap.put("key1", "value1");
        modifiableMap.put("key2", "value2");
        modifiableMap.put("key3", "value3");
        Map<String, String> map = Collections.unmodifiableMap(modifiableMap);
        System.out.println(map);
    }
}

注意：Collections.unmodifiableMap()创建的映射是不可变的，即不能添加、删除或替换键值对。

方法二（双括号初始化）不推荐在多线程环境中使用的原因主要与Java的匿名内部类和实例变量的初始化顺序有关。以下是详细解释：

1. 匿名内部类的实例变量

当你使用双括号初始化时，实际上是在创建一个匿名内部类的实例。这个匿名内部类会捕获外部类的实例变量（如果有的话），并且在内部类中创建一个新的HashMap实例。

2. 实例变量的初始化顺序

在Java中，实例变量的初始化顺序是先执行父类的构造方法，然后是子类的成员变量初始化，最后是子类的构造方法。当你在一个类的构造方法中使用双括号初始化时，这个初始化过程可能会在这个类的实例完全构造完成之前开始。

3. 多线程环境中的问题

在多线程环境中，如果多个线程同时访问同一个尚未完全构造的对象，就可能导致以下问题：

可见性：一个线程对共享变量的修改可能对其他线程不可见。
竞态条件：多个线程同时读取和修改共享数据，导致不可预测的结果。由于双括号初始化涉及到捕获外部类的实例变量，如果在多线程环境中使用，就可能遇到上述问题。特别是当这个HashMap被多个线程共享时，就可能导致数据不一致或其他并发问题。

4. 示例

以下是一个简化的示例，说明为什么双括号初始化在多线程环境中可能有问题：

public class SomeClass {
    private Map<String, String> map = new HashMap<String, String>() {{
        put("key1", "value1");
        put("key2", "value2");
    }};
    public SomeClass() {
        // 构造方法中的其他初始化代码
    }
    public Map<String, String> getMap() {
        return map;
    }
}

在这个示例中，如果多个线程在SomeClass的实例完全构造完成之前就调用getMap()方法，它们可能会看到一个未完全初始化的map。

为了避免这些潜在的问题，推荐在多线程环境中使用更明确和线程安全的方法来初始化HashMap，比如方法一（使用匿名内部类但不使用双括号）或其他线程安全的集合初始化方法。这样可以确保在多线程环境中对共享数据的访问是安全的。

不可变集合

不可变集合是一个长度不可变，内容也无法修改的集合

使用场景

如果某个数据不能被修改，把它防御性地拷贝到不可变集合中是个很好的实践。当集合对象被不可信的库调用时，不可变形式是安全的。

不可变的list集合

List<String> list = List.of("张三", "李四", "王五", "赵六");
System.out.println("---------------------------");
for (String s : list) {
    System.out.println(s);
}
System.out.println("---------------------------");
Iterator<String> it = list.iterator();
while(it.hasNext()){
    String s = it.next();
    System.out.println(s);
}
System.out.println("---------------------------");
for (int i = 0; i < list.size(); i++) {
    String s = list.get(i);
    System.out.println(s);
}
System.out.println("---------------------------");
//list.remove("李四");
//list.add("aaa");
list.set(0,"aaa");

不可变的Set集合

Set<String> set = Set.of("张三", "张三", "李四", "王五", "赵六");
for (String s : set) {
    System.out.println(s);
}
System.out.println("-----------------------");
Iterator<String> it = set.iterator();
while(it.hasNext()){
    String s = it.next();
    System.out.println(s);
}
System.out.println("-----------------------");
//set.remove("王五");

不可变的Map集合

键值对个数小于等于10

public class ImmutableDemo3 {
    public static void main(String[] args) {
       /*
        创建Map的不可变集合
            细节1：
                键是不能重复的
            细节2：
                Map里面的of方法，参数是有上限的，最多只能传递20个参数，10个键值对
            细节3：
                如果我们要传递多个键值对对象，数量大于10个，在Map接口中还有一个方法
        */

        //一旦创建完毕之后，是无法进行修改的，在下面的代码中，只能进行查询操作
        Map<String, String> map = Map.of("张三", "南京", "张三", "北京", "王五", "上海", "赵六", "广州", "孙七", "深圳", "周八", "杭州", "吴九", "宁波", "郑十", "苏州", "刘一", "无锡", "陈二", "嘉兴");
        Set<String> keys = map.keySet();
        for (String key : keys) {
            String value = map.get(key);
            System.out.println(key + "=" + value);
        }
        System.out.println("--------------------------");
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "=" + value);
        }
        System.out.println("--------------------------");
    }
}

键值对个数大于10

public class ImmutableDemo4 {
    public static void main(String[] args) {

        /*
            创建Map的不可变集合,键值对的数量超过10个
        */

        //1.创建一个普通的Map集合
        HashMap<String, String> hm = new HashMap<>();
        hm.put("张三", "南京");
        hm.put("李四", "北京");
        hm.put("王五", "上海");
        hm.put("赵六", "北京");
        hm.put("孙七", "深圳");
        hm.put("周八", "杭州");
        hm.put("吴九", "宁波");
        hm.put("郑十", "苏州");
        hm.put("刘一", "无锡");
        hm.put("陈二", "嘉兴");
        hm.put("aaa", "111");

        //2.利用上面的数据来获取一个不可变的集合
/*
        //获取到所有的键值对对象（Entry对象）
        Set<Map.Entry<String, String>> entries = hm.entrySet();
        //把entries变成一个数组
        Map.Entry[] arr1 = new Map.Entry[0];
        //toArray方法在底层会比较集合的长度跟数组的长度两者的大小
        //如果集合的长度 > 数组的长度 ：数据在数组中放不下，此时会根据实际数据的个数，重新创建数组
        //如果集合的长度 <= 数组的长度：数据在数组中放的下，此时不会创建新的数组，而是直接用
        Map.Entry[] arr2 = entries.toArray(arr1);
        //不可变的map集合
        Map map = Map.ofEntries(arr2);
        map.put("bbb","222");*/


        //Map<Object, Object> map = Map.ofEntries(hm.entrySet().toArray(new Map.Entry[0]));

        Map<String, String> map = Map.copyOf(hm);
        map.put("bbb","222");
    }
}

java学习笔记（5）

Tue, 11 Mar 2025 00:00:00 GMT

泛型

泛型方法

泛型方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。

java 中泛型标记符：

E - Element (在集合中使用，因为集合中存放的是元素)
T - Type（Java 类）
K - Key（键）
V - Value（值）
N - Number（数值类型）
？ - 表示不确定的 java 类型

public class GenericMethodTest
{
   // 泛型方法 printArray                         
   public static < E > void printArray( E[] inputArray )
   {
      // 输出数组元素            
         for ( E element : inputArray ){        
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }
 
    public static void main( String args[] )
    {
        // 创建不同类型数组： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
 
        System.out.println( "整型数组元素为:" );
        printArray( intArray  ); // 传递一个整型数组
 
        System.out.println( "\n双精度型数组元素为:" );
        printArray( doubleArray ); // 传递一个双精度型数组
 
        System.out.println( "\n字符型数组元素为:" );
        printArray( charArray ); // 传递一个字符型数组
    } 
}

可能有时候，会想限制那些被允许传递到一个类型参数的类型种类范围。例如，一个操作数字的方法可能只希望接受Number或者Number子类的实例。这就是有界类型参数的目的。

要声明一个有界的类型参数，首先列出类型参数的名称，后跟extends关键字，最后紧跟它的上界。

public class MaximumTest
{
   // 比较三个值并返回最大值
   public static <T extends Comparable<T>> T maximum(T x, T y, T z)
   {                     
      T max = x; // 假设x是初始最大值
      if ( y.compareTo( max ) > 0 ){
         max = y; //y 更大
      }
      if ( z.compareTo( max ) > 0 ){
         max = z; // 现在 z 更大           
      }
      return max; // 返回最大对象
   }
   public static void main( String args[] )
   {
      System.out.printf( "%d, %d 和 %d 中最大的数为 %d\n\n",
                   3, 4, 5, maximum( 3, 4, 5 ) );
 
      System.out.printf( "%.1f, %.1f 和 %.1f 中最大的数为 %.1f\n\n",
                   6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );
 
      System.out.printf( "%s, %s 和 %s 中最大的数为 %s\n","pear",
         "apple", "orange", maximum( "pear", "apple", "orange" ) );
   }
}

泛型类

泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。

和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。

import java.util.*;
 
public class GenericTest {
     
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        
        name.add("icon");
        age.add(18);
        number.add(314);
 
        //getUperNumber(name);//1
        getUperNumber(age);//2
        getUperNumber(number);//3
       
   }
 
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
   
   public static void getUperNumber(List<? extends Number> data) {
          System.out.println("data :" + data.get(0));
       }
}

在 //1 处会出现错误，因为 getUperNumber() 方法中的参数已经限定了参数泛型上限为 Number，所以泛型为 String 是不在这个范围之内，所以会报错。

3、类型通配符下限通过形如 List<? super Number> 来定义，表示类型只能接受 Number 及其上层父类类型，如 Object 类型的实例。

序列化

序列化在 Java 中是通过 java.io.Serializable 接口来实现的，该接口没有任何方法，只是一个标记接口，用于标识类可以被序列化。

import java.io.Serializable;

public class MyClass implements Serializable {
    // 类的成员和方法
}

序列化：

MyClass obj = new MyClass();
try {
    FileOutputStream fileOut = new FileOutputStream("object.ser");
    ObjectOutputStream out = new ObjectOutputStream(fileOut);
    out.writeObject(obj);
    out.close();
    fileOut.close();
} catch (IOException e) {
    e.printStackTrace();
}

反序列化：

MyClass obj = null;
try {
    FileInputStream fileIn = new FileInputStream("object.ser");
    ObjectInputStream in = new ObjectInputStream(fileIn);
    obj = (MyClass) in.readObject();
    in.close();
    fileIn.close();
} catch (IOException e) {
    e.printStackTrace();
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

Java数据结构

Tue, 11 Mar 2025 00:00:00 GMT

数组（Arrays）

数组（Arrays）是一种基本的数据结构，可以存储固定大小的相同类型的元素。

int[] array = new int[5];

特点： 固定大小，存储相同类型的元素。
优点： 随机访问元素效率高。
缺点： 大小固定，插入和删除元素相对较慢。

列表（Lists）

Java 提供了多种列表实现，如 ArrayList 和 LinkedList。

List<String> arrayList = new ArrayList<>();
List<Integer> linkedList = new LinkedList<>();

ArrayList:

ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，可以添加或删除元素。

import java.util.ArrayList; // 引入 ArrayList 类
ArrayList<E> objectName =new ArrayList<>();　 // 初始化

特点： 动态数组，可变大小。
优点： 高效的随机访问和快速尾部插入。
缺点： 中间插入和删除相对较慢。
添加元素: add(obj)
访问元素: get(int index)
修改元素: set(int index, obj)
删除元素: remove(int index)
删除所有元素: removeAll(obj)
元素数量: size()
元素索引: indexOf(obj)
是否存在: contains(obj)
复制: clone()
清空: clear()
替换所有: replaceAll(UnaryOperator<E> operator
- sites.replaceAll(e -> e.toUpperCase());
- numbers.replaceAll(e -> e * 2);;
删除满足条件元素: removeIf(Predicate<E> filter)
- sites.removeIf(e -> e.contains("Tao"));
- numbers.removeIf(e -> (e % 2) == 0);

遍历: forEach(Consumer<E> action)

numbers.forEach((e) -> {
            e = e * 10;
            System.out.print(e + " ");
        });

LinkedList:

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。

// 引入 LinkedList 类
import java.util.LinkedList; 
LinkedList<E> list = new LinkedList<E>();   // 普通创建方法
LinkedList<E> list = new LinkedList(Collection<? extends E> c); // 使用集合创建链表

特点： 双向链表，元素之间通过指针连接。
优点： 插入和删除元素高效，迭代器性能好。
缺点： 随机访问相对较慢。
添加元素: add(obj)
头部添加: addFirst(obj)
尾部添加: addLast(obj)
移除开头: removeFirst()
移除尾部: removeLast()
获取头部: getFirst()
获取尾部: getLast()

集合（Sets）

集合（Sets）用于存储不重复的元素，常见的实现有 HashSet 和 TreeSet。

Set<String> hashSet = new HashSet<>();
Set<Integer> treeSet = new TreeSet<>();

HashSet:

import java.util.HashSet; // 引入 HashSet 类
HashSet<String> sites = new HashSet<String>();

特点： 无序集合，基于HashMap实现。
优点： 高效的查找和插入操作。
缺点： 不保证顺序。
添加元素：add(obj)
判断元素是否存在：contains(obj)
删除元素：remove()
清空元素：clear()
计算大小：size()

TreeSet:

**特点：**TreeSet 是有序集合，底层基于红黑树实现，不允许重复元素。
优点： 提供自动排序功能，适用于需要按顺序存储元素的场景。
缺点： 性能相对较差，不允许插入 null 元素。

映射（Maps）

映射（Maps）用于存储键值对，常见的实现有 HashMap 和 TreeMap。

Map<String, Integer> hashMap = new HashMap<>();
Map<String, Integer> treeMap = new TreeMap<>();

HashMap:

import java.util.HashMap; // 引入 HashMap 类
HashMap<Integer, String> Sites = new HashMap<Integer, String>();

特点： 基于哈希表实现的键值对存储结构。
优点： 高效的查找、插入和删除操作。
缺点： 无序，不保证顺序。
添加元素：put(key, value)
访问元素：get(key)
删除元素：remove(key)
删除所有：clear()
计算元素数量：size()
获取所有key：keySet()

TreeMap:

特点： 基于红黑树实现的有序键值对存储结构。
优点： 有序，支持按照键的顺序遍历。
缺点： 插入和删除相对较慢。

ThreeMap<Integer, String> tm = new TreeMap<>(new Comparator<Integer>(){
  @Override
  public int compare(Integer o1, Integer o2){
    return o2-o1;
  }
});

栈（Stack）

栈（Stack）是一种线性数据结构，它按照后进先出（Last In, First Out，LIFO）的原则管理元素。在栈中，新元素被添加到栈的顶部，而只能从栈的顶部移除元素。这就意味着最后添加的元素是第一个被移除的。

Stack<Integer> stack = new Stack<>();

Stack 类:

特点： 代表一个栈，通常按照后进先出（LIFO）的顺序操作元素。

队列（Queue）

队列（Queue）遵循先进先出（FIFO）原则，常见的实现有 LinkedList 和 PriorityQueue。

Queue<String> queue = new LinkedList<>();

Queue 接口:

特点： 代表一个队列，通常按照先进先出（FIFO）的顺序操作元素。
实现类： LinkedList, PriorityQueue, ArrayDeque。

堆（Heap）

堆（Heap）优先队列的基础，可以实现最大堆和最小堆。

PriorityQueue<Integer> minHeap = new PriorityQueue<>();
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());

C++ Function

Mon, 10 Mar 2025 00:00:00 GMT

static

静态方法，没有this指针，不属于特定的对象。
不访问这个对象的非静态成员。

class demo{
    private:
    	std::string VERSION = "v1.0.0";
    public:
    	static std::string getVersion();
}

const

承诺不会在方法内不改变对象内部的值。
非const能调用const方法，const不能调用非const

class demo{
    public:
    	std::string getString() const;
}

mutable

允许在const中修改的成员变量

class demo{
    private:
    	int value;
    	mutable size_t numOfAccesses = 0;
    public:
    	int getValue() const{
            numOfAccesses++;
            return value;
        }
}

noexcept

该方法不会抛出异常

void test(int a) noexcept;

delete

显示的删除某个方法

class demo{
	public:
    	int foo(int a);
    	int foo(double a) = delete;
}

以 double为参数调用foo时编译器会报错

inline

inline int getValue(){
    ......
}

内联类似于#define，但是比使用#define更安全

virtual

只有在基类中声明为virtual的方法才能被派生类重写

建议所有方法都声明为virtual(对于现代计算机而言开销很小，Java默认使用virtual)
析构函数一定要声明为virtual，否则派生类将默认调用基类的析构函数
纯虚方法告诉编译器，该方法在该类中不存在定义。包含纯虚方法的类成为抽象类

class Base{
    public:
    	virtual void method();
    	virtual void method1() = 0;//纯虚方法
}

override

class Next: public Base{
    public:
    	virtual void method() override;
}

constexpr

常量表达式，通常在编译时进行计算

constexpr int getArraySize(){return 32;}
int nums[getArraySize()]; //getArraySize()是一个常量

本地大模型部署

Mon, 10 Mar 2025 00:00:00 GMT

大模型运行时采用Ollama，Ollama 是一个开源的本地大语言模型运行框架，专为在本地机器上便捷部署和运行大型语言模型（LLM）而设计。Ollama 支持多种操作系统，包括 macOS、Windows、Linux 以及通过 Docker 容器运行。Ollama 提供对模型量化的支持，可以显著降低显存要求，使得在普通家用计算机上运行大型模型成为可能。

Ollama安装

Ollama 对硬件要求不高，旨在让用户能够轻松地在本地运行、管理和与大型语言模型进行交互。

Windows：
- 打开浏览器，访问 Ollama 官方网站：https://ollama.com/download，下载适用于 Windows 的安装程序。
Linux：
- Linux 下可以使用一键安装脚本，运行命令：curl -fsSL https://ollama.com/install.sh | bash

安装完成之后，通过ollama --version 验证安装。

Ollama运行模型

Ollama 运行模型使用 ollama run 命令。

ollama run xxx:yyy # xxx为模型名称，yyy为模型版本

若本地不存在该模型，Ollama会自动从服务器拉取。模型列表可以从Ollama官方链接找到。

选择合适的模型，打开选择模型参数，然后复制命令到终端运行，即可自动部署。

若需要部署第三方模型或者其它开源模型，可访问huggingface。

选择合适的模型，然后选择使用该模型。(注意：选择模型时，应选择ollama支持的GGUF格式的模型版本。)

选择适合硬件的量化方案之后，复制该命令到终端，执行，Ollama会自动拉取该镜像。

国内huggingface会被限制访问，可将使用镜像网站：hf-mirror.com。拉取模型时，将hf.co替换为hf-mirror.com 。例如：

ollama run hf-mirror.com/Qwen/QwQ-32B-GGUF:Q4_0

API

Ollama 提供了基于 HTTP 的 API，允许开发者通过编程方式与模型进行交互。默认情况下，服务会运行在 http://localhost:11434。

Ollama 提供了以下主要 API 端点：

生成文本（Generate Text）

端点：POST /api/generate
功能：向模型发送提示词（prompt），并获取生成的文本。

请求格式：

{
  "model": "<model-name>",  // 模型名称
  "prompt": "<input-text>", // 输入的提示词
  "stream": false,          // 是否启用流式响应（默认 false）
  "options": {              // 可选参数
    "temperature": 0.7,     // 温度参数
    "max_tokens": 100       // 最大 token 数
  }
}

响应格式：

{
  "response": "<generated-text>", // 生成的文本
  "done": true                    // 是否完成
}

聊天（Chat）

端点：POST /api/chat
功能：支持多轮对话，模型会记住上下文。

请求格式：

{
  "model": "<model-name>",  // 模型名称
  "messages": [             // 消息列表
    {
      "role": "user",       // 用户角色
      "content": "<input-text>" // 用户输入
    }
  ],
  "stream": false,          // 是否启用流式响应
  "options": {              // 可选参数
    "temperature": 0.7,
    "max_tokens": 100
  }
}

响应格式：

{
  "message": {
    "role": "assistant",    // 助手角色
    "content": "<generated-text>" // 生成的文本
  },
  "done": true
}

列出本地模型（List Models）

端点：GET /api/tags
功能：列出本地已下载的模型。

响应格式：

{
  "models": [
    {
      "name": "<model-name>", // 模型名称
      "size": "<model-size>", // 模型大小
      "modified_at": "<timestamp>" // 修改时间
    }
  ]
}

拉取模型（Pull Model）

端点：POST /api/pull
功能：从模型库中拉取模型。

请求格式：

{
  "name": "<model-name>" // 模型名称
}

响应格式：

{
  "status": "downloading", // 下载状态
  "digest": "<model-digest>" // 模型摘要
}

启用流式响应

同时，Ollama还支持流式响应，该功能适用于实时生成文本的场景。在请求中设置 "stream": true，API 会逐行返回生成的文本。

curl http://localhost:11434/api/generate -d '{
  "model": "deepseek-coder",
  "prompt": "你好，你能帮我写一段代码吗？",
  "stream": true
}'

响应格式

每行返回一个 JSON 对象：

{
  "response": "<partial-text>",  // 部分生成的文本
  "done":   false                // 是否完成
}

python调用ollama的API

非流式调用采用python的requests库

def ollama(prompt):
    with requests.post(ollama_base_url,json={
        "model": llm_model_name,
        "prompt": prompt,
        "stream": False,
        "options": {
            "temperature": 0,
            "max_tokens": 64800
        }
    }) as response:
        return response.json()['response']

流式调用相对于非流式要复杂一些，采用aiohttp库，并使用异步的写法

async def ollama_stream(prompt):
    async with aiohttp.ClientSession() as session:
        async with session.post(ollama_base_url,json={
            "model": llm_model_name,  
            "prompt": prompt, 
            "stream": True,          
            "options": {              
                "temperature": 0,     
                "max_tokens": 64800       
                }
            }) as response:
            ans = []
            sentence = ''
            response.raise_for_status()
            try:
                async for reses in response.content.iter_any():
                    lines = reses.decode('utf-8').split('\n')
                    for line in lines:
                        if line:
                            response_text = json.loads(line)['response']
                            sentence += response_text
                            if response_text == '。' or response_text == '？' or response_text == '！' or response_text == '\n' or response_text == '\n\n' :
                                ans.append(sentence)
                                sentence.replace('\n','')
                                yield sentence
                                sentence = ''
            except Exception as e:
                print(e)
                return

流式返回的代码中进行了一定的处理，是的返回的内容并非直接返回ollama的数据流，而是当生成完整的一个句子之后，返回该语句。这样的做法有助于衔接TTS引擎，是的用户不用等待过长的时间才能听到语音的回复。

纯虚函数

Mon, 10 Mar 2025 00:00:00 GMT

纯虚函数（Pure Virtual Function）是C++中的一种特殊类型的虚函数，它在基类中没有具体的实现，并且要求任何继承自该基类的子类都必须提供这个函数的具体实现。纯虚函数在基类中的声明形式是在函数声明后面加上“= 0”，这表示这个函数是纯虚的，没有实际的函数体。纯虚函数的作用是定义一个接口，使得继承自基类的子类能够以多态的方式实现这个接口。由于纯虚函数没有实现，包含纯虚函数的类不能被实例化，这种类通常被称为抽象类（Abstract Class）。以下是一个简单的示例：

class Base {
public:
    virtual void pureVirtualFunction() = 0; // 纯虚函数
};
class Derived : public Base {
public:
    void pureVirtualFunction() override { // 实现纯虚函数
        // 函数的具体实现
    }
};

在这个示例中，Base是一个抽象类，因为它包含了一个纯虚函数pureVirtualFunction()。Derived类继承自Base类，并且提供了pureVirtualFunction()的具体实现。如果Derived类没有实现这个纯虚函数，那么Derived也会成为一个抽象类，不能被实例化。纯虚函数是C++实现多态和接口的一种重要机制，它允许基类定义一个通用的接口，而具体的实现则由子类根据具体的需求来完成。

C++ Class

Mon, 10 Mar 2025 00:00:00 GMT

继承

class next:public Base{
    ...
};

final

禁用继承

class Base final{
    ...
};

explicit

用于修饰类的构造函数，表示该构造函数必须为显示的。

类构造函数只有一个参数时，可隐式构造：CString s = 10编译器会自动调用CString s(10)

隐式构造容易出错

上下转型

Base base = myImplement;
Base &base = myImplement;

不加引用会导致数据截断。

通常不建议向下转型，若需要使用则通过static_cast<Implement *>(base)或者dynamic_cast<Implement *>(base)。

运行时工具

RTTI运行时类型信息

#include<typeifo>
class Animal{public: virtual ~Animal() = default};
class Dog: public Animal{};
class Cat: public Animal{};
void speak(const Animal & animal){
    if(typeid(animal)==typeid(Dog)){...}
    if(typeid(animal)==typeid(Cat)){...}
}

虚函数

虚函数是C++中实现多态的一种机制。当基类中的某个函数被声明为虚函数时，其派生类中的同名函数自动成为虚函数，无论是否使用virtual关键字。

c++中的虚函数主要作用是允许在派生类中重新定义基类的函数，以便实现特定的行为。通过基类指针或引用调用虚函数时，能够根据实际对象的类型来决定调用哪个函数，从而实现运行时多态。

如果在基类中没有定义虚函数，派生类可以调用基类中的非虚函数。即使基类中的函数没有被定义为虚函数，派生类仍然可以继承并调用这些函数。在这种情况下，派生类对基类函数的调用是通过静态绑定进行的，即在编译时就已经确定了要调用的函数。

继承：派生类继承基类的所有非私有成员函数，包括非虚函数。因此，派生类对象可以调用这些继承来的非虚函数。
静态绑定：对于非虚函数，调用哪个函数是在编译时确定的，基于对象的静态类型（即声明时的类型）而不是动态类型（即实际对象的类型）。
覆盖与重载：如果派生类定义了一个与基类中非虚函数同名但参数列表不同的函数，这被称为重载，而不是覆盖。调用哪个函数将基于函数的参数列表和对象的静态类型。
访问控制：派生类调用基类非虚函数的权限取决于基类中该函数的访问级别（如public、protected或private）。如果基类函数是私有的，派生类将无法直接调用它。

需要注意的是，如果希望在派生类中修改基类函数的行为，并且希望这种修改在通过基类指针或引用调用时生效（即实现多态），那么应该将基类中的相应函数声明为虚函数。非虚函数的调用不会实现多态行为。

虚基类

虚基类是C++中用于解决多继承时可能出现的二义性问题的一种机制。当某个类在多条继承路径上被多次继承时，如果不使用虚基类，那么这个类的成员变量和成员函数可能会在派生类中存在多个副本，导致二义性和资源浪费。 概念：

虚继承：虚基类是通过虚继承来实现的。在声明继承关系时，使用virtual关键字来指定基类为虚基类。
共享副本：通过虚继承，无论虚基类在继承层次中出现了多少次，派生类中都只包含虚基类的一个共享副本。
虚基类表：为了实现这种共享，编译器会为每个包含虚基类的对象添加一个虚基类表，用于记录虚基类成员的偏移量。 用法：
声明虚基类：在继承时使用virtual关键字。
```
class A { /* ... */ };
class B : virtual public A { /* ... */ };
class C : virtual public A { /* ... */ };
class D : public B, public C { /* ... */ };
```
在这个例子中，A是B和C的虚基类，D通过B和C间接继承了A，但A的成员在D中只有一个副本。

构造函数调用：虚基类的构造函数由最派生的类负责调用，而不是由直接继承的子类调用。

class A {
public:
    A() { /* ... */ }
};
class B : virtual public A {
public:
    B() { /* ... */ } // 不调用A的构造函数
};
class C : virtual public A {
public:
    C() { /* ... */ } // 不调用A的构造函数
};
class D : public B, public C {
public:
    D() : A(), B(), C() { /* ... */ } // 由D负责调用A的构造函数
};

避免二义性：使用虚基类可以避免在多继承情况下对基类成员的访问产生二义性。
```
D d;
d.someMemberOfA; // 无二义性，因为A的成员在D中只有一个副本
```
注意事项：

虚基类主要解决的是多继承中的二义性问题，并不是所有多继承场景都需要使用虚基类。
虚基类的构造函数由最派生的类负责调用，因此需要确保最派生的类能够访问到虚基类的构造函数。
虚继承会引入一些额外的开销，如虚基类表，因此在使用时应权衡其利弊。通过合理使用虚基类，可以有效地管理多继承关系，避免潜在的二义性和资源浪费问题。

数组索引可能的溢出及解决方式

Mon, 10 Mar 2025 00:00:00 GMT

c++中int可能存在溢出问题，例如：类型上溢出 $$ m = [(i+j)/2]int $$ 当i，j均为int类型时，可能出现int类型上溢出，可考虑使用一下手段在不改变数据类型的前提下，避免溢出： $$ m = [i+(j-i)/2] $$

#include<iostream>
using namespace std;

int main(void){
    int a = 1 << 31, b = 1 << 31;
    a -= 10;
    b -= 1;
    cout << a << " " << b << endl;
    cout << (a+b)/2 << endl;
    cout << a + (b-a)/2 << endl;
    return 0;
}

java学习笔记（4）

Mon, 10 Mar 2025 00:00:00 GMT

虚函数

虚函数的存在是为了多态。Java 中其实没有虚函数的概念，它的普通函数就相当于 C++ 的虚函数，动态绑定是Java的默认行为。如果 Java 中不希望某个函数具有虚函数特性，可以加上 final 关键字变成非虚函数。

C++的虚函数

虚函数是C++中实现多态的一种机制。当基类中的某个函数被声明为虚函数时，其派生类中的同名函数自动成为虚函数，无论是否使用virtual关键字。

继承：派生类继承基类的所有非私有成员函数，包括非虚函数。因此，派生类对象可以调用这些继承来的非虚函数。
静态绑定：对于非虚函数，调用哪个函数是在编译时确定的，基于对象的静态类型（即声明时的类型）而不是动态类型（即实际对象的类型）。
覆盖与重载：如果派生类定义了一个与基类中非虚函数同名但参数列表不同的函数，这被称为重载，而不是覆盖。调用哪个函数将基于函数的参数列表和对象的静态类型。
访问控制：派生类调用基类非虚函数的权限取决于基类中该函数的访问级别（如public、protected或private）。如果基类函数是私有的，派生类将无法直接调用它。

C++的虚基类

虚继承：虚基类是通过虚继承来实现的。在声明继承关系时，使用virtual关键字来指定基类为虚基类。
共享副本：通过虚继承，无论虚基类在继承层次中出现了多少次，派生类中都只包含虚基类的一个共享副本。
虚基类表：为了实现这种共享，编译器会为每个包含虚基类的对象添加一个虚基类表，用于记录虚基类成员的偏移量。 用法：
声明虚基类：在继承时使用virtual关键字。
```
class A { /* ... */ };
class B : virtual public A { /* ... */ };
class C : virtual public A { /* ... */ };
class D : public B, public C { /* ... */ };
```
在这个例子中，A是B和C的虚基类，D通过B和C间接继承了A，但A的成员在D中只有一个副本。

构造函数调用：虚基类的构造函数由最派生的类负责调用，而不是由直接继承的子类调用。

class A {
public:
    A() { /* ... */ }
};
class B : virtual public A {
public:
    B() { /* ... */ } // 不调用A的构造函数
};
class C : virtual public A {
public:
    C() { /* ... */ } // 不调用A的构造函数
};
class D : public B, public C {
public:
    D() : A(), B(), C() { /* ... */ } // 由D负责调用A的构造函数
};

避免二义性：使用虚基类可以避免在多继承情况下对基类成员的访问产生二义性。
```
D d;
d.someMemberOfA; // 无二义性，因为A的成员在D中只有一个副本
```

注意事项：

虚基类主要解决的是多继承中的二义性问题，并不是所有多继承场景都需要使用虚基类。
虚基类的构造函数由最派生的类负责调用，因此需要确保最派生的类能够访问到虚基类的构造函数。
虚继承会引入一些额外的开销，如虚基类表，因此在使用时应权衡其利弊。通过合理使用虚基类，可以有效地管理多继承关系，避免潜在的二义性和资源浪费问题。

抽象类

在Java中，可以使用abstract关键字来将一个方法标记为抽象方法，这样继承类就必须实现该方法。抽象方法没有方法体，只有方法签名。包含抽象方法的类也必须被声明为抽象类。以下是一个示例：

// 声明一个抽象类
public abstract class AbstractClass {
    // 声明一个抽象方法
    public abstract void abstractMethod();
}
// 继承抽象类
public class ConcreteClass extends AbstractClass {
    // 实现抽象方法
    @Override
    public void abstractMethod() {
        // 方法实现
        System.out.println("实现了抽象方法");
    }
}

在这个示例中，AbstractClass是一个抽象类，它包含了一个抽象方法abstractMethod()。ConcreteClass继承了AbstractClass，并且必须实现abstractMethod()方法。如果不实现抽象方法，那么继承类也必须被声明为抽象类。例如：

// 另一个继承抽象类的类，没有实现抽象方法
public abstract class AnotherAbstractClass extends AbstractClass {
    // 可以添加其他方法或属性
}

在这个例子中，AnotherAbstractClass继承了AbstractClass但没有实现abstractMethod()，因此它也必须被声明为抽象类。

Java的反射机制是Java语言的一个重要特性，它允许程序在运行时获取任意类的内部信息，包括类的方法、属性、构造器等，并且可以动态地创建对象、调用方法、访问属性。这种机制极大地提高了Java的灵活性和动态性，但同时也带来了一些性能开销和安全性问题。

反射机制的基本概念

Class类：Java中的每个类都有一个对应的Class对象，这个对象包含了类的所有信息。通过Class对象，可以获取类的构造器、方法、属性等。
Constructor类：代表类的构造器。
Method类：代表类的方法。
Field类：代表类的属性（字段）。
Modifier类：提供了一系列静态方法来解析类的访问修饰符。

反射的基本用法

获取Class对象

通过类名：Class<?> clazz = String.class;
通过对象：Class<?> clazz = "hello".getClass();
通过全限定名：Class<?> clazz = Class.forName("java.lang.String");

获取构造器

Constructor<?>[] constructors = clazz.getConstructors(); // 获取所有公共构造器
Constructor<?> constructor = clazz.getConstructor(String.class); // 获取特定公共构造器
Constructor<?>[] constructors = clazz.getDeclaredConstructors(); // 获取所有构造器，包括私有
Constructor<?> constructor = clazz.getDeclaredConstructor(String.class); // 获取特定构造器，包括私有

创建对象

Object obj = constructor.newInstance("hello"); // 调用构造器创建对象

获取方法

Method[] methods = clazz.getMethods(); // 获取所有公共方法
Method method = clazz.getMethod("toString"); // 获取特定公共方法
Method[] methods = clazz.getDeclaredMethods(); // 获取所有方法，包括私有
Method method = clazz.getDeclaredMethod("someMethod", String.class); // 获取特定方法，包括私有

调用方法

Object result = method.invoke(obj, "param"); // 调用方法，obj为对象实例，param为参数

获取属性

Field[] fields = clazz.getFields(); // 获取所有公共属性
Field field = clazz.getField("someField"); // 获取特定公共属性
Field[] fields = clazz.getDeclaredFields(); // 获取所有属性，包括私有
Field field = clazz.getDeclaredField("someField"); // 获取特定属性，包括私有

访问属性

Object value = field.get(obj); // 获取属性值
field.set(obj, "newValue"); // 设置属性值

反射的应用场景

框架开发：如Spring、Hibernate等框架大量使用反射来实现依赖注入、对象关系映射等功能。
动态代理：如Java的动态代理机制，通过反射来动态创建代理类。
代码分析工具：如IDE、代码生成器等工具使用反射来分析代码结构。
测试框架：如JUnit使用反射来识别和调用测试方法。

反射的注意事项

性能开销：反射操作相比直接代码调用会有较大的性能开销。
安全性问题：反射可以绕过类的访问控制，可能会破坏封装性，导致安全问题。
代码可读性：过度使用反射会使代码难以理解和维护。
异常处理：反射操作会抛出如ClassNotFoundException、NoSuchMethodException等异常，需要妥善处理。

示例代码

public class ReflectionDemo {
    public static void main(String[] args) throws Exception {
        // 获取Class对象
        Class<?> clazz = Class.forName("java.lang.String");
        // 获取构造器并创建对象
        Constructor<?> constructor = clazz.getConstructor(String.class);
        Object obj = constructor.newInstance("hello");
        // 获取方法并调用
        Method method = clazz.getMethod("toUpperCase");
        Object result = method.invoke(obj);
        // 输出结果
        System.out.println(result); // 输出：HELLO
    }
}

这个示例展示了如何使用反射来获取String类的构造器、创建对象、获取方法并调用方法。通过这个简单的例子，可以初步了解Java反射机制的基本用法。在实际应用中，反射通常用于更复杂和动态的场景。

获取接口和父类

Class<?> clazz = Person.class;

// 获取所有接口
Class<?>[] interfaces = clazz.getInterfaces();
for (Class<?> i : interfaces) {
    System.out.println("Interface: " + i.getName());
}

// 获取父类
Class<?> superClass = clazz.getSuperclass();
System.out.println("Superclass: " + superClass.getName());

`java.lang.reflect`

java.lang.reflect 是 Java 反射机制的核心包，提供了操作类及其成员（字段、方法、构造函数等）的类和接口。通过这些 API，开发者可以在运行时动态地查询和修改类的结构。

图片来源：https://www.runoob.com/

Class 类

功能：表示类的对象，提供了获取类信息的方法，如字段、方法、构造函数等。
主要方法：
- getFields()：获取所有公共字段。
- getDeclaredFields()：获取所有声明的字段，包括私有字段。
- getMethods()：获取所有公共方法。
- getDeclaredMethods()：获取所有声明的方法，包括私有方法。
- getConstructors()：获取所有公共构造函数。
- getDeclaredConstructors()：获取所有声明的构造函数，包括私有构造函数。
- getSuperclass()：获取类的父类。
- getInterfaces()：获取类实现的所有接口。

Field 类

功能：表示类的字段（属性），提供了访问和修改字段值的方法。
主要方法：
- get(Object obj)：获取指定对象的字段值。
- set(Object obj, Object value)：设置指定对象的字段值。
- getType()：获取字段的数据类型。
- getModifiers()：获取字段的修饰符（如 public、private）。

Method 类

功能：表示类的方法，提供了调用方法的能力。
主要方法：
- invoke(Object obj, Object... args)：调用指定对象的方法。
- getReturnType()：获取方法的返回类型。
- etParameterTypes()：获取方法的参数类型。
- etModifiers()：获取方法的修饰符（如 public、private）。

Constructor 类

功能：表示类的构造函数，提供了创建对象的能力。
主要方法：
- newInstance(Object... initargs)：创建一个新实例，使用指定的构造函数参数。
- getParameterTypes()：获取构造函数的参数类型。
- getModifiers()：获取构造函数的修饰符（如 public、private）。

Java 排序

Sun, 09 Mar 2025 00:00:00 GMT

Java排序

在Java中，Collections 类的 sort() 方法用于对列表进行排序，而 Arrays 类的 sort() 方法用于对数组进行排序。如果你想要对自定义对象数组或列表进行排序，你需要确保这些对象实现了 Comparable 接口。以下是如何手动实现 Comparable 接口的步骤：

定义自定义类：首先，定义一个自定义类，比如 Person。
实现 Comparable 接口：在自定义类中实现 Comparable 接口，并指定比较的对象类型。
覆盖 compareTo 方法：实现 compareTo 方法，定义对象的比较逻辑。下面是一个示例，展示了如何为一个 Person 类实现 Comparable 接口，以便根据 Person 的 age 属性进行排序：

public class Person implements Comparable<Person> {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    @Override
    public int compareTo(Person other) {
        // 根据年龄升序排序
        return this.age - other.age;
    }
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + '}';
    }
}

在这个例子中，compareTo 方法根据 Person 对象的 age 属性进行比较。如果需要降序排序，可以修改 compareTo 方法中的返回值为 other.age - this.age。现在，你可以使用 Arrays.sort() 或 Collections.sort() 方法对 Person 对象数组或列表进行排序：

import java.util.Arrays;
import java.util.List;
public class Main {
    public static void main(String[] args) {
        Person[] people = {
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        };
        Arrays.sort(people);
        for (Person person : people) {
            System.out.println(person);
        }
        List<Person> personList = Arrays.asList(people);
        Collections.sort(personList);
        for (Person person : personList) {
            System.out.println(person);
        }
    }
}

在这个例子中，Arrays.sort(people) 和 Collections.sort(personList) 都会根据 Person 类中实现的 compareTo 方法进行排序。输出将显示根据年龄排序的 Person 对象。

`Arrays`和`Collections`类中常用的一些API方法：

类名	方法签名	描述
`Arrays`	`static void sort(int[] a)`	对整型数组进行排序
	`static void sort(Object[] a)`	对对象数组进行排序，要求对象实现`Comparable`接口
	`static void sort(T[] a, Comparator<? super T> c)`	使用指定的`Comparator`对对象数组进行排序
	`static int binarySearch(int[] a, int key)`	在已排序的整型数组中使用二分搜索查找元素
	`static int binarySearch(Object[] a, Object key)`	在已排序的对象数组中使用二分搜索查找元素，要求对象实现`Comparable`接口
	`static int binarySearch(T[] a, T key, Comparator<? super T> c)`	使用指定的`Comparator`在已排序的对象数组中进行二分搜索
	`static void fill(int[] a, int val)`	将指定的整数值填充到数组中
	`static void fill(Object[] a, Object val)`	将指定的对象引用填充到数组中
	`static boolean equals(int[] a, int[] a2)`	判断两个整型数组是否相等
	`static boolean equals(Object[] a, Object[] a2)`	判断两个对象数组是否相等
	`static String toString(int[] a)`	返回数组的字符串表示形式
	`static String toString(Object[] a)`	返回对象数组的字符串表示形式
`Collections`	`static <T extends Comparable<? super T>> void sort(List<T> list)`	对列表进行排序，要求列表中的元素实现`Comparable`接口
	`static <T> void sort(List<T> list, Comparator<? super T> c)`	使用指定的`Comparator`对列表进行排序
	`static int binarySearch(List<? extends Comparable<? super T>> list, T key)`	在已排序的列表中使用二分搜索查找元素，要求元素实现`Comparable`接口
	`static int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)`	使用指定的`Comparator`在已排序的列表中进行二分搜索
	`static void reverse(List<?> list)`	反转列表中元素的顺序
	`static void shuffle(List<?> list)`	随机打乱列表中元素的顺序
	`static void swap(List<?> list, int i, int j)`	交换列表中两个位置上的元素
	`static <T> void fill(List<? super T> list, T obj)`	使用指定的对象填充列表
	`static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)`	替换列表中所有旧值为新值
	`static boolean addAll(Collection<? super T> c, T... elements)`	将所有指定元素添加到集合中
	`static <T> T min(Collection<? extends T> coll)`	返回集合中的最小元素，要求元素实现`Comparable`接口
	`static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)`	使用指定的`Comparator`返回集合中的最小元素
	`static <T> T max(Collection<? extends T> coll)`	返回集合中的最大元素，要求元素实现`Comparable`接口
	`static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)`	使用指定的`Comparator`返回集合中的最大元素
	`static void rotate(List<?> list, int distance)`	将列表中的元素循环移动指定的距离
`Arrays`类主要用于数组操作，而`Collections`类主要用于集合框架中的列表、集和映射操作。在使用这些方法时，需要确保传入的参数符合方法的要求，例如数组或列表已经排序、元素类型正确等。

Comparator

在Java中，Comparator接口用于定义对象的比较逻辑，尤其是在需要对某个类的对象进行排序，但该类没有实现Comparable接口，或者需要按照不同的排序逻辑进行排序时。实现Comparator接口需要创建一个实现了Comparator接口的类，并覆盖其compare方法。以下是如何实现Comparator接口的步骤：

创建一个实现Comparator接口的类。
覆盖compare方法，定义比较逻辑。
在需要排序的地方使用这个Comparator。下面是一个简单的示例，展示了如何为Person类实现一个Comparator来根据年龄进行排序：

import java.util.Comparator;
// Person类
class Person {
    String name;
    int age;
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return name + ": " + age;
    }
}
// 实现Comparator接口的AgeComparator类
class AgeComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return Integer.compare(p1.age, p2.age);
    }
}
// 主类
public class ComparatorExample {
    public static void main(String[] args) {
        Person[] people = {
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        };
        // 使用Arrays.sort方法和AgeComparator来排序
        Arrays.sort(people, new AgeComparator());
        // 输出排序后的结果
        for (Person person : people) {
            System.out.println(person);
        }
    }
}

在这个示例中，AgeComparator类实现了Comparator<Person>接口，并覆盖了compare方法，该方法比较两个Person对象的年龄。在main方法中，我们使用Arrays.sort方法和AgeComparator实例来对Person数组进行排序。 compare方法的返回值应该是一个负数、零或正数，分别表示第一个参数小于、等于或大于第二个参数。此外，从Java 8开始，你可以使用lambda表达式来简化Comparator的实现，如下所示：

// 使用lambda表达式创建Comparator
Comparator<Person> ageComparator = (p1, p2) -> Integer.compare(p1.age, p2.age);
// 使用Arrays.sort方法和lambda表达式来排序
Arrays.sort(people, ageComparator);

这种方式更加简洁，特别适合于简单的比较逻辑。

Java学习笔记（3）

Sun, 09 Mar 2025 00:00:00 GMT

try-with-resources

try-with-resources是Java 7引入的一种特性，用于自动管理资源，例如文件、网络连接等。这种机制确保了在try代码块执行完毕后，资源会被自动关闭，从而避免了资源泄露。

工作原理

资源定义：在try语句的括号内声明并初始化资源。这些资源必须实现AutoCloseable接口。
资源使用：在try代码块内使用这些资源。
自动关闭：无论try代码块是正常结束还是因为异常而结束，都会自动调用资源的close()方法来关闭资源。

语法

try (ResourceType resource = resourceInitialization) {
    // 使用资源的代码
} catch (ExceptionType e) {
    // 处理异常的代码
}

示例

假设我们有一个文件example.txt，我们想要读取它的内容并打印到控制台。使用try-with-resources，我们可以确保文件在读取后会被正确关闭。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class TryWithResourcesExample {
    public static void main(String[] args) {
        // 使用try-with-resources自动管理BufferedReader资源
        try (BufferedReader br = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.err.println("发生IO异常: " + e.getMessage());
        }
        // 不需要显式关闭BufferedReader，try-with-resources会自动处理
    }
}

在这个例子中：

BufferedReader是一个实现了AutoCloseable接口的资源。
我们在try的括号内初始化了这个资源。
在try代码块内，我们读取文件的内容。
无论读取过程中是否发生异常，BufferedReader都会在try代码块执行完毕后自动关闭。这种方式简化了资源管理，使得代码更加简洁和健壮。

ry-with-resources 处理多个资源

try-with-resources 语句中可以声明多个资源，方法是使用分号 ; 分隔各个资源：

import java.io.*;
import java.util.*;
class RunoobTest {
    public static void main(String[] args) throws IOException{
        try (Scanner scanner = new Scanner(new File("testRead.txt")); 
            PrintWriter writer = new PrintWriter(new File("testWrite.txt"))) {
            while (scanner.hasNext()) {
                writer.print(scanner.nextLine());
            }
        }
    }
}

以上实例使用 Scanner 对象从 testRead.txt 文件中读取一行并将其写入新的 testWrite.txt 文件中。

多个声明资源时，try-with-resources 语句以相反的顺序关闭这些资源。在本例中，PrintWriter 对象先关闭，然后 Scanner 对象关闭。

类实例对象监测

要实时检测某个类在当前程序中的实例数量，我们可以使用一个静态变量来跟踪实例化的次数。每次创建新实例时，我们增加这个计数器；每次实例被垃圾回收时，我们减少这个计数器。为了实现后者，我们可以使用Java的finalize()方法，但是请注意，finalize()方法不保证被及时调用，并且它的使用通常是不推荐的。从Java 9开始，finalize()方法已被弃用。一个更现代的方法是使用Java的java.lang.ref.PhantomReference和java.lang.ref.ReferenceQueue，这样可以更准确地跟踪对象的垃圾回收。以下是一个使用PhantomReference和ReferenceQueue来实时检测类实例数量的示例：

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
public class InstanceTracker {
    private static int instanceCount = 0;
    private static ReferenceQueue<InstanceTracker> referenceQueue = new ReferenceQueue<>();
    private static PhantomReference<InstanceTracker> phantomReference;
    public InstanceTracker() {
        instanceCount++;
        phantomReference = new PhantomReference<>(this, referenceQueue);
    }
    @Override
    protected void finalize() throws Throwable {
        try {
            super.finalize();
        } finally {
            instanceCount--;
        }
    }
    public static int getInstanceCount() {
        // 清理已经被回收的实例
        while ((phantomReference = (PhantomReference<InstanceTracker>) referenceQueue.poll()) != null) {
            instanceCount--;
        }
        return instanceCount;
    }
    public static void main(String[] args) throws InterruptedException {
        System.out.println("Initial instance count: " + InstanceTracker.getInstanceCount());
        InstanceTracker instance1 = new InstanceTracker();
        System.out.println("Instance count after creating instance1: " + InstanceTracker.getInstanceCount());
        InstanceTracker instance2 = new InstanceTracker();
        System.out.println("Instance count after creating instance2: " + InstanceTracker.getInstanceCount());
        // 强制垃圾回收
        instance1 = null;
        System.gc();
        Thread.sleep(100); // 等待垃圾回收完成
        System.out.println("Instance count after garbage collecting instance1: " + InstanceTracker.getInstanceCount());
        instance2 = null;
        System.gc();
        Thread.sleep(100); // 等待垃圾回收完成
        System.out.println("Instance count after garbage collecting instance2: " + InstanceTracker.getInstanceCount());
    }
}

在这个示例中，我们定义了一个InstanceTracker类，它有一个静态变量instanceCount来跟踪实例的数量。每次创建InstanceTracker的新实例时，instanceCount都会增加。我们使用PhantomReference和ReferenceQueue来检测对象何时被垃圾回收，并在getInstanceCount方法中更新instanceCount。请注意，这个示例中的System.gc()和Thread.sleep()是为了演示目的，强制垃圾回收并等待其完成。在实际应用中，不推荐依赖这些方法来管理内存，因为垃圾回收的行为是不可预测的。此外，这个示例仅用于演示如何跟踪实例数量，并不推荐作为生产环境中的解决方案。在生产环境中，更好的做法是使用现有的库或框架来管理对象的生命周期和资源。

Java String 类

Sat, 08 Mar 2025 00:00:00 GMT

字符串广泛应用在 Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。

String 基础用法

创建String

String a = "hello world!";
String b = new String("hello world!");
char[] chs = {'h', 'e', 'l', 'l', 'o'};
String c = new String(chs);

获取字符串长度

int len = str.length();

连接字符串

string1.concat(string2); // 返回 string2 连接 string1 的新字符串。
"hello," + " world" + "!";

常用API

char charAt(int index);

返回指定索引处的 char 值。

int compareTo(String anotherString)

字符串比较(字典序)。

boolean startsWith(String prefix)

测试此字符串是否以指定的前缀开始。

boolean endsWith(String suffix)

测试此字符串是否以指定的后缀结束。

byte[] getBytes()

使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。

byte[] getBytes(String charsetName)

使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。

int indexOf(int ch)

返回指定字符在此字符串中第一次出现处的索引。

int indexOf(int ch, int fromIndex)

返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。

int indexOf(String str)

返回指定子字符串在此字符串中第一次出现处的索引。

int indexOf(String str, int fromIndex)

返回指定子字符串在此字符串中第一次出现处的索引。

int length()

返回此字符串的长度。

String replace(char oldChar, char newChar)

返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。

String replaceAll(String regex, String replacement)

使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

String[] split(String regex)

根据给定正则表达式的匹配拆分此字符串。

String substring(int beginIndex, int endIndex)

返回一个新字符串，它是此字符串的一个子字符串。

char[] toCharArray()

将此字符串转换为一个新的字符数组。

String toLowerCase()

使用默认语言环境的规则将此 String 中的所有字符都转换为小写。

String toUpperCase()

使用默认语言环境的规则将此 String 中的所有字符都转换为大写。

String trim()

返回字符串的副本，忽略前导空白和尾部空白。

isEmpty()

判断字符串是否为空。

String 基础特性

不可变性

Java的String对象一旦创建，其内容不可修改。所有看似修改的操作（如拼接、替换）实际上是创建新的String对象。

String s = "Hello";
s = s + " World"; // 创建新对象，原"Hello"仍存在内存中

字符串常量池

Java通过字符串池优化内存，相同字面量的字符串会复用池中的对象（通过intern()方法可手动入池）。

String s1 = "abc"; // 从池中获取
String s2 = new String("abc"); // 强制创建新对象
System.out.println(s1 == s2); // false（比较对象地址）
System.out.println(s1.equals(s2)); // true（比较内容）

字符串比较

必须使用equals()而非==来比较内容，因为==比较的是对象地址。

String 深入用法

高效字符串操作

StringBuilder与StringBuffer 频繁修改字符串时，使用StringBuilder（非线程安全）或StringBuffer（线程安全）避免频繁创建新对象。
- ```
StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" World");
String result = sb.toString(); // 高效拼接
```
字符串分割与正则表达式 使用split()和正则表达式处理复杂字符串：
- ```
String str = "a,b,c";
String[] parts = str.split(","); // ["a", "b", "c"]
```

字符串格式化

String.format()

似C的printf，支持格式化输出：

String formatted = String.format("Name: %s, Age: %d", "Alice", 30);

Java 15+ 的文本块（Text Blocks）

String json = """
              {
                  "name": "Alice",
                  "age": 30
              }
              """;

编码与字节转换

byte[] utf8Bytes = str.getBytes(StandardCharsets.UTF_8);
String decoded = new String(utf8Bytes, StandardCharsets.UTF_8);

与C++ std::string和Python str的对比

不可变性

Java：String不可变，修改操作生成新对象。
C++：std::string是可变的，直接修改原对象。

std::string s = "Hello"; s += " World"; // 直接修改原对象


- Python：`str`不可变，类似Java，修改生成新对象。

> 2. 内存管理

- Java：依赖JVM垃圾回收，字符串池优化内存。
- C++：手动管理内存（RAII），`std::string`内部使用动态数组。
- Python：引用计数和垃圾回收，字符串驻留（类似池化）优化。

> **3. **常用操作

- 拼接效率
- Java：推荐`StringBuilder`（`O(n)`复杂度）。
- C++：直接使用`+=`或`append()`（动态数组扩容，高效）。
- Python：推荐`join()`（高效处理列表拼接）。
- 切片与索引
- Java：需用`substring(begin, end)`。
- C++：`substr(pos, length)`。
- Python：直接使用`s[start:end]`语法，最简洁。

> 4. Unicode支持

- Java：`String`内部为UTF-16，需注意代理对（Surrogate Pairs）。
- Python3：`str`默认支持Unicode，透明处理多语言文本。

Java学习笔记（2）

Sat, 08 Mar 2025 00:00:00 GMT

可变参数

Java的函数支持可变参数。在Java中，可变参数允许在调用方法时传入不定数量的参数。这为方法提供了一种灵活的方式来处理不同数量的输入。

要定义一个可变参数方法，只需在参数类型后加上省略号（…）。例如，以下是一个简单的可变参数方法的示例：

public class VarargsExample {
    public static void main(String[] args) {
        // 调用可变参数方法
        printNumbers(1, 2, 3, 4, 5);
        printNumbers(10, 20);
    }
    // 定义可变参数方法
    public static void printNumbers(int... numbers) {
        for (int number : numbers) {
            System.out.println(number);
        }
    }
}

在这个示例中，printNumbers方法可以接受任意数量的int类型参数。当调用这个方法时，可以传入任意数量的整数，方法会遍历并打印每个数字。

需要注意的是，可变参数必须是方法参数列表中的最后一个参数，并且一个方法只能有一个可变参数。如果方法还有其他参数，它们必须位于可变参数之前。

此外，可变参数在内部实际上是一个数组，因此可以像数组一样进行操作。但是，为了提高代码的可读性和清晰度，建议在需要处理不定数量参数的情况下使用可变参数。

Java类内实例化与循环引用分析

静态方法实例化类

Java中类的静态方法（比如main）属于类本身，而不是实例。在静态方法中，可以创建该类的实例，这没有问题。比如常见的public static void main里，通常会创建自己类的实例来启动程序。所以这并不会导致循环引用，因为这只是创建一个实例，而不会无限递归。比如:

public class Test {
    public static void main(String[] args) {
    	Test t = new Test(); // 这是合法的，不会导致循环
    }
}

这时候，每次运行main方法会创建一个Test实例，但如果没有在构造函数里再次创建Test实例的话，就不会有问题。

循环引用

循环引用的定义：循环引用指两个或多个对象互相持有引用，导致无法被垃圾回收。例如：

class A { B b; }
class B { A a; }

实际上，只有在构造函数中不加控制地创建自身实例只会导致栈溢出。

public class Test {
    public Test() {
    	new Test(); // 每次构造都会创建新的实例，导致无限递归，栈溢出
    }
    public static void main(String[] args) {
    	new Test();
    }
}

同时，对象之间的相互引用，比如A引用B，B引用A，这样可能导致内存泄漏。

public class reference {
    private class Node{
        int a, b, c;
        Node(int a, int b, int c){
            this.a = a;
            this.b = b;
            this.c = c;
        }
        public String toString(){
            return "a: " + a + " b: " + b + " c: " + c;
        }
    }
    public void change(Node node){
        node.a = 1;
        node.b = 2;
        node.c = 3;
    }
    public static void main(String[] args) {
        reference outer = new reference();
        Node node = outer.new Node(0, 0, 0);
        System.out.println(node);
        outer.change(node);
        System.out.println(node);
    }
}

这段代码仅存在单向引用（node→outer），而非reference与Node互相引用。因此不存在循环引用。

非静态内部类在编译后会生成一个包含外部类引用的构造器。例如，Node类会被编译为类似以下形式：

class reference$Node {
    final reference outer; // 隐式持有外部类实例
    int a, b, c;
    
    reference$Node(reference outer, int a, int b, int c) {
        this.outer = outer;
        this.a = a;
        // ...
    }
}

当你通过outer.new Node(...)创建Node实例时，实际调用的是上述构造器，将outer作为参数传入。

Java学习笔记（1）

Fri, 07 Mar 2025 00:00:00 GMT

default关键字

像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。

访问控制修饰符 : default, public , protected, private
非访问控制修饰符 : final, abstract, static, synchronized

在Java中，default 关键词有两个主要的用途：

默认访问修饰符：
- 当一个类、方法或变量没有明确指定访问修饰符（如public、protected、private）时，它默认具有包级私有（package-private）访问权限。这意味着只有同一个包内的类可以访问这个类、方法或变量。
接口中的默认方法：
- 从Java 8开始，接口中可以包含默认方法（default methods）。这些方法是带有具体实现的方法，使用default关键字修饰。默认方法允许在接口中提供方法的实现，这样现有的实现类不需要修改就可以使用新添加的方法。这为接口的扩展提供了更大的灵活性。

// 默认访问修饰符示例
class DefaultExample {
    int number; // 默认访问权限，同一包内的类可以访问

    void display() { // 默认访问权限，同一包内的类可以访问
        System.out.println("Number: " + number);
    }
}

// 接口中的默认方法示例
interface MyInterface {
    void method1(); // 抽象方法

    default void method2() { // 默认方法
        System.out.println("Default method implementation");
    }
}

class ImplementationClass implements MyInterface {
    public void method1() {
        System.out.println("Implementation of method1");
    }
}

public class Main {
    public static void main(String[] args) {
        ImplementationClass obj = new ImplementationClass();
        obj.method1(); // 调用实现的方法
        obj.method2(); // 调用接口中的默认方法
    }
}

在这个示例中，DefaultExample类没有明确指定访问修饰符，因此它的成员具有包级私有访问权限。MyInterface接口包含一个默认方法method2，ImplementationClass实现了这个接口，并可以直接使用method2 而不用提供实现。

枚举

Java 5.0引入了枚举，枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的 bug。

例如，我们为果汁店设计一个程序，它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。

class FreshJuice {
   enum FreshJuiceSize{ SMALL, MEDIUM , LARGE }
   FreshJuiceSize size;
}
 
public class FreshJuiceTest {
   public static void main(String[] args){
      FreshJuice juice = new FreshJuice();
      juice.size = FreshJuice.FreshJuiceSize.MEDIUM  ;
   }
}

**注意：**枚举可以单独声明或者声明在类里面。方法、变量、构造函数也可以在枚举中定义。

数组存在于堆上

Java中的数组作为对象，确实是在堆上存储的，而指向这些数组的引用则存储在栈上。在Java中，所有的对象，包括数组，都是在堆上分配内存的。这是因为对象通常需要较大的内存空间，并且生命周期较长，因此将它们存储在堆上可以更有效地管理内存。当你在Java中创建一个数组时，例如：

int[] myArray = new int[10];

这里，myArray是一个引用变量，它存储在栈上，而实际的数组对象（包含10个整数元素）是在堆上分配的。myArray变量持有的只是这个堆上数组对象的引用（或地址）。这种设计允许Java具有更灵活的内存管理，并支持复杂的数据结构和动态内存分配。但是，这也意味着开发者需要负责管理对象的创建和销毁，以避免内存泄漏和其他内存相关的问题。

Java具有自动垃圾回收机制，可以自动回收不再被引用的对象所占用的空间。当对象不再被任何引用所指向时，垃圾回收器会在适当的时候回收这些对象所占用的内存。然而，尽管Java提供了自动垃圾回收，开发者仍然需要谨慎地管理对象的引用，以避免不必要的内存占用和潜在的内存泄漏。例如，如果对象之间存在循环引用，且这些对象不再被外部引用，垃圾回收器可能无法回收它们，从而导致内存泄漏。此外，垃圾回收器的具体行为和效率也受到多种因素的影响，包括Java虚拟机的实现、垃圾回收算法的选择、系统的内存压力等。因此，尽管Java提供了自动垃圾回收，开发者仍然需要关注内存管理和性能优化。Java的自动垃圾回收机制确实可以自动回收不再被引用的对象所占用的空间，但开发者仍需谨慎管理对象引用并关注内存使用情况。

抽象类和接口类

在Java中，抽象类（Abstract Class）和接口（Interface）都是用来实现抽象化的重要机制，但它们之间有一些关键的区别：

定义：
- 抽象类：是一种不能被实例化的类，可以包含具体实现的方法和抽象方法（没有方法体的方法）。
- 接口：是一种完全抽象的类，只能包含抽象方法和默认方法（Java 8+），以及常量。
继承与实现：
- 抽象类：一个类只能继承一个抽象类，因为Java不支持多重继承。
- 接口：一个类可以实现多个接口，提供多继承的效果。
成员：
- 抽象类：可以包含构造器、非final的变量、具体实现的方法、抽象方法、静态方法、初始化块等。
- 接口：只能包含静态常量、抽象方法、默认方法（Java 8+）、静态方法（Java 9+）。
访问修饰符：
- 抽象类：可以有任何访问修饰符（public、protected、private）。
- 接口：默认是public的，成员变量默认是public static final的，方法默认是public的。
使用场景：
- 抽象类：当多个类共享一些共同的方法和属性时，可以使用抽象类来定义这些共同的特性。
- 接口：用于定义公共的方法规范，实现类可以以任何方式实现这些方法。
扩展性：
- 抽象类：扩展性有限，因为子类只能继承一个抽象类。
- 接口：提供更高的扩展性，因为一个类可以实现多个接口。
默认实现：
- 抽象类：可以提供某些方法的具体实现，子类可以选择性地覆盖这些方法。
- 接口：在Java 8之前不能提供方法的实现，Java 8引入了默认方法，允许接口提供方法的默认实现。
多态性：
- 抽象类：可以通过抽象类引用指向子类对象来实现多态。
- 接口：可以通过接口引用指向实现类对象来实现多态。总的来说，抽象类更适合于那些部分实现或共享代码的场景，而接口则适用于定义完全抽象的API，使得实现类可以以多种方式实现这些API。选择使用抽象类还是接口，取决于具体的设计需求和场景。

instanceof

instanceof 是 Java 语言中的一个二元操作符，用于测试左边的对象是否是右边类或接口的实例，返回 boolean 类型的结果。如果左边的对象是右边类或接口的实例，或者是右边类的子类实例，那么 instanceof 操作符返回 true，否则返回 false。其基本语法如下：

object instanceof Class

object：要测试的对象。
Class：类或接口的类型。 instanceof 操作符的主要用途包括：

类型检查：在运行时确定对象的类型，以便进行相应的操作。
向下转型：在向下转型（将父类对象转换为子类对象）之前，使用 instanceof 检查可以避免 ClassCastException。示例：

class Animal {}
class Dog extends Animal {}
public class Test {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        if (myAnimal instanceof Dog) {
            Dog myDog = (Dog) myAnimal; // 安全的向下转型
            System.out.println("This is a Dog.");
        }
    }
}

在这个例子中，myAnimal instanceof Dog 检查 myAnimal 是否是 Dog 类的实例，因为 myAnimal 实际上指向的是一个 Dog 对象，所以这个表达式返回 true，随后可以安全地进行向下转型。需要注意的是，instanceof 操作符只能用于对象类型，不能用于基本数据类型。例如，以下代码是错误的：

int num = 5;
if (num instanceof Integer) { // 错误，基本数据类型不能使用 instanceof
    // ...
}

在使用 instanceof 时，还应该注意避免与过度的类型检查，这可能会使代码变得冗余和难以维护。在设计类和接口时，应尽量使用多态和接口来减少对 instanceof 的依赖。

Go语言中encoding的用法——Binary

Wed, 12 Feb 2025 00:00:00 GMT

encoding/binary是Go语言标准库中的一个包，用于实现数据的二进制编码和解码。这个包主要提供了将数据以大端或小端格式进行编码和解码的功能。

1. `binary.BigEndian` 和 `binary.LittleEndian`

这两个变量是binary包提供的两个实现了binary.ByteOrder接口的结构体，分别用于表示大端和小端字节序。

2. `Read` 方法

Read方法用于从字节切片中读取指定类型的数据。例如：

var data []byte = []byte{0x01, 0x02, 0x03, 0x04}
var value uint32
err := binary.BigEndian.Read(data, &value)
if err != nil {
    log.Fatal(err)
}
fmt.Println(value) // 输出: 16909060

3. `Write` 方法

Write方法用于将数据写入到字节切片中。例如：

var buffer []byte = make([]byte, 4)
var value uint32 = 16909060
err := binary.BigEndian.Write(buffer, value)
if err != nil {
    log.Fatal(err)
}
fmt.Println(buffer) // 输出: [1 2 3 4]

4. `Uvarint` 和 `Varint`

这两个函数用于处理变长整数（variable-length integers）。Uvarint用于解码一个无符号的变长整数，Varint用于解码一个有符号的变长整数。

buf := []byte{0x96, 0x01}
value, n := binary.Uvarint(buf)
if n <= 0 {
    log.Fatal("Uvarint error")
}
fmt.Println(value) // 输出: 150

5. `PutUvarint` 和 `PutVarint`

这两个函数用于将变长整数编码为字节切片。PutUvarint用于无符号整数，PutVarint用于有符号整数。

buf := make([]byte, 10)
n := binary.PutUvarint(buf, 150)
fmt.Println(buf[:n]) // 输出: [150 1]

注意事项

在使用Read和Write方法时，需要确保提供的字节切片长度足够。
变长整数的编码和解码在处理大量数据时可以节省空间，但可能会增加编码和解码的复杂性。

实际应用

encoding/binary包通常用于网络通信、文件存储等需要处理二进制数据的场景。例如，在实现自定义协议时，可以使用这个包来编码和解码消息头或消息体。以上是encoding/binary包的一些基本用法。在实际使用中，还需要根据具体的需求来选择合适的函数和方法。

在Go语言中，没有内置的方法可以自动将任意结构体转换为二进制格式。但是，你可以使用encoding/binary包中的函数手动实现这一功能。为了方便地将结构体转换为二进制，你通常需要确保结构体的字段是固定大小的基本数据类型，并且使用binary包中的Read和Write方法。下面是一个示例，展示如何定义一个结构体并将其转换为二进制数据：

package main
import (
	"bytes"
	"encoding/binary"
	"fmt"
	"io"
)
// 定义一个简单的结构体
type MyStruct struct {
	Field1 uint32
	Field2 int16
	Field3 bool
}
// 将结构体转换为二进制数据
func structToBinary(data interface{}) ([]byte, error) {
	buf := new(bytes.Buffer)
	err := binary.Write(buf, binary.BigEndian, data)
	if err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}
// 从二进制数据解析回结构体
func binaryToStruct(data []byte, obj interface{}) error {
	buf := bytes.NewReader(data)
	return binary.Read(buf, binary.BigEndian, obj)
}
func main() {
	// 创建结构体实例
	myData := MyStruct{
		Field1: 123456,
		Field2: -123,
		Field3: true,
	}
	// 转换为二进制
	binaryData, err := structToBinary(&myData)
	if err != nil {
		fmt.Println("Error converting to binary:", err)
		return
	}
	fmt.Println("Binary data:", binaryData)
	// 解析回结构体
	var myDataCopy MyStruct
	err = binaryToStruct(binaryData, &myDataCopy)
	if err != nil {
		fmt.Println("Error converting from binary:", err)
		return
	}
	fmt.Printf("Parsed struct: %+v\n", myDataCopy)
}

在这个示例中，我们定义了一个MyStruct结构体，并实现了两个函数structToBinary和binaryToStruct来处理结构体与二进制数据之间的转换。我们使用binary.Write来将结构体数据写入一个bytes.Buffer，然后将其转换为字节切片。同样，我们使用binary.Read来从字节切片中读取数据并填充到结构体中。请注意，为了使这个示例工作，结构体的所有字段都必须是导出的（即首字母大写），因为binary.Write和binary.Read函数需要访问这些字段。此外，结构体中的字段类型应该是binary包能够处理的类型。如果你想要更高级的序列化功能，比如支持更复杂的数据结构或自动处理字段标签，你可能需要使用像protobuf、msgpack或其他序列化库。这些库提供了更复杂的序列化机制，但需要你定义数据结构的方式符合它们的规范。

Go语言中结构体标签（tag）的用法

Sat, 08 Feb 2025 00:00:00 GMT

结构体标签（tag）是Go语言中一种为结构体字段提供额外元数据的机制。它们通常用于JSON序列化/反序列化、数据库映射等场景。下面将详细讲解结构体标签的用法：

1. 基本用法

结构体标签以字符串的形式紧跟在字段类型后面，用反引号`括起来。标签内部可以包含多个键值对，键和值之间用冒号:分隔，多个键值对之间用空格分隔。

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

在这个例子中，json:"name"和json:"age"是结构体标签。它们指定了在JSON序列化/反序列化时，Name字段对应JSON中的name键，Age字段对应JSON中的age键。

2. 多个标签

一个字段可以拥有多个标签，用于不同的场景。例如，同时为JSON和XML序列化提供标签：

type Person struct {
    Name string `json:"name" xml:"name"`
    Age  int    `json:"age" xml:"age"`
}

3. 标签键的命名

标签键的命名通常是场景或库特定的。例如，json键用于JSON处理，bson键用于MongoDB的BSON格式，xml键用于XML处理等。

4. 标签值的选项

标签值可以包含多个选项，用逗号,分隔。例如，在JSON标签中，可以使用omitempty选项来指示空值不应被序列化：

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age,omitempty"` // 如果Age为0，则不会被序列化
}

其他常见选项包括：

omitempty：空值不序列化。
string：强制将整数值序列化为字符串（用于JSON）。
inline：内联嵌套结构体的字段（用于JSON）。

5. 忽略字段

如果想要在序列化/反序列化时忽略某个字段，可以在标签中使用-：

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
    Ignored string `json:"-"` // 该字段将被忽略
}

6. 自定义标签

除了标准库支持的标签外，还可以自定义标签，用于特定的库或场景：

type Person struct {
    Name string `mytag:"name"`
    Age  int    `mytag:"age"`
}

在这里，mytag是一个自定义的标签键，可以根据需要自行解析和使用。

package main

import (
	"fmt"
	"reflect"
	"strings"
)

type Person struct {
	Name string `mytag:"name"`
	Age  int    `mytag:"age"`
}

func parseTags(v interface{}) {
	val := reflect.ValueOf(v)
	typ := val.Type()

	for i := 0; i < val.NumField(); i++ {
		field := val.Field(i)
		fieldType := typ.Field(i)
		tag := fieldType.Tag.Get("mytag")

		if tag != "" {
			fmt.Printf("Field: %s, MyTag: %s\n", fieldType.Name, tag)
		}
	}
}

func main() {
	p := Person{Name: "Alice", Age: 30}
	parseTags(p)
}

`v interface{}`

表示一个空接口，它是 Go 语言中所有类型的超集。任何类型都可以赋值给空接口。通常用于函数参数，允许函数接受任何类型的参数。

func printType(v interface{}) {
    fmt.Println(reflect.TypeOf(v))
}

func main() {
    printType(42)      // 输出：int
    printType("hello") // 输出：string
}

`reflect.ValueOf(v)`

反射包中的一个函数，用于获取传入参数 v 的反射值对象（reflect.Value）。这个对象包含了 v 的值和类型信息。通过 reflect.Value 对象，可以访问和操作原始值，包括获取类型信息、字段、方法等。

常用方法：
- Type()：返回值的类型信息（reflect.Type）。
- Kind()：返回值的类型种类，如 int, string, struct 等。
- Field(i int)：获取结构体的第 i 个字段。
- Method(i int)：获取方法的第 i 个方法。
- Interface()：将 reflect.Value 转换回空接口，可以再断言回原始类型。

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "Alice", Age: 30}
    v := reflect.ValueOf(p)

    fmt.Println(v.Type())          // 输出：main.Person
    fmt.Println(v.Kind())          // 输出：struct

    for i := 0; i < v.NumField(); i++ {
        field := v.Field(i)
        fmt.Printf("Field %d: %v\n", i, field.Interface())
    }
}

性能：反射通常比直接访问慢，因为它是运行时动态解析的。应避免在性能敏感的代码路径中使用反射。
类型断言：从 reflect.Value 转换回原始类型时，通常需要使用类型断言。
安全性：反射可以绕过编译时的类型检查，可能导致运行时错误。使用时需谨慎。

7. 结构体标签的解析

结构体标签的解析通常由相应的库完成。例如，encoding/json库会解析json标签，encoding/xml库会解析xml标签。自定义标签则需要自己编写解析逻辑。

示例：使用结构体标签进行JSON序列化

package main
import (
	"encoding/json"
	"fmt"
)
type Person struct {
	Name string `json:"name"`
	Age  int    `json:"age,omitempty"`
}
func main() {
	p := Person{Name: "Alice", Age: 0}
	jsonData, err := json.Marshal(p)
	if err != nil {
		fmt.Println("Error marshalling JSON:", err)
		return
	}
	fmt.Println(string(jsonData)) // 输出：{"name":"Alice"}
}

在这个示例中，由于Age字段使用了omitempty选项，并且其值为0（在Go中，0被视为itempty的空值），所以在序列化后的JSON中，age键被省略了。

示例

假设有以下复杂的JSON结构，其中包含重名字段：

{
  "user": {
    "name": "Alice",
    "email": "alice@example.com",
    "profile": {
      "name": "Alice Profile", // 重名字段
      "age": 30
    },
    "contacts": [
      {"type": "home", "number": "123-456-7890"},
      {"type": "work", "number": "987-654-3210"}
    ]
  },
  "settings": {
    "notifications": true,
    "theme": "dark"
  }
}

对应的Go结构体可能如下：

package main
import (
	"encoding/json"
	"fmt"
)
type User struct {
	Name    string   `json:"name"`
	Email   string   `json:"email"`
	Profile Profile  `json:"profile"`
	Contacts []Contact `json:"contacts"`
}
type Profile struct {
	Name string `json:"name"` // 使用相同的标签，但属于不同的结构体
	Age  int    `json:"age"`
}
type Contact struct {
	Type   string `json:"type"`
	Number string `json:"number"`
}
type Settings struct {
	Notifications bool   `json:"notifications"`
	Theme         string `json:"theme"`
}
type RequestBody struct {
	User     User     `json:"user"`
	Settings Settings `json:"settings"`
}
func main() {
	// 示例：序列化和反序列化
	// ...
}

在这个例子中：

User和Profile结构体都有一个名为Name的字段，但由于它们属于不同的结构体，所以不会冲突。
Contacts是一个切片，表示JSON中的数组。
Settings是一个独立的结构体，表示JSON中的另一个对象。如果结构体中确实需要处理重名字段，并且这些字段在同一个结构体中，那么可以使用不同的标签别名来区分它们：

type Example struct {
	Name  string `json:"name"`
	Name2 string `json:"name"` // 这将导致错误，因为标签相同
}
// 应该改为：
type Example struct {
	Name  string `json:"name"`
	Name2 string `json:"name2"` // 使用不同的标签别名
}

在反序列化时，JSON处理包会根据标签来决定哪个字段对应JSON中的哪个键。如果出现标签相同的情况，会导致反序列化失败，因为Go不允许同一个结构体中有相同的标签。

Git基本使用方法

Thu, 09 Jan 2025 00:00:00 GMT

初始化Git仓库

初始化一个Git仓库，使用git init命令。

添加文件到Git仓库，分两步：

使用命令git add <file>，注意，可反复多次使用，添加多个文件；
使用命令git commit -m <message>，完成。

工作区

要随时掌握工作区的状态，使用git status命令。
如果git status告诉你有文件被修改过，用git diff可以查看修改内容。

版本回退

HEAD指向的版本就是当前版本，因此，Git允许我们在版本的历史之间穿梭，使用命令git reset --hard commit_id。
穿梭前，用git log可以查看提交历史，以便确定要回退到哪个版本。
要重返未来，用git reflog查看命令历史，以便确定要回到未来的哪个版本。

撤销修改

场景1：当你改乱了工作区某个文件的内容，想直接丢弃工作区的修改时，用命令git checkout -- file。

场景2：当你不但改乱了工作区某个文件的内容，还添加到了暂存区时，想丢弃修改，分两步，第一步用命令git reset HEAD <file>，就回到了场景1，第二步按场景1操作。

场景3：已经提交了不合适的修改到版本库时，想要撤销本次提交，参考版本回退一节，不过前提是没有推送到远程库。

删除文件

先手动删除文件，然后使用git status命令会立刻告诉你哪些文件被删除了

现在有两个选择，一是确实要从版本库中删除该文件，那就用命令git rm删掉，并且git commit

另一种情况是删错了，因为版本库里还有呢，所以可以很轻松地把误删的文件恢复到最新版本：

$ git checkout -- test.txt

git checkout其实是用版本库里的版本替换工作区的版本，无论工作区是修改还是删除，都可以“一键还原”。从来没有被添加到版本库就被删除的文件，是无法恢复的！

远程仓库

初始化

要关联一个远程库，使用命令git remote add origin git@server-name:path/repo-name.git；

关联一个远程库时必须给远程库指定一个名字，origin是默认习惯命名；

关联后，使用命令git push -u origin master第一次推送master分支的所有内容；

此后，每次本地提交后，只要有必要，就可以使用命令git push origin master推送最新修改；

git config user.name "username"

git config user.email "username@example.com"

仓库克隆

要克隆一个仓库，首先必须知道仓库的地址，然后使用git clone命令克隆。

Git分支管理

Git鼓励大量使用分支：

查看分支：git branch

创建分支：git branch <name>

切换分支：git checkout <name>或者git switch <name>

创建+切换分支：git checkout -b <name>或者git switch -c <name>

合并某分支到当前分支：git merge <name>

删除分支：git branch -d <name>

如果要丢弃一个没有被合并过的分支，可以通过git branch -D <name>强行删除。

当Git无法自动合并分支时，就必须首先解决冲突。解决冲突后，再提交，合并完成。

解决冲突就是把Git合并失败的文件手动编辑为我们希望的内容，再提交。

$ git add readme.txt 
$ git commit -m "conflict fixed"

用git log --graph命令可以看到分支合并图。

bug分支

软件开发中，bug就像家常便饭一样。有了bug就需要修复，在Git中，由于分支是如此的强大，所以，每个bug都可以通过一个新的临时分支来修复，修复后，合并分支，然后将临时分支删除。

多人协作

多人协作的工作模式通常是这样：

首先，可以尝试用git push origin <branch-name>推送自己的修改；
如果推送失败，则因为远程分支比你的本地更新，需要先用git pull试图合并；
如果合并有冲突，则解决冲突，并在本地提交；
没有冲突或者解决掉冲突后，再用git push origin <branch-name>推送就能成功！

如果git pull提示no tracking information，则说明本地分支和远程分支的链接关系没有创建，用命令git branch --set-upstream-to <branch-name> origin/<branch-name>。

查看远程库信息，使用git remote -v；
本地新建的分支如果不推送到远程，对其他人就是不可见的；
从本地推送分支，使用git push origin branch-name，如果推送失败，先用git pull抓取远程的新提交；
在本地创建和远程分支对应的分支，使用git checkout -b branch-name origin/branch-name，本地和远程分支的名称最好一致；
建立本地分支和远程分支的关联，使用git branch --set-upstream branch-name origin/branch-name；
从远程抓取分支，使用git pull，如果有冲突，要先处理冲突。

.gitignore

不需要从头写.gitignore文件，GitHub已经为我们准备了各种配置文件，只需要组合一下就可以使用了。所有配置文件可以直接在线浏览：GitHub/gitignore

示例：

# Windows:
Thumbs.db
ehthumbs.db
Desktop.ini

# Python:
*.py[cod]
*.so
*.egg
*.egg-info
dist
build

# My configurations:
db.ini
deploy_key_rsa

# 排除所有.开头的隐藏文件:
.*
# 排除所有.class文件:
*.class

# 不排除.gitignore和App.class:
!.gitignore
!App.class

.gitignore写得有问题，需要找出来到底哪个规则写错了，可以用git check-ignore命令检查

go语言学习笔记（1）

Sat, 10 Aug 2024 00:00:00 GMT

编译器会自动选择在栈上还是在堆上分配局部变量的存储空间，这个选择并不是由用var还是new声明变量的方式决定的。因此，函数内声明的函数指针，赋值后，返回该指针，函数外仍然可用。
- Go语言的自动垃圾收集器是如何知道一个变量是何时可以被回收呢？基本的实现思路是，从每个包级的变量和每个当前运行函数的每一个局部变量开始，通过指针或引用的访问路径遍历，是否可以找到该变量。如果不存在这样的访问路径，那么说明该变量是不可达的，也就是说它是否存在并不会影响程序后续的计算结果。因为一个变量的有效周期只取决于是否可达，因此一个循环迭代内部的局部变量的生命周期可能超出其局部作用域。同时，局部变量可能在函数返回之后依然存在。

go语言中指针，实现类似c++中的*(p+1)来访问地址

func point() *int32 {
	var i int32 = 0
	return &i
}

func main(){
    var p = point()
	*p = 100
	var p1 = point()
	var p2 = point()
	*p2 = 200
    
    *(*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + uintptr(unsafe.Sizeof(*p)))) //*(p+1) -> p1
    *(*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + 2*uintptr(unsafe.Sizeof(*p))))  //*(p+2) ->p2
}

go中的swap：

a, b = b, a
num[0], num[1], num[2] = num[1], num[2], num[0]

切片操作可能出问题：

var nums = []int{1, 2, 3, 4, 5}
a := nums[1:3]
//对a的任何操作都会反作用于nums
//若a.append(a, 100)，那么会修改nums[3]的值。
//

匿名嵌入

type Point struct {
    X, Y int
}

type Circle struct {
    Center Point
    Radius int
}

type Wheel struct {
    Circle Circle
    Spokes int
}
var w Wheel
//因为匿名嵌入
w.X = 10 //等价于 w.Circle.Point.X = 10
w.Y = 100
//但是赋值的时候必须循环嵌套,下面这种会报错
w = Wheel{X: 8, Y: 8, Radius: 5, Spokes: 20} // compile error: unknown fields

导出结构，只有大写字母开头的成员才会被导出

type Movie struct {
	Title  string `json:"标题"`
	Year   int    `json:"年"`
	Color  bool   `json:"color, omitempty"` //omitempty选项，表示当Go语言结构体成员为空或零值时不生成该JSON对象
	Actors []string
	test   string // 小写字母开头不会被编码
}
var movies = []Movie{
	{Title: "Casablanca", Year: 1942, Color: false,
     Actors: []string{"Humphrey Bogart", "Ingrid Bergman", "Claude Rains"}, test: "test"}}

data, err := json.Marshal(movies)
//data的json字符串中没有test字段

c++程序编译

Thu, 09 May 2024 00:00:00 GMT

gcc/g++

g++ 是 GNU 编译器集合（GNU Compiler Collection）中的 C++ 编译器。以下是一些基本的 g++ 使用方法：

编译一个 C++ 源文件:
```
g++ -o output_file source_file.cpp
```
这条命令会编译 source_file.cpp 并生成名为 output_file 的可执行文件。
编译多个 C++ 源文件:
```
g++ -o output_file source1.cpp source2.cpp
```
如果你有多个源文件，可以一次性编译它们。
链接外部库:
```
g++ -o output_file source_file.cpp -llibrary
```
如果你的程序需要链接一个外部库（例如 -lstdc++ 是 C++ 标准库），可以在命令中加入 -l 选项后跟库的名字。
指定编译器的搜索路径:
```
g++ -o output_file source_file.cpp -I/include/path
```
使用 -I 选项可以指定头文件的搜索路径。
启用 C++11 或更高版本的标准:
```
g++ -o output_file source_file.cpp -std=c++11
```
如果你使用了 C++11 或更高版本的特性，需要使用 -std 选项指定版本。
优化代码:
```
g++ -o output_file source_file.cpp -O2
```
-O0 不优化。

-O1 O或-01对程序做部分编译优化，对于大函数，优化编译占用稍微多的时间和相当大的内存。使用本项优化，编译器会尝试减小生成代码的尺寸，以及缩短执行时间，但并不执行需要占用大量编译时间的优化。

-O2 比O1更高级的选项，进行更多的优化。与O1比较而言，O2优化增加了编译时间的基础上，提高了生成代码的执行效率。推荐使用

-O3比O2更优。
调试信息:
```
g++ -o output_file source_file.cpp -g
```
使用 -g 选项可以在编译时包含调试信息，这样你可以使用调试器（如 gdb）进行调试。
警告和错误:
```
g++ -o output_file source_file.cpp -Wall -Werror
```
-Wall 选项启用所有警告，-Werror 将警告视为错误，使得编译在遇到警告时停止。
运行程序:
```
./output_file
```
编译完成后，可以通过在命令行中输入可执行文件的名称来运行程序。这些是 g++ 的一些基本用法。根据你的具体需求，你可能会使用更多的选项和参数。g++ 的 man 页面提供了完整的选项列表和详细说明，可以通过运行 man g++ 来查看。

静态库

在 C++ 中，静态库（Static Library）是一种包含编译后的代码的文件，可以在链接阶段与其他源代码一起被链接到可执行文件中。静态库通常以 .a（在 Linux 和 macOS 上）或 .lib（在 Windows 上）文件扩展名结尾。以下是创建和使用静态库的基本步骤：

创建静态库

编写源代码: 创建一个或多个源文件（.cpp）和一个头文件（.h）。
编译源文件: 使用 g++（或其他编译器）将源文件编译成目标文件（.o）。
```
g++ -c source_file1.cpp source_file2.cpp
```
-c 选项告诉编译器只编译源文件，不进行链接。
创建静态库:
```
g++ -c -o libXXX.a source_file.cpp
```

使用静态库

包含头文件: 在使用静态库的源代码中包含库的头文件。
```
#include "libraryname.h"
```
编译源代码: 编译源代码时，指定静态库的路径和名称。
```
g++ -o output_file source_file.cpp -L/path/to/library -llibraryname
```
-L 选项指定静态库的路径，-l 选项指定静态库的名称（去掉 lib 前缀和 .a 或 .lib 后缀）。
链接静态库: 在链接阶段，链接器会从指定的路径中查找静态库，并将其链接到可执行文件中。

示例

假设你有以下文件：

library.h
library.cpp
main.cpp 首先，编译 library.cpp：

g++ -c -o liblibrary.a library.cpp

接下来，编译 main.cpp 并链接静态库：

g++ -o main main.cpp -L. -llibrary

最后，运行可执行文件：

./main

在这个例子中，. 表示当前目录，-llibrary 指定了静态库 liblibrary.a。请注意，这些步骤可能会根据你的操作系统和编译器有所不同。以上步骤适用于类 Unix 系统，如 Linux 和 macOS。在 Windows 上，你可能需要使用不同的命令和工具。

动态库

在使用g++编译动态库时，需要遵循几个步骤。以下是一个简单的指南：

编写源代码：动态库由源代码文件组成，通常是以.cpp为扩展名的C++源文件和以.h为扩展名的头文件。
创建编译命令：使用g++编译器，可以使用以下命令来编译一个动态库：
```
g++ -shared -fPIC -o libyourlibrary.so yoursourcefile.cpp
```
这里：
- -shared：告诉g++生成一个共享库。
- -fPIC：表示生成位置无关代码，这是创建动态库所必需的。
- -o：指定输出文件名。在Linux系统中，动态库通常以lib<name>.so的格式命名。
- yoursourcefile.cpp：这是的源代码文件。
包含头文件：如果动态库中有函数声明在头文件中，那么在使用这个库的时候需要包含这些头文件。
链接动态库：当编译使用这个动态库的代码时，需要指定动态库的位置，可以使用-L选项来指定库文件所在的目录，使用-l选项来指定库的名称（去掉lib前缀和.so后缀）。例如，如果的动态库叫libyourlibrary.so，在/usr/local/lib目录下，那么编译命令可能如下所示：
```
g++ -o yourprogram yourprogram.cpp -L/usr/local/lib -lyourlibrary
```
设置库路径：在运行使用动态库的程序之前，可能需要确保动态链接器知道库的位置。这可以通过设置LD_LIBRARY_PATH环境变量来实现：
```
export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH
```
运行程序：最后，可以通过输入程序名称来运行程序。如果一切设置正确，程序将能够找到并使用动态库。以上步骤是编译和使用动态库的基本流程。在具体实施时，可能需要根据具体环境和需求进行适当的调整。

python中网页解析库及基本用法

Tue, 13 Feb 2024 00:00:00 GMT

lxml

安装
pip install lxml
基本使用
- ```
from lxml import etree

html = etree.HTML(text)
res = html.xpath(xpath_string)
```
- 限制属性：'//div[@class="attr0"]'
- 获取文本：'//div/text()'
- 获取属性：‘//li/a/@href’

Beautifal Soup

安装
- pip install beautifulsoup4

基本使用

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'lxml')
for i, child in enumerate(soup.children):
    print(i, child)

获取属性：soup.p.attrs['name']
获取文本：soup.p.tring （默认为当前节点下的第一个p节点）

方法选择器find_all(name, attrs, recursive, text), find类似但返回单个
- 查找所有ul节点：soup.find_all(name='ul')
- 加入属性：soup.find_all(name='ul', attrs={'id':'demo1'})

python中requests的基本用法

Mon, 12 Feb 2024 00:00:00 GMT

requests

发起的是同步网络请求

导入

import requests

请求

get

requests.get(...)

传递参数

data = {
	'name':'amy',
	'age':15
}
headers = {
	'...':'...'
}
res = requests.get(url, params=data, headers=headers)
res.json() # 转为字典，若返回不是json格式将报错

若网站的SSL出错，则可以不进行SSL验证requests.get(url, verify=False)
超时设置requests.get(url, timeout=1) 单位为：秒。(设置为None表示永久等待)
登录验证：requests.get(url, auth=(username, password))

获取二进制数据（图片、音频、视频等）

res = requests.get('...../a.png', params=data)
with open('a.png', 'wb') as f:
	f.write(res.content)

post

类似于get

session

session = requests.session()

session.get(...)

响应

res.status_code

res.headers

res.cookies

res.url

res.history 请求历史

说说

Thu, 09 Sep 1999 00:00:00 GMT

2025-03-16: 四年了，黑魂3全成就！

2025-03-15: 太棒了，是Maven！

2025-03-10: 开干！

AuroraLilis

Spring框架

Spring 框架

核心概念

HTTP协议

基本介绍

请求

GET

POST

示例

常见状态码

YAML配置文件

一、基本语法

二、数据类型

三、特殊语法

四、示例

五、使用场景

virtual在使用中的问题

virtual在使用中的问题

纯虚方法和抽象基类

override关键字

虚基类

C++用户自定义字面量

用户自定义字面量的基本语法

使用用户自定义字面量

用户自定义字面量的类型

注意事项

实际应用

系统自带的字面量

C++可变参数

C风格的变参函数

C++11的初始化列表和变参模板

折叠表达式

折叠表达式的语法

折叠表达式的工作原理

在例子中的应用

优点

例子1：打印多个值

例子2：计算多个数的和

例子3：连接字符串

例子4：检查所有参数是否满足某个条件

例子5：使用初始化列表和折叠表达式创建数组

C++类型别名

1. 基本概念

2. 语法区别

typedef 的语法

using 的语法

3. 复杂类型的处理

函数指针

多维数组

模板类型

4. 模板别名（Template Aliases）

using 的模板别名

typedef 的局限性

5. 匿名类型

6. 可读性和现代性

7. 其他特性

总结：何时使用？

示例对比

explicit关键字

explicit与构造函数

explicit与转换函数

为什么使用explicit？

JUnit

JUnit 基本用法

添加依赖

编写测试类

运行测试

JUnit 高级特性

注解

断言

JUnit 的新特性

JUnit 5架构

注解改进

断言改进

参数化测试改进

示例

C++右值及相关用法

右值和右值引用

基本概念

`explicit`与构造函数

`explicit`与转换函数

为什么使用`explicit`？

`std::move`的应用示例

`ReentrantLock`

创建 `ReentrantLock` 实例

`ReadWriteLock`

`wait()`, `notify()`, `notifyAll()`方法