jasper

拓扑排序

Sat, 28 Mar 2026 21:03:05 +0000

[原理](https://jingsam.github.io/2020/08/11/topological-sort.html) ##### kahn实现 - 采用入度，以循环迭代方式实现 ##### 算法逻辑 - 使用队列记录indegree为0的节点 - 依次出队，遍历更新其outdegree节点，若其indegree为0,则入队 - 最后，若存在环，则idx < n ```java int[] topoSort(int n, int[][] edges) { List> graph = new ArrayList<>(); for(int i = 0;i < n;i++) { graph.add(new ArrayList<>()); } int[] indegree = new int[n]; for(int[] e : edges) { graph.get(e[0]).add(e[1]); indegree[e[1]]++; } Queue q = new ArrayDeque<>(); for(int i = 0;i < n;i++) { if(indegree[i] == 0) q.offer(i); } int[] ans = new int[n]; int idx = 0; while(!q.isEmpty()) { int c = q.poll(); ans[idx++] = c; for(int next : graph.get(c)) { indegree[next]--; if(indegree[next] == 0) q.offer(next); } } if(idx < n) return new int[]{}; return ans; } ``` ##### dfs实现(未学) - 采用出度，以递归实现 ```java ``` 。

辗转相除法

Fri, 01 Aug 2025 09:31:02 +0000

### 算法步骤: (Know-How) 1. 设有两个正整数a和b，且a > b。

mysql主从配置

Fri, 09 May 2025 22:21:16 +0000

##### 一主多从主库my.cnf配置: ```mysql [mysqld] bind-address = 0.0.0.0 port = 3306 server-id = 1 log-bin = mysql-bin binlog-do-db = sharding_jdbc_demo binlog-do-db = sharding_jdbc_demo2 binlog-do-db = sharding_jdbc_userdb ``` 从库my.cnf配置 ```sql [mysqld] # 基础配置 basedir=/home/jasper/桌面/apps/mysql/mysql-8.0.42-linux-glibc2.28-x86_64 # 修改为你的MySQL解压目录（即bin的上级） datadir=/home/jasper/桌面/apps/mysql/mysql-8.0.42-linux-glibc2.28-x86_64/mysql_data socket=/home/jasper/桌面/apps/mysql/mysql-8.0.42-linux-glibc2.28-x86_64/mysql.sock pid-file=/home/jasper/桌面/apps/mysql/mysql-8.0.42-linux-glibc2.28-x86_64/mysql.pid bind-address = 0.0.0.0 port=3307 # 避免与主库冲突 # 日志配置 log-error=/home/jasper/桌面/apps/mysql/mysql-8.0.42-linux-glibc2.28-x86_64/mysql.err log-bin=/home/jasper/桌面/apps/mysql/mysql-8.0.42-linux-glibc2.28-x86_64/mysql-bin.log # server id 必须唯一 server-id=2 # 复制配置 relay-log=/home/jasper/桌面/apps/mysql/mysql-8.0.42-linux-glibc2.28-x86_64/mysql-relay-bin read_only=1 # 只复制主库中的某个数据库（可选） replicate-do-db=sharding_jdbc_demo replicate-do-db=sharding_jdbc_demo2 replicate-do-db=sharding_jdbc_userdb ``` 初始化从库 ```shell ./mysqld --defaults-file=./my.cnf --initialize-insecure ``` > **error:** > > error while loading shared libraries: libaio.so.1: cannot open shared object file: No such file or directory > > **解决:** > > 安装并创建软链接 > > ```shell > sudo apt install libaio-dev > ldconfig -p | grep libaio # 找到此lib > sudo ln -s /lib/x86_64-linux-gnu/libaio.so.1t64 /lib/x86_64-linux-gnu/libaio.so.1 > ``` > > 启动从库 ```shell ./mysqld_safe --defaults-file=./my.cnf ``` 配置master信息并启动replica ```sql # 在主库中获取LOG_File以及LOG_POS # 低版本: show master status; # 高版本: show binary log status; CHANGE REPLICATION SOURCE TO SOURCE_HOST='127.0.0.1', SOURCE_PORT=3306, SOURCE_USER='root', SOURCE_PASSWORD='pubgM666', SOURCE_LOG_FILE='mysql-bin.000006', SOURCE_LOG_POS=158; start replica; ``` 。

sharding-jdbc分库分表

Fri, 09 May 2025 21:52:35 +0000

##### 分库分表 - 垂直分表 > 将频繁访问的属性与访问率较低的属性,拆分到两张表 - 垂直分库 > 将不相关的业务实体,拆分到两个数据库 - 水平分库 > 将表数据划分到不同的数据库 - 水平分表 > 将表水平拆分成多个表 ##### sharding-jdbc-sql执行过程 1. 解析 2. 改写 3. 路由 4. 执行 5. 归并 ##### 水平分表demo **水平分表** `sql`准备,创建两张表: `t_order_1`,`t_order_2` ```sql create table t_order_2( `id` bigint primary key comment '订单id', `product_id` bigint not null comment '商品id', `amount` int not null comment '购买数量', `buyer_id` bigint not null comment '购买者id', `create_date` datetime not null comment '下单时间', `status` int not null default 0 comment '订单状态 0: 未支付, 1: 已支付, 2: 超时, 3: 取消, 4: 其他', `pay_time` datetime null comment '支付时间' ) engine=innodb default charset=utf8mb4 comment='订单表2'; ``` `maven`依赖 ```xml org.springframework.boot spring-boot-starter-web 2.7.15 org.slf4j slf4j-api org.springframework.boot spring-boot-starter-logging org.projectlombok lombok 1.18.34 mysql mysql-connector-java 8.0.30 com.baomidou mybatis-plus-boot-starter 3.5.5 org.slf4j slf4j-api com.github.xiaoymin knife4j-openapi2-spring-boot-starter 4.2.0 org.apache.shardingsphere sharding-jdbc-spring-boot-starter 4.1.1 org.springframework.boot spring-boot-starter-logging 2.7.15 17 17 UTF-8 ``` `yaml`配置 ```yaml server: port: 8888 mybatis-plus: configuration: map-underscore-to-camel-case: true spring: # sharding-jdbc 配置 shardingsphere: datasource: names: m1 m1: type: com.zaxxer.hikari.HikariDataSource driver-class-name: com.mysql.cj.jdbc.Driver jdbc-url: jdbc:mysql://localhost:3306/sharding_jdbc_demo?serverTimezone=UTC username: root password: pubgM666 sharding: tables: t_order: actual-data-nodes: m1.t_order_$->{1..2} table-strategy: inline: sharding-column: id algorithm-expression: t_order_$->{id % 2 + 1} key-generator: column: id type: SNOWFLAKE props: worker: id: 100 max: tolerate: time: difference: milliseconds: 20 ``` **细节** 1. 雪花算法生成的字段,在insert时,需要自定义`sql`,将次字段从`sql`插入字段中去除: > 比如: > > 定义id字段为雪花算法自动生成,则`insert sql`为: > > ```java > @Insert('insert into t_order(product_id, amount, buyer_id, create_date, status, pay_time) values(#{productId}, #{amount}, #{buyerId}, #{createDate}, #{status}, #{payTime})') > int insert(TOrder tOrder); > ``` 2. 依赖不能导错,`sharding-jdbc`依赖: ```xml org.apache.shardingsphere sharding-jdbc-spring-boot-starter 4.1.1 ``` ###### 碰到的bug 1. `sharding-jdbc-spring-boot-starter`,无法解析`LocalDateTime`以及`LocalDate` > 修复: > > - 依赖升级 > > ```xml > > org.apache.shardingsphere > shardingsphere-jdbc-core-spring-boot-starter > 5.2.1 > > > org.yaml > snakeyaml > > > > ``` > > - `5.x.x`版本yml配置不同,更改为: > > ```yaml > spring: > shardingsphere: > datasource: > names: m1 > m1: > type: com.zaxxer.hikari.HikariDataSource > driver-class-name: com.mysql.cj.jdbc.Driver > jdbc-url: jdbc:mysql://localhost:3306/sharding_jdbc_demo?serverTimezone=UTC > username: root > password: pubgM666 > > rules: > sharding: > tables: > t_order: > actual-data-nodes: m1.t_order_$->{1..2} > table-strategy: > standard: > sharding-column: id > sharding-algorithm-name: t_order_inline > key-generate-strategy: > column: id > key-generator-name: snowflake > > sharding-algorithms: > t_order_inline: > type: INLINE > props: > algorithm-expression: t_order_$->{id % 2 + 1} > > key-generators: > snowflake: > type: SNOWFLAKE > props: > worker-id: 100 > max-tolerate-time-difference-milliseconds: 20 > > props: > sql-show: true # 开启SQL打印，方便调试 > ``` 2. `mybatis-plus`与`sharding-jdbc`的不兼容 > 解决: `sql`都使用`mapper`方式定义,不使用`mybatis-plus` ##### 水平分库demo **`yml`配置:** ```yaml spring: shardingsphere: datasource: names: m1, m2 m1: type: com.zaxxer.hikari.HikariDataSource driver-class-name: com.mysql.cj.jdbc.Driver jdbc-url: jdbc:mysql://localhost:3306/sharding_jdbc_demo?serverTimezone=UTC username: root password: pubgM666 m2: type: com.zaxxer.hikari.HikariDataSource driver-class-name: com.mysql.cj.jdbc.Driver jdbc-url: jdbc:mysql://localhost:3306/sharding_jdbc_demo2?serverTimezone=UTC username: root password: pubgM666 rules: sharding: tables: t_order: actual-data-nodes: m$->{1..2}.t_order_$->{1..2} database-strategy: standard: sharding-column: product_id sharding-algorithm-name: t_order_database_inline table-strategy: standard: sharding-column: id sharding-algorithm-name: t_order_inline key-generate-strategy: column: id key-generator-name: snowflake sharding-algorithms: t_order_inline: type: INLINE props: algorithm-expression: t_order_$->{id % 2 + 1} t_order_database_inline: type: INLINE props: algorithm-expression: m$->{product_id % 2 + 1} key-generators: snowflake: type: SNOWFLAKE props: worker-id: 100 max-tolerate-time-difference-milliseconds: 20 props: sql-show: true # 开启SQL打印，方便调试 ``` ##### 垂直分库 **数据库准备** ```sql create database sharding_jdbc_userdb; create table `user`( `id` bigint auto_increment primary key comment 'id,主键', `username` varchar(16) not null comment '用户名', `encoded_password` varchar(256) not null comment '加密后的密码', `salt` char(16) not null comment '随机盐', `create_date` datetime not null comment '创建时间' )engine=innodb default charset=utf8mb4 comment='用户表'; ``` ##### 广播表若垂直分库后,部分库都需要对某个表join,并且此表数据读u多写少,可以将其作为为公告表 ```sql create table common( `id` bigint primary key auto_increment comment '主键', `name` varchar(32) null comment '名字' )engine=innodb default charset=utf8mb4 comment='公共表'; ``` **`yml`配置:** ```yaml spring: shardingsphere: rules: sharding: # 广播表 broadcast-tables: common ``` ##### sharding-jdbc读写分离 > `sharding-jdbc`根据`sql`语义,将写操作路由至`master`,将读操作路由至`slave`.提供透明化读写操作,像使用一个数据库一样使用主从数据库集群. > > ![image-20250429231159360](http://192.168.1.101:9000/kijjqvbsoduu/imgs/image-20250429231159431.png) `yaml`配置 ```yaml rules: readwrite-splitting: data-sources: m0_group: static-strategy: write-data-source-name: m0 read-data-source-names: - s0 load-balancer-name: round_robin load-balancers: round_robin: type: ROUND_ROBIN sharding: # 广播表 broadcast-tables: common tables: user: actual-data-nodes: m0_group.user ``` ##### 实践 **描述:** 以商品为例,进行实践. ###### 数据库设计 > *entity:* > > - 商品 > - 店铺 > - 地理区域 > > *垂直分库:* > > 将商品以及店铺划分到product_db,store_db > > *垂直分表:* > > 将商品信息划分为product_info,product_desc > > *广播表:* > > region > > *水平分库:* > > 将product_db根据store_id分库 > > *水平分表:* > > 将product_info根据product_id分表 ###### sql准备 product_info ```sql create database product_db_1; create database product_db_2; create table product_info_1( `id` bigint primary key comment '商品id', `store_id` bigint not null comment '所属店铺id', `name` varchar(64) not null comment '商品名称', `specification` varchar(8) not null comment '规格', `source_place` varchar(16) null comment '产地', `price` decimal not null comment '价格', `pic_url` varchar(200) not null comment '图片url' ) engine=innodb default charset=utf8mb4 comment='商品信息表'; ``` product_desc ```sql create table product_desc_1( `id` bigint auto_increment primary key comment 'id', `product_id` bigint not null comment '商品id', `store_id` bigint not null comment '店铺id', `desc` text not null comment '商品描述' ) engine=innodb default charset=utf8mb4 comment '商品描述表'; ``` store ```sql create databse store_db; create table store( `id` bigint primary key auto_increment comment '店铺id', `name` varchar(32) not null comment '店铺名称', `score` float null default 0 comment '店铺评分', `source_place_id` bigint not null comment '店铺所在地' ) engine=innodb default charset=utf8mb4 comment '店铺信息表'; ``` region ```sql create table region( `id` bigint primary key auto_increment comment 'id', `code` bigint not null comment '地域编码', `name` varchar(32) not null comment '地理区域名称', `level` int not null comment '级别,省:1 市:2 县:3 镇:4', `parent` bigint null comment '上级地理区域' ) engine=innodb default charset=utf8mb4 comment '地域信息表'; ``` 。

LIS优化(nlogn)

Thu, 03 Apr 2025 21:06:48 +0000

**示例：**$[3,1,5,6,4,2]$ **定义：**$f[i]$定义为长度为$i$的子序列右端点最小值 **模拟：** $i=0$： > $f[1]$ = 3 $i=1$： > $f[1]=1$ $i=2$： > $f[1]=1$，$f[2]=5$ $i=3$： > $f[1]=1$，$f[2]=5$，$f[3]=6$ $i=4$： > $f[1]=1$，$f[2]=4$，$f[3]=6$ $i=5$： > $f[1]=1$，$f[2]=2$，$f[3]=6$ **疑惑：** - 为什么是$f[i]$是递增的？ > 观察模拟过程，贪心地维护$f[i]$的最小值， > > 考虑$nums[i]$，若$nums[i]>f[k]$ 且$nums[i] > 则可以替换$f[k+1]$为$nums[i]$， > > 因为$f[k+1]$是基于$f[k]$构建的长度为$k+1$的序列。

素数判定

Tue, 18 Mar 2025 07:29:41 +0000

**四大判定法** ![Image](https://github.com/user-attachments/assets/e2849b70-739e-46b1-90df-16eb1d9dfecd) 1. 试除法 ```java boolean prime(int v) { if(v < 2) return false; if(v == 2) return true; if(v % 2 == 0) return false; for(int i = 3;i * i <= v;i += 2) { if(v % i == 0) return false; } return true; } ``` 2. 埃氏筛 **[[详解](https://zh.wikipedia.org/wiki/%E5%9F%83%E6%8B%89%E6%89%98%E6%96%AF%E7%89%B9%E5%B0%BC%E7%AD%9B%E6%B3%95)](https://zh.wikipedia.org/wiki/%E5%9F%83%E6%8B%89%E6%89%98%E6%96%AF%E7%89%B9%E5%B0%BC%E7%AD%9B%E6%B3%95)** ```java /*** * * @param n 求[2 - n]范围内的素数 * @return boolean数组，false则为素数 */ boolean[] eratosthenes(int n) { int g = (int) Math.sqrt(n); boolean[] b = new boolean[n + 1]; for(int i = 2;i <= n;++i) { if(!b[i]) { if(i > g) break; for(int k = i * i;k <= n;k += i) { b[k] = true; } } } return b; } ``` 3. 欧拉筛 ```java static List ps = new ArrayList<>(); static boolean[] b = new boolean[10001]; static { b[0] = b[1] = true; for(int i = 2;i <= 10000;i++) { if(!b[i]) ps.add(i); for(int p : ps) { if(i * p > 10000) break; b[i * p] = true; if(i % p == 0) break; } } } ``` 4. Miller-Rabin。

rabbitmq_spring_amqp

Thu, 06 Mar 2025 05:02:15 +0000

##### 依赖 ```xml org.springframework.boot spring-boot-starter-amqp 3.2.10 org.springframework.boot spring-boot-starter-logging ``` ##### 如何声明队列、如何创建消费者？ **由配置类完成：** - 声明队列，，注入容器 - 创建consumer类，@Bean注入容器对于consumer，也可直接@component注入容器 **consumer涉及注解：** - @RabbitListener - @RabbitHandler ```java @Configuration @Profile({'tut2', 'work-queues'}) public class Tut2Config { @Bean public Queue queue() { return new Queue('hello_a'); } @Profile({'receiver'}) private static class ReceiverConfig { @Bean public Tut2Receiver receiver1() { return new Tut2Receiver(1); } @Bean public Tut2Receiver receiver2() { return new Tut2Receiver(2); } } @Profile({'sender'}) @Bean public Tut2Sender sender() { return new Tut2Sender(); } } ``` ##### 如何发送消息？ - RabbitTemplate对底层代码做了封装，可直接注入使用 - 对RabbiTemplate再做一层封装 ##### fanout使用示例 - 配置类 ```java @Configuration @Profile({'tut3', 'publish-subscribe'}) public class Tut3Config { @Bean public FanoutExchange fanoutExchange() { return new FanoutExchange('tut.fanout'); } @Profile({'receiver'}) private static class Receiver { @Bean public Queue autoDeleteQueue1() { return new AnonymousQueue(); } @Bean public Queue autoDeleteQueue2() { return new AnonymousQueue(); } @Bean public Binding binding1(@Autowired @Qualifier('autoDeleteQueue1') Queue autoDeleteQueue1, FanoutExchange fanoutExchange) { return BindingBuilder.bind(autoDeleteQueue1).to(fanoutExchange); } @Bean public Binding binding2(@Autowired @Qualifier('autoDeleteQueue2') Queue autoDeleteQueue2, FanoutExchange fanoutExchange) { return BindingBuilder.bind(autoDeleteQueue2).to(fanoutExchange); } @Bean public Tut3Receiver tut3Receiver() { return new Tut3Receiver(); } } @Profile({'sender'}) @Bean public Tut3Sender tut3Sender() { return new Tut3Sender(); } } ``` - producer ```java public class Tut3Sender { @Autowired private RabbitTemplate rabbit; @Autowired private FanoutExchange fanoutExchange; @Scheduled(fixedDelay = 1000, initialDelay = 500) public void send() { Random random = new Random(); String message = '广播消息' + random.nextInt(Integer.MAX_VALUE); rabbit.convertAndSend(fanoutExchange.getName(), '', message); } } ``` - consumer ```java public class Tut3Receiver { @RabbitListener(queues = {'#{autoDeleteQueue1.name}'}) public void receive1(String body) { System.out.println('worker-1消费消息：' + body); } @RabbitListener(queues = {'#{autoDeleteQueue2.name}'}) public void receive2(String body) { System.out.println('worker-2消费消息：' + body); } } ``` ##### direct使用示例 - 配置类 ```java @Configuration @Profile({'tut4'}) public class Tut4Config { @Bean public DirectExchange directExchange() { return new DirectExchange('tut.direct'); } @Profile({'receiver'}) private static class Receiver { @Bean public Queue q1() { return new AnonymousQueue(); } @Bean public Queue q2() { return new AnonymousQueue(); } @Bean public Binding b1(@Autowired @Qualifier('q1') AnonymousQueue q1, DirectExchange exchange) { return BindingBuilder.bind(q1).to(exchange).with('1'); } @Bean public Binding b2(@Autowired @Qualifier('q1')AnonymousQueue q1, DirectExchange exchange) { return BindingBuilder.bind(q1).to(exchange).with('2'); } @Bean public Binding b3(@Autowired @Qualifier('q2')AnonymousQueue q2, DirectExchange exchange) { return BindingBuilder.bind(q2).to(exchange).with('3'); } @Bean public Binding b4(@Autowired @Qualifier('q2')AnonymousQueue q2, DirectExchange exchange) { return BindingBuilder.bind(q2).to(exchange).with('4'); } @Bean public Tut4Receiver receiver() { return new Tut4Receiver(); } } @Profile({'sender'}) @Bean public Tut4Sender sender() { return new Tut4Sender(); } } ``` - producer ```java public class Tut4Sender { @Autowired private RabbitTemplate rabbit; @Autowired private DirectExchange exchange; @Scheduled(fixedDelay = 1000, initialDelay = 500) public void send() { Random random = new Random(); int v = random.nextInt(5); rabbit.convertAndSend(exchange.getName(), String.valueOf(v), v); } } ``` - consumer ```java public class Tut4Receiver { @RabbitListener(queues = {'#{q1.name}'}) public void receive1(String body) { System.out.println('1-消费了消息：' + body); } @RabbitListener(queues = {'#{q2.name}'}) public void receive2(String body) { System.out.println('2-消费了消息：' + body); } } ``` ##### topic使用示例 - 配置类 ```java @Configuration @Profile({'tut5'}) public class Tut5Config { @Bean public TopicExchange topicExchange() { return new TopicExchange('tut.topic_exchange'); } @Profile({'receiver'}) private static class Receiver { @Bean public Queue q1() { return new AnonymousQueue(); } @Bean public Queue q2() { return new AnonymousQueue(); } @Bean public Binding b1(@Autowired @Qualifier('q1') Queue q1, TopicExchange exchange) { return BindingBuilder.bind(q1).to(exchange).with('*.orange.*'); } @Bean public Binding b2(@Autowired @Qualifier('q2') Queue q2, TopicExchange exchange) { return BindingBuilder.bind(q2).to(exchange).with('*.*.rabbit'); } @Bean public Binding b3(@Autowired @Qualifier('q2') Queue q2, TopicExchange exchange) { return BindingBuilder.bind(q2).to(exchange).with('lazy.#'); } @Bean public Tut5Receiver receiver() { return new Tut5Receiver(); } } @Profile({'sender'}) @Bean public Tut5Sender sender() { return new Tut5Sender(); } } ``` - producer ```java public class Tut5Sender { @Autowired private RabbitTemplate rabbit; @Autowired private TopicExchange exchange; private final String[] routingKeys = {'quick.orange.rabbit', 'lazy.orange.elephant', 'quick.orange.fox', 'lazy.brown.fox', 'lazy.pink.rabbit', 'quick.brown.fox'}; @Scheduled(fixedDelay = 2000, initialDelay = 500) public void send() { Random random = new Random(); String routingKey = routingKeys[random.nextInt(routingKeys.length)]; rabbit.convertAndSend(exchange.getName(), routingKey, routingKey); } } ``` - consumer ```java public class Tut5Receiver { @RabbitListener(queues = {'#{q1.name}'}) public void receive1(String body) { System.out.println('*.orange.* 消费消息：' + body); } @RabbitListener(queues = {'#{q2.name}'}) public void receive2(String body) { System.out.println('*.*.rabbit | lazy.# 消费消息：' + body); } } ``` 。

rabbitmq_java

Tue, 04 Mar 2025 22:10:07 +0000

##### rabbitmq安装教程 **环境：ubuntu** 1. 直接使用[官网](https://www.rabbitmq.com/docs/install-debian#apt-quick-start-cloudsmith)提供的一键脚本，会安装较新的erlang以及rabbit-server 2. 启用插件管理，开启web端 ```shell rabbitmq-plugins enable rabbitmq_management ``` 3. 默认web端只支持localhost访问，额外配置： ```shell # 添加用户 rabbitmqctl add_user jasper pubgM666 # 设置为管理员 rabbitmqctl set_user_tags jasper administrator # 授予权限 rabbitmqctl set_permissions -p / jasper '.*' '.*' '.*' # restart systemctl restart rabbitmq-server ``` ##### tabbitmq简单使用 ###### 依赖 ```xml com.rabbitmq amqp-client 5.19.0 org.slf4j slf4j-api 2.0.11 org.slf4j slf4j-simple 2.0.11 ``` ###### hello world 1. producer ```java package wwb.rabbitmq.producer; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory; import java.nio.charset.StandardCharsets; public class HelloProducer { public static void main(String[] args) { ConnectionFactory factory = new ConnectionFactory(); factory.setHost('172.24.192.134'); factory.setPort(5672); factory.setUsername('jasper'); factory.setPassword('pubgM666'); factory.setVirtualHost('/'); try (Connection connection = factory.newConnection(); Channel channel = connection.createChannel()) { channel.queueDeclare('hello', false, false, false, null); channel.basicPublish('', 'hello', null, '你好'.getBytes(StandardCharsets.UTF_8)); } catch (Exception e) { } } } ``` 2. consumer ```java package wwb.rabbitmq.consumer; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory; import com.rabbitmq.client.DeliverCallback; public class HelloConsumer { public static void main(String[] args) throws Exception{ ConnectionFactory factory = new ConnectionFactory(); factory.setHost('172.24.192.134'); factory.setPort(5672); factory.setUsername('jasper'); factory.setPassword('pubgM666'); factory.setVirtualHost('/'); Connection connection = factory.newConnection(); Channel channel = connection.createChannel(); channel.queueDeclare('hello', false, false, false, null); DeliverCallback deliverCallback = (consumerTag, mess) -> { String message = new String(mess.getBody(), 'UTF-8'); System.out.println(message); }; channel.basicConsume('hello', true, deliverCallback, tag -> {}); } } ``` ###### acknowlegement ```java public static void main(String[] args) throws Exception{ ConnectionFactory factory = new ConnectionFactory(); factory.setHost('172.24.192.134'); factory.setPort(5672); factory.setUsername('jasper'); factory.setPassword('pubgM666'); Connection connection = factory.newConnection(); Channel channel = connection.createChannel(); channel.queueDeclare('workqueues', false, false, false, null); // 设置一次只接受一个未消费消息 channel.basicQos(1); Random random = new Random(); StringBuilder sb = new StringBuilder(); for(int i = 0;i < 4;i++) { sb.append((char) (random.nextInt(26) + 97)); } String workerName = sb.toString(); DeliverCallback callback = (tag, entity) -> { String body = new String(entity.getBody(), StandardCharsets.UTF_8); for(int i = 0;i < body.length();++i) { if(body.charAt(i) == '.') { try { TimeUnit.MILLISECONDS.sleep(300); } catch (InterruptedException e) { throw new RuntimeException(e); } } } // 手动返回ack channel.basicAck(entity.getEnvelope().getDeliveryTag(), false); System.out.println(workerName + '消费了：' + body); }; channel.basicConsume('workqueues', false, callback, tag -> {}); } ``` ###### message durability 如何确保消息不会丢失： 1. 队列持久化，声明队列时，第二个参数 ```java channel.queueDeclare('workqueues', true, false, false, null); ``` 2. 消息持久化，发送消息时声明 ```java channel.basicPublish('', 'workqueues', MessageProperties.PERSISTENT_TEXT_PLAIN, body.getBytes(StandardCharsets.UTF_8)); ``` 如此过后消息可靠性大幅提升，已经可以满足大部分情况，但是还是存在一个小的窗口导致消息丢失，因为rabbitmq收到消息时，并不会保证将每条消息都刷盘，而是存在缓冲区。

tarjan算法

Thu, 02 Jan 2025 16:54:25 +0000

#### tarjan算法 [tarjan学习](https://oi-wiki.org/graph/scc/) > Robert E. Tarjan（计算机科学家）发明了很多算法和数据结构，有： > > > 已学习：✓ > > > > 未学习：× > > - 并查集（✓） > - Splay（×） > - Toptree（×） > - Tarjan（dfs求强连通分量、dfs求割点、dfs求割边）(✓) ##### 1.在有向图中求强连通分量 **强连通分量（Strongly Connected Components）**：极大的强连通子图 tarjan算法基于dfs，并且维护一个栈，m每次把尚未处理的节点加入栈中并且，每个节点还维护了以下两个变量： - dfn：dfs时遍历节点的次序 - low(low link value)：子树中能够回溯到的最早的在stack中的dfn 对于一个连通分量，第一个dfs到的节点的dfn = low，这时将stack里 >= dfn的节点pop ##### 2.在无相图中求割点基于1进行变形 - 对于根节点，若子树大于等于2，则为割点 - 对于某个节点u的子节点，若存在一个节点v的low值大于等于dfn(u)，则u为割点 > why？：因为若去掉点u，则点v无法回到祖先节点（因为点v能够回到祖先节点是依赖点u），形成新的连通分量 ##### 3.在无向图中求割边基于1进行变形 - 若某个节点v的dfn == low(v) ，则代表其无法回到祖先节点，也无法通过另一条边回到父亲节点，则其父节点u到v的这条边即为割边割边例题：[1192.查找集群内的关键连接](https://leetcode.cn/problems/critical-connections-in-a-network/description/?envType=study-plan-v2&envId=graph-theory) 实现： ```java class Solution { // tarjan 割边 int p = 0; List> ans; public List> criticalConnections(int n, List> connections) { Map> map = new HashMap<>(); for(List e : connections) { map.computeIfAbsent(e.get(0), k -> new ArrayList<>()).add(e.get(1)); map.computeIfAbsent(e.get(1), k -> new ArrayList<>()).add(e.get(0)); } int[] dfn = new int[n]; int[] low = new int[n]; boolean[] v = new boolean[n]; Set set = new HashSet<>(); ArrayDeque stack = new ArrayDeque<>(); ans = new ArrayList<>(); dfs(map, stack, set, v, dfn, low, 0, -1); return ans; } private void dfs(Map> map, ArrayDeque stack, Set set, boolean[] v, int[] dfn, int[] low, int cur, int pare) { dfn[cur] = p; low[cur] = dfn[cur]; set.add(cur); stack.push(cur); v[cur] = true; List ns = map.get(cur); if(ns != null) { for(int next : ns) { if(!v[next]) { ++p; dfs(map, stack, set, v, dfn, low, next, cur); low[cur] = Math.min(low[cur], low[next]); if(low[next] > dfn[cur]) { // 割边 ans.add(List.of(cur, next)); } } else { if(set.contains(next) && next != pare) { low[cur] = Math.min(low[cur], low[next]); } } } } if(dfn[cur] == low[cur]) { while(!stack.isEmpty() && stack.peek() != cur) { int pop = stack.pop(); set.remove(pop); } if(!stack.isEmpty()) { int pop = stack.pop(); set.remove(pop); } } } } ``` 。

并查集

Wed, 01 Jan 2025 02:21:14 +0000

#### 通用版 ```java class UnionFind { int[] s; public UnionFind(int size) { s = new int[size]; for (int i = 0; i < size; i++) { s[i] = i; } } public int find(int x) { int r = s[x]; if (r != x) { r = find(s[x]); } return r; } public void union(int i, int j) { int iBoss = find(i); int jBoss = find(j); if (iBoss != jBoss) { if(iBoss < jBoss) { s[jBoss] = iBoss; } else { s[iBoss] = jBoss; } } } } ``` #### hash表版（没有初始化节点(i -> i)，需要在外部主动初始化） ```java class UnionFind { Map map = new HashMap<>(); public UnionFind() {} public int find(int x) { int r = map.get(x); if(map.get(x) != x) { r = find(r); } return r; } public void union(int i, int j) { int iBoss = find(i); int jBoss = find(j); if (iBoss != jBoss) { if (iBoss < jBoss) { map.put(jBoss, iBoss); } else { map.put(iBoss, jBoss); } } } } ``` #### 完全版 - 有path compressed - 有 union by rank ```java class DisjointSet { int[] s; int[] rank; public DisjointSet(int size) { s = new int[size]; rank = new int[size]; for (int i = 0; i < size; i++) { s[i] = i; } } public int find(int x) { // path compression if (s[x] != x) { s[x] = find(s[x]); } return s[x]; } public void union(int i, int j) { int iBoss = find(i); int jBoss = find(j); if (iBoss != jBoss) { // union by rank if (rank[iBoss] < rank[jBoss]) { s[iBoss] = jBoss; } else if (rank[iBoss] > rank[jBoss]) { s[jBoss] = iBoss; } else { s[iBoss] = jBoss; rank[jBoss]++; } } } @Override public String toString() { return 'DisjointSet{' + 's=' + Arrays.toString(s) + '}'; } } ```。

二进制枚举

Tue, 31 Dec 2024 19:41:52 +0000

#### 二进制枚举 ##### 1.枚举所有集合 > 假设有三个元素的集合z：{0, 1, 2}，那么每种元素可以选或者不选，只有三个元素，有`2^3`个子集 > > {0，1，10，11，100，101，110，111}，刚好小于`1 << |z|`的数有`2^3`个，从小开始枚举，然后取二进制位即可表示某个元素的状态 ```java for(int i = 0;i < (1 << n);i++) { // 枚举二进制位，即能得到某个元素的取舍状态 } ``` ##### 2.从大到小枚举某个集合s的非空子集 > 假设对于集合`10101`，若想要枚举全部非空集合，暴力做法是：不断减1，得到的所有子集中包含了`s`的子集，其中会有集合不是s的子集 > > 那么，如何跳过这些非s的子集的集合。

floyd

Sun, 29 Dec 2024 22:30:57 +0000

#### [原理](https://blog.csdn.net/qq_35644234/article/details/60875818) #### 实现 - 数据 ```text 12 1 2 12 1 6 16 1 7 14 2 3 10 2 6 7 3 4 3 3 5 5 3 6 6 4 5 4 5 6 2 5 7 8 6 7 9 ``` ```java public static void floyd() { Scanner sc = new Scanner(System.in); System.out.print('请输入图的边数量: '); int edgesAmount = sc.nextInt(); List edges = new ArrayList<>(); sc.nextLine(); System.out.println('请输入所有边（格式为: 点x 点y 权重）: '); Set points = new HashSet<>(); for(int i = 0;i < edgesAmount;i++) { String line = sc.nextLine(); String[] edge = line.split(' '); edges.add(new int[]{Integer.parseInt(edge[0]), Integer.parseInt(edge[1]), Integer.parseInt(edge[2])}); points.add(Integer.parseInt(edge[0])); points.add(Integer.parseInt(edge[1])); } int pointSize = points.size() + 1; int[][] d = new int[pointSize][pointSize]; int[][] p = new int[pointSize][pointSize]; // 初始化d数组 for(int i = 0;i < pointSize;i++) { Arrays.fill(d[i], Integer.MAX_VALUE); } for(int[] e : edges) { d[e[0]][e[1]] = e[2]; d[e[1]][e[0]] = e[2]; } // 初始化path数组，假设全都可达 for(int i = 0;i < pointSize;i++) { for(int j = 0;j < pointSize;j++) { p[i][j] = j; } } // O(n^3) for(int k = 0;k < pointSize;k++) { for(int i = 0;i < pointSize;i++) { for(int j = 0;j < pointSize;j++) { if(d[i][k] == Integer.MAX_VALUE || d[k][j] == Integer.MAX_VALUE) continue; int dis = d[i][k] + d[k][j]; if(dis < d[i][j]) { d[i][j] = dis; p[i][j] = k; } } } } // 输出 for(int i = 0;i < pointSize;i++) { for(int j = 0;j < pointSize;j++) { if(i == j || d[i][j] == Integer.MAX_VALUE) continue; System.out.println(i + '->' + j + '的最短路径值: ' + d[i][j]); List paths = new ArrayList<>(); path(p, i, j, -1, paths); System.out.println('路径为: ' + buildPath(paths)); } } } private static void path(int[][] p, int s, int t, int lr, List paths) { int m = p[s][t]; if(lr != 1) paths.add(s); // 处理左边 if(!(m == s || m == t)) path(p, s, m, 1, paths); // 中点 if(!(m == s || m == t)) paths.add(m); // 处理右边 if(!(m == s || m == t)) path(p, m, t, 1, paths); if(lr != 1) paths.add(t); } private static String buildPath(List paths) { StringBuilder sb = new StringBuilder(); for(int i = 0;i < paths.size();i++) { sb.append(paths.get(i)); if(i != paths.size() - 1) sb.append('->'); } return sb.toString(); } ``` 。

前缀函数（kmp）

Wed, 18 Dec 2024 09:21:52 +0000

#### 前缀函数（kmp） ##### [原理](https://oi-wiki.org/string/kmp/#__tabbed_3_3) ##### 1.求前缀函数，普通写法 - 时间复杂度：O(n^3) ```java /** * * 时间复杂度: O(n^3) * @param s 字符串 * @return pai */ public int[] pf(String s) { char[] c = s.toCharArray(); int n = c.length; int[] pi = new int[n]; for(int i = 1;i < n;i++) { for(int j = 1;j <= i;j++) { int l = 0; int r = j; while(r < n && c[l] == c[r]) { l++; r++; } if(r > i) { pi[i] = i - j + 1; break; } } } return pi; } ``` ##### 2.求前缀函数，第一个优化 - 时间复杂度：O(n^2) - 原理： > 观察相邻的`pai[i]`、`pai[i + 1]`，发现`pai[i + 1] <= pai[i] + 1`，那么对于每个`pai[i]`都能跳过`i - pai[i + 1]`个前缀，大大提高效率 ```java /** * * 时间复杂度: O(n^2) * @param s 字符串 * @return pi */ public int[] pf(String s) { char[] c = s.toCharArray(); int n = c.length; int[] pi = new int[n]; for(int i = 1;i < n;i++) { if(c[i] == c[pi[i - 1]]) { pi[i] = pi[i - 1] + 1; continue; } for(int j = i - pi[i - 1] + 1;j <= i;j++) { int l = 0; int r = j; while(r < n && c[l] == c[r]) { l++; r++; } if(r > i) { pi[i] = i - j + 1; break; } } } return pi; } ``` ##### 3.求前缀函数，第二个优化 - 时间复杂度：O(n) - 原理： > 求`pi[i]`，`len = pi[i - 1]`，`len`为`c[i - 1]`的相等真前后缀长度，若`s[len] != s[i]`，则减少，直到`0`。

Z函数（扩展kmp）

Tue, 17 Dec 2024 10:32:15 +0000

[原理](https://oi-wiki.org/string/z-func/#__tabbed_2_1) ```java public int[] zFunction(String s) { int n = s.length(); char[] c = s.toCharArray(); int[] z = new int[n]; int l = 0; int r = 0; for(int i = 1;i < n;i++) { if(i > r) { // 暴力匹配 while(i + z[i] < n && c[i + z[i]] == c[z[i]]) z[i]++; } else { if(z[i - l] < r - i + 1) z[i] = z[i - l]; else { // 跳过前r - i + 1个后继续匹配 while(r + z[i] + 1 < n && c[r + z[i] + 1] == c[r - i + 1 + z[i]]) z[i]++; z[i] += r - i + 1; } } if(i + z[i] > r && z[i] != 0) { // 更新l、r l = i; r = i + z[i] - 1; } } return z; } ```。

dijkstra

Fri, 13 Dec 2024 22:58:14 +0000

1. 普通dijkstra ```java import java.util.*; public class Dijkstra { static class Node implements Comparable { int vertex; int distance; public Node(int vertex, int distance) { this.vertex = vertex; this.distance = distance; } @Override public int compareTo(Node other) { return Integer.compare(this.distance, other.distance); } } public static int[] dijkstra(int[][] graph, int start) { int n = graph.length; int[] distances = new int[n]; boolean[] visited = new boolean[n]; // 初始化距离数组 Arrays.fill(distances, Integer.MAX_VALUE); distances[start] = 0; // 使用优先队列优化 PriorityQueue pq = new PriorityQueue<>(); pq.offer(new Node(start, 0)); while (!pq.isEmpty()) { Node current = pq.poll(); int u = current.vertex; // 如果已经访问过，跳过 if (visited[u]) continue; visited[u] = true; // 更新相邻节点的距离 for (int v = 0; v < n; v++) { if (graph[u][v] != 0) { // 存在边 int newDist = distances[u] + graph[u][v]; if (newDist < distances[v]) { distances[v] = newDist; pq.offer(new Node(v, distances[v])); } } } } return distances; } // 测试代码 public static void main(String[] args) { int[][] graph = { {0, 4, 2, 0, 0}, {4, 0, 1, 5, 0}, {2, 1, 0, 8, 10}, {0, 5, 8, 0, 2}, {0, 0, 10, 2, 0} }; int start = 0; // 起点为A（0号顶点） int[] distances = dijkstra(graph, start); // 打印结果 System.out.println('从顶点 ' + start + ' 到各个顶点的最短距离：'); for (int i = 0; i < distances.length; i++) { System.out.println('到顶点 ' + i + ' 的距离: ' + distances[i]); } } } ``` 2. 带路径记录的dijkstra ```java import java.util.*; public class DijkstraWithPath { static class Node implements Comparable { int vertex; int distance; public Node(int vertex, int distance) { this.vertex = vertex; this.distance = distance; } @Override public int compareTo(Node other) { return Integer.compare(this.distance, other.distance); } } static class Result { int[] distances; int[] previousVertices; public Result(int[] distances, int[] previousVertices) { this.distances = distances; this.previousVertices = previousVertices; } // 获取从起点到目标点的路径 public List getPath(int target) { List path = new ArrayList<>(); int current = target; // 如果没有路径到达目标点 if (distances[target] == Integer.MAX_VALUE) { return path; } while (current != -1) { path.add(0, current); current = previousVertices[current]; } return path; } } public static Result dijkstra(int[][] graph, int start) { int n = graph.length; int[] distances = new int[n]; int[] previousVertices = new int[n]; boolean[] visited = new boolean[n]; // 初始化 Arrays.fill(distances, Integer.MAX_VALUE); Arrays.fill(previousVertices, -1); distances[start] = 0; PriorityQueue pq = new PriorityQueue<>(); pq.offer(new Node(start, 0)); while (!pq.isEmpty()) { Node current = pq.poll(); int u = current.vertex; if (visited[u]) continue; visited[u] = true; for (int v = 0; v < n; v++) { if (graph[u][v] != 0) { int newDist = distances[u] + graph[u][v]; if (newDist < distances[v]) { distances[v] = newDist; previousVertices[v] = u; pq.offer(new Node(v, distances[v])); } } } } return new Result(distances, previousVertices); } public static void main(String[] args) { // 示例图（邻接矩阵表示） int[][] graph = { {0, 4, 2, 0, 0}, {4, 0, 1, 5, 0}, {2, 1, 0, 8, 10}, {0, 5, 8, 0, 2}, {0, 0, 10, 2, 0} }; int start = 0; Result result = dijkstra(graph, start); // 打印所有最短距离 System.out.println('从顶点 ' + start + ' 到各个顶点的最短距离：'); for (int i = 0; i < result.distances.length; i++) { System.out.println('到顶点 ' + i + ' 的距离: ' + result.distances[i]); // 打印路径 List path = result.getPath(i); System.out.println('路径: ' + path); } } } ``` 3. 解释 1. Node类 - 实现了Comparator接口，用于优先队列的排序 - 存储顶点编号和到起点的距离 2. 数据结构 - `distances[]`：存储从起点到各个顶点的最短距离 - `visited[]`：记录顶点是否被访问过 - `previousVertices[]`：记录最短路径中每个顶点的前驱顶点 - `PriorityQueue`：优先队列，用于获取当前最短距离的顶点 3. 核心步骤 - 初始化距离数组，起点距离为0，其他为无穷大 - 使用优先队列选择当前最短距离的顶点 - 更新选中顶点的邻接点的距离 - 记录路径信息 4. 性能优化建议 1. 对于稀疏图，使用邻接表代替邻接矩阵 2. 使用索引优先队列可以进一步优化性能 3. 如果只需要找到到特定目标的最短路径，可以在找到后提前终止 5. 使用示例 ```java // 创建图（邻接矩阵） int[][] graph = new int[5][5]; // 添加边 graph[0][1] = 4; // A到B的距离为4 graph[1][0] = 4; // B到A的距离为4 // ... 添加其他边 // 计算最短路径 Result result = dijkstra(graph, 0); // 从顶点0开始 // 获取到某个顶点的最短路径 List pathTo3 = result.getPath(3); System.out.println('到顶点3的路径: ' + pathTo3); System.out.println('距离: ' + result.distances[3]); ``` 。

java日志框架

Wed, 06 Nov 2024 09:50:38 +0000

#### java现有的日志框架有哪些 - JUL(java util logging) - logback - log4j - log4j2 - JCL(jakarta commons logging) - slf4j(simple logging facade for java) #### 日志门面技术的优点 1. 面向接口开发，不再依赖具体的实现类 2. 通过导入不同的日志实现类，可以灵活的切换日志框架 3. 统一api，方便开发者学习和使用 4. 统一配置便于项目日志的管理 #### JUL(java util logging) JUL，java原生日志框架，不需要引入第三方依赖包，使用简单方便，一般在小型应用中使用，主流项目中很少使用 ##### JUL架构 - Application：java应用程序 - loggers：记录器，application通过获取logger对象，调用其api来发布日志消息 - appenders：也称为handlers，每个logger都会关联一组handlers，logger会将日志交给handlers处理handlers是一个抽象，其具体的实现决定了日志记录的位置可以是控制台、文件、网络上的其他日志服务或操作系统日志等 - layouts：也称为formatters，负责对日志进行转换或者格式化 - level：每条日志都有一个关联的日志级别 - filters：过滤器，根据需要自定义哪些消息会被记录，哪些消息会被放过 ##### 日志级别(由高到低) 1. severe 2. warning 3. info(默认的日志级别) 4. config 5. fine 6. finer 7. finest ##### 为什么要对日志进行分级无论是将日志输出到`console`还是文件，都会带来消耗，降低程序的运行效率，但是，日志又是调试或者了解程序运行的不可或缺的手段，通过对日志进行分级处理，在一个配置文件中进行统一的管理，这样代码中日志部分就可以不用删除，又可以控制输出哪些日志 ```java public static void main(String[] args) { Logger logger = Logger.getLogger('multi'); logger.setUseParentHandlers(false); ConsoleHandler consoleHandler = new ConsoleHandler(); consoleHandler.setLevel(Level.ALL); SimpleFormatter simpleFormatter = new SimpleFormatter(); consoleHandler.setFormatter(simpleFormatter); logger.addHandler(consoleHandler); logger.setLevel(Level.ALL); logger.severe('>>>> severe'); logger.warning('>>>> warning'); logger.info('>>>> info'); logger.config('>>>> config'); logger.fine('>>>> fine'); logger.finer('>>>> finer'); logger.finest('>>>> finest'); logger.log(Level.WARNING, '>>>> waring!!!!'); String name = 'wwb'; int age = 23; logger.log(Level.INFO, '>>>> name: {0}, age: {1}', new Object[]{name, age}); //logger.log(Level.SEVERE, 'NPE: ', new NullPointerException()); } ``` ##### logger的继承关系创建`logger`时，若未指定父`logger`，则默认继承`RootLogger`。

minio基础

Sat, 02 Nov 2024 04:43:21 +0000

**官网**：[官网](https://min.io) **文档**：[文档](https://minio-java.min.io) **快速开始**：[quickStart](https://www.minio.org.cn/docs/minio/linux/developers/java/minio-java.html#minio-java-quickstart) **安装** ```shell wget https://dl.min.io/server/minio/release/linux-amd64/minio chmod +x minio MINIO_ROOT_USER=wwb MINIO_ROOT_PASSWORD=pubgM666 ./minio server /mnt/min_data --console-address ':9001' ``` **access_key and secret_key** ```text access_key: Um89W6wboxiiVeLUiYBn secret_key: 4MmSQrEy5t8xpIbACZLmnYhidaOcIEt246GiSPRM ``` **上传文件demo** ```java package com.minio; import io.minio.*; public class Exec { public static void main(String[] args) throws Exception{ MinioClient client = new MinioClient.Builder().endpoint('http://172.24.192.134:9000') .credentials('Um89W6wboxiiVeLUiYBn', '4MmSQrEy5t8xpIbACZLmnYhidaOcIEt246GiSPRM') .build(); boolean exists = client.bucketExists(BucketExistsArgs.builder().bucket('test').build()); if(!exists) { client.makeBucket(MakeBucketArgs.builder().bucket('test').build()); } client.uploadObject(UploadObjectArgs.builder() .object('RocketMQ api实战.md') .filename('C:\\Users\\wwb\\Desktop\\typora_record\\RocketMQ api实战.md') .bucket('test') .build()); client.close(); } } ``` **minio对象属性：** - object name：对象的唯一名称 - bucket name：对象所在的存储桶名称 - content type：对象的mime类型，例如：image/jpeg、application//pdf - content length：对象的大小，以byte为单位 - last modified：对象的最后修改时间 - user-defined metadata：对象的自定义元数据，例如作者、创建日期等 - etag：对象的唯一标识符，通常是一个哈希值 **spring-boot对文件上传大小默认大小为1MB，需要覆盖配置** ```yaml spring: servlet: multipart: max-file-size: 1TB max-request-size: 1TB ``` **获取对象链接** ```java String url = client.getPresignedObjectUrl(GetPresignedObjectUrlArgs .builder() .bucket('test') .object('RocketMQ api实战.md') .method(Method.GET) .expiry(5, TimeUnit.DAYS) .build()); ``` **列出文件列表** ```java /** * 测试列出文件列表 * @throws Exception 异常 */ static void testListObjs() throws Exception{ Iterable> objs = client.listObjects(ListObjectsArgs.builder() .bucket('test') .prefix('video/a') .recursive(true) .build()); for (Result obj : objs) { System.out.println(obj.get().objectName()); } client.close(); } ``` **列出所有bucket** ```java /** * 测试列出所有bucket * @throws Exception 异常 */ static void testListBuckets() throws Exception { List buckets = client.listBuckets(); buckets.forEach(b -> System.out.println(b.name())); client.close(); } ``` **下载文件** ```java /** * 测试下载文件 * @throws Exception 异常 */ static void testGetObj() throws Exception { GetObjectResponse resp = client.getObject(GetObjectArgs.builder() .bucket('test') .object('9666489052.mp4') .build()); byte[] data = resp.readAllBytes(); FileOutputStream outputStream = new FileOutputStream(resp.object()); outputStream.write(data); outputStream.flush(); outputStream.close(); client.close(); } ``` **复制文件** ```java /** * 测试复制文件 * @throws Exception 异常 */ static void testCopyObj() throws Exception { CopySource src = new CopySource.Builder().bucket('test').object('9666489052.mp4').build(); client.copyObject(CopyObjectArgs.builder() .source(src) .bucket('learn') .object('美女舞蹈.mp4') .build()); client.close(); } ``` **删除文件** ```java /** * 测试删除文件 * @throws Exception 异常 */ static void testDeleteObj() throws Exception { client.removeObject(RemoveObjectArgs.builder() .bucket('learn') .object('美女舞蹈.mp4') .build()); client.close(); } ``` 。

树状数组

Tue, 08 Oct 2024 13:16:44 +0000

#### 树状数组 **模板** ```java static class FenwickTree { int[] arr; int[] b; int n; public FenwickTree(int[] nums) { this.arr = nums; n = nums.length; init(nums); } private void init(int[] nums) { b = new int[n + 1]; for(int i = 1;i <= nums.length;i++) { int k = i; while(k <= n) { b[k] += nums[i - 1]; k += (k & -k); } } } public void update(int i, int val) { int tmp = arr[i]; arr[i] = val; int k = i + 1; while(k <= n) { b[k] -= tmp; b[k] += val; k += (k & -k); } } public int sum(int l, int r) { return sum(r + 1) - sum(l); } private int sum(int r) { int sum = 0; while(r > 0) { sum += b[r]; r -= (r & -r); } return sum; } } ```。

java打包

Wed, 18 Sep 2024 23:16:13 +0000

```java org.springframework.boot spring-boot-maven-plugin 3.1.2 repackage ```。

欧几里得算法求最大公约数（GCD）

Wed, 18 Sep 2024 12:05:19 +0000

判断两个数是否为非互质数的计算原理基于最大公约数 (GCD)。

最大频率栈

Tue, 17 Sep 2024 18:40:34 +0000

#### 最大频率栈实现方法 - 为每一个频率维护一个栈（map） - 为元素维护计数器（map） - push元素时注意max以及频率栈的更新 - pop元素时注意max、频率栈的删除以及计数器的更新代码如下 ```java class FreqStack { Map map = new HashMap<>(); Map> freqMap = new HashMap<>(); int max = 0; public FreqStack() {} public void push(int val) { int freq = map.getOrDefault(val, 0) + 1; max = Math.max(max, freq); map.put(val, freq); freqMap.computeIfAbsent(freq, k -> new ArrayDeque<>()).push(val); } public int pop() { ArrayDeque stack = freqMap.get(max); int re = stack.pop(); map.put(re, map.get(re) - 1); if(stack.isEmpty()) { freqMap.remove(max--); } return re; } } ```。

扫描线

Mon, 16 Sep 2024 14:19:04 +0000

未接触。

线段树

Mon, 16 Sep 2024 14:18:39 +0000

#### 手搓两套线段树板子 - **可以区间修改/求和的线段树模板** ```java class SegmentTree { int[] arr; int[] d; int[] b; boolean[] v; public SegmentTree(int[] arr) { this.arr = arr; d = new int[arr.length * 4]; b = new int[arr.length * 4]; v = new boolean[arr.length * 4]; buildTree(0, arr.length - 1, 0, d, arr); } private void buildTree(int s, int t, int p, int[] d, int[] arr) { if(s == t) { d[p] = arr[s]; return; } int m = (s + t) >> 1; buildTree(s, m, 2 * p + 1, d, arr); buildTree(m + 1, t, 2 * p + 2, d, arr); d[p] = d[2 * p + 1] + d[2 * p + 2]; } public void rangeUpdate(int l, int r, int c) { rangeUpdate(l, r, c, 0, arr.length - 1, 0, d, b, v); } private void rangeUpdate(int l, int r, int c, int s, int t, int p, int[] d, int[] b, boolean[] v) { if(s >= l && t <= r) { d[p] = c * ((t - s) + 1); b[p] = c; v[p] = true; return; } int m = (s + t) >> 1; if(v[p]) { tagDown(d, b, v, m, s, t, p); } if(m >= l) rangeUpdate(l, r, c, s, m, 2 * p + 1, d, b, v); if(m + 1 <= r) rangeUpdate(l, r, c, m + 1, t, 2 * p + 2, d, b, v); d[p] = d[2 * p + 1] + d[2 * p + 2]; } public int rangeSum(int l, int r) { return rangeSum(l, r, 0, arr.length - 1, 0, d, b, v); } private int rangeSum(int l, int r, int s, int t, int p, int[] d, int[] b, boolean[] v) { if(s >= l && t <= r) { return d[p]; } int sum = 0; int m = (s + t) >> 1; if(v[p]) { tagDown(d, b, v, m, s, t, p); } if(m >= l) sum += rangeSum(l, r, s, m, 2 * p + 1, d, b, v); if(m + 1 <= r) sum += rangeSum(l, r, m + 1, t, 2 * p + 2, d, b, v); return sum; } private void tagDown(int[] d, int[] b, boolean[] v, int m, int s, int t, int p) { d[2 * p + 1] = b[p] * ((m - s) + 1); d[2 * p + 2] = b[p] * ((t - (m + 1)) + 1); b[2 * p + 1] = b[p]; b[2 * p + 2] = b[p]; v[2 * p + 1] = true; v[2 * p + 2] = true; b[p] = 0; v[p] = false; } } ``` - **可以区间加/求和的线段树模板** ```java class SegmentTree { int[] arr; int[] d; int[] b; public SegmentTree(int[] arr) { this.arr = arr; d = new int[arr.length * 4]; b = new int[arr.length * 4]; // build tree buildSegmentTree(0, arr.length - 1, 0, arr, d); } /** * 线段树初始化 * * @param s 区间左边界 * @param t 区间有边界 * @param p 区间编号 * @param arr 原始数组 * @param d 线段树树状数组 */ private void buildSegmentTree(int s, int t, int p, int[] arr, int[] d) { if(s == t) { d[p] = arr[s]; return; } int m = (s + t) >> 1; buildSegmentTree(s, m, 2 * p + 1, arr, d); buildSegmentTree(m + 1, t, 2 * p + 2, arr , d); d[p] = d[2 * p + 1] + d[2 * p + 2]; } /** * 外部调用方法 * * @param l 更新左边界 * @param r 更新右边界 * @param c 增量 */ public void rangeUpdate(int l, int r, int c) { rangeUpdate(l, r, c, 0, arr.length - 1, 0, d, b); } /** * * @param l 更新左边界 * @param r 更新右边界 * @param c 增量 * @param s 区间左边界 * @param t 区间右边界 * @param p 区间编号 * @param d 线段树树状数组 * @param b 标记数组 */ private void rangeUpdate(int l, int r, int c, int s, int t, int p, int[] d, int[] b) { if(s >= l && t <= r) { d[p] += c * ((t - s) + 1); b[p] += c; return; } int m = (s + t) >> 1; if(s != t && b[p] != 0) { tagDown(d, b, m, s, t, p); } if(m >= l) rangeUpdate(l, r, c, s, m, 2 * p + 1, d, b); if(m + 1 <= r) rangeUpdate(l, r, c, m + 1, t, 2 * p + 2, d, b); d[p] = d[2 * p + 1] + d[2 * p + 2]; } /** * 外部调用方法 * @param l 查询左边界 * @param r 查询右边界 * @return 区间和 */ public int rangeSum(int l, int r) { return rangeSum(l, r, 0, arr.length - 1, 0, d, b); } /** * * @param l 查询左边界 * @param r 查询右边界 * @param s 区间左边界 * @param t 区间右边界 * @param p 区间编号 * @param d 线段树树状数组 * @param b 标记数组 * @return 区间和 */ private int rangeSum(int l, int r, int s, int t, int p, int[] d, int[] b) { if(s >= l && t <= r) { return d[p]; } int sum = 0; int m = (s + t) >> 1; if(s != t && b[p] != 0) { tagDown(d, b, m, s, t, p); } if(m >= l) sum += rangeSum(l, r, s, m, 2 * p + 1, d, b); if(m + 1 <= r) sum += rangeSum(l, r, m + 1, t, 2 * p + 2, d, b); return sum; } private void tagDown(int[] d, int[] b, int m, int s, int t, int p) { d[2 * p + 1] += b[p] * ((m - s) + 1); d[2 * p + 2] += d[p] * ((t - (m + 1)) + 1); b[2 * p + 1] += b[p]; b[2 * p + 2] += b[p]; b[p] = 0; } } ```。

差分数组（一维、二维）

Sat, 14 Sep 2024 14:31:36 +0000

#### 一维差分差分map写法： - 主要用到treemap的merge方法 ```java public boolean carPooling(int[][] trips, int capacity) { TreeMap d = new TreeMap<>(); for (int[] t : trips) { int num = t[0], from = t[1], to = t[2]; d.merge(from, num, Integer::sum); d.merge(to, -num, Integer::sum); } int s = 0; for (int v : d.values()) { s += v; if (s > capacity) { return false; } } return true; } ``` #### 二维差分 ##### 原理图 - 初始化 ![二维差分原理图](https://pic.leetcode.cn/1702439895-HZofag-LC2132-c.png) - 恢复 - 对行依次做前缀和 - 对列依次做前缀和 #### 离散化 + 二维差分 [leetcode：LCP74.最强祝福力场](https://leetcode.cn/problems/xepqZ5/) 此题困惑点： - 存在非整数，解决：将所有坐标 * 2 - 坐标范围很大，解决：离散化 - 离散化步骤： - 排序 - 去重 - 重新编号。

二维前缀和

Fri, 13 Sep 2024 13:52:47 +0000

求矩阵的子矩阵和 - 方法一：对矩阵的每一行做前缀和，求子矩阵元素和时还需要遍历每一行，并不能做到O(1)的查询时间 - 方法二：预处理二维矩阵前缀和，将每次查询优化到O(1) ![原理图](https://pic.leetcode.cn/1765887873-gHCBKd-lc304-c.png)。

位运算

Fri, 13 Sep 2024 11:37:36 +0000

#### n & n - 1 `n & n - 1` n减去最低位的2的幂 #### n & -n `n & -n` 获取组成n的二进制中的最低位的2的幂。

快速幂

Tue, 10 Sep 2024 16:15:51 +0000

#### 快速幂实现 - 时间复杂度：O(logn) - 空间复杂度：O(logn) 栈的开销 ```java private int fastPow(int val, int p) { if(p == 0) return 1; if(p == 1) return val; int half = fastPow(val, p >> 1); int result; if((p & 1) == 0) result = half * half; else result = half * half * val; return result; } ```。

设计模式

Sat, 13 Jul 2024 16:13:53 +0000

#### 创建型模式 ##### 单例 **常见的单例：** - `RunTime` - Spring中的`ApplicationContext` ```java public class SingleTon { private static volatile SingleTon single; private SingleTon() { } public static SingleTon getInstance() { if(single == null) { synchronized(SingleTon.class) { if(single == null) single = new SingleTon(); } } return single; } } ``` ##### 简单工厂 **主要角色：** - 抽象产品 - 具体产品 - 简单工厂 > 所有产品都交由简单工厂创建，若需新增产品，则需要改动简单工厂的代码 ```java // 抽象产品 public interface Phone { } // 具体产品 public class XiaoMi implements Phone{ } // 具体产品 public class HuaWei implements Phone{ } // 简单工厂 public class PhoneFactory { public static Phone createPhone(String type) { if(type == null) return null; if(type.equals('XiaoMi')) return new XiaoMi(); else if(type.equals('HuaWei')) return new HuaWei(); return null; } } ``` ##### 工厂方法 **主要角色：** - 抽象产品 - 具体产品 - 抽象工厂 - 具体工厂 > 对于简单工厂，新增产品需要改动代码。

dubbo

Fri, 12 Jul 2024 04:02:50 +0000

Mysql

Fri, 12 Jul 2024 04:02:07 +0000

**行记录格式** - antelope - redundant - compact - barracuda - dynamic - compressed **compact** 可变长字段长度(1或2个byte) NULL值(bitmap) 头部(5个byte) **三个隐藏字段** - ROWID(6 byte)，在没有指定primary key时才存在 - 事务ID(6 byte) - 回滚指针(7 byte) **buffer pool** 由控制块与缓存页组成 Hash ```text 由表空间及页号组成key，控制块引用为value，O(1)的时间判断要查询的数据是否位于buffer pool ``` 各链表及其作用 - free链 ```text 双向链表，节点存储缓存页等信息 ``` - Flush链 ```text 双向链表，节点存储缓存页等信息，当数据被更新时，被标记为dirty page，相应的控制块加入flush链，由后台线程异步刷盘 ``` - LRU链 ```text 双向链表，节点存储缓存页等信息，分为young数据区、old 数据区，当buffer pool满时，淘汰数据 ```。

RocketMQ

Fri, 12 Jul 2024 04:01:49 +0000

# RocketMQ api实战 ### Consumer - 推模式：broker推送消息给consumer - 拉模式：consumer主动从broker拉取消息 > 推模式消费者 ```java package com.mq.consumer; import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer; import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus; import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently; public class SyncConsumer { public static void main(String[] args) throws Exception{ // 推模式(boroker(主动推送) -> consumer) DefaultMQPushConsumer consumer = new DefaultMQPushConsumer('SyncConsumer'); // set name server addr consumer.setNamesrvAddr('172.24.192.134:9876'); // subscribe consumer.subscribe('wwb', '*'); // consume message consumer.setMessageListener((MessageListenerConcurrently) (list, consumeConcurrentlyContext) -> { for(int i = 0;i < list.size();i++) { System.out.println('消费一条消息'); } return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; }); consumer.start(); System.out.println('消费者启动成功...'); } } ``` > 拉模式消费者（@deprecated） ```java package com.mq.consumer; import org.apache.rocketmq.client.consumer.DefaultMQPullConsumer; import org.apache.rocketmq.client.consumer.PullResult; import org.apache.rocketmq.client.consumer.PullStatus; import org.apache.rocketmq.client.consumer.store.ReadOffsetType; import org.apache.rocketmq.client.exception.MQBrokerException; import org.apache.rocketmq.client.exception.MQClientException; import org.apache.rocketmq.common.message.MessageQueue; import org.apache.rocketmq.remoting.exception.RemotingException; import java.util.HashSet; import java.util.List; import java.util.Set; public class PullConsumer { @Deprecated public static void main(String[] args) throws Exception{ DefaultMQPullConsumer consumer = new DefaultMQPullConsumer('PullConsumer'); // set name server addr consumer.setNamesrvAddr('172.24.192.134:9876'); // set register topic consumer.setRegisterTopics(new HashSet<>(List.of('wwb', 'async_wwb', 'TopicTest'))); consumer.start(); while(true) { consumer.getRegisterTopics().forEach(t -> { try { Set queues = consumer.fetchSubscribeMessageQueues(t); queues.forEach(q -> { try { long offset = consumer.getOffsetStore().readOffset(q, ReadOffsetType.READ_FROM_MEMORY); if(offset < 0) offset = consumer.getOffsetStore().readOffset(q, ReadOffsetType.READ_FROM_STORE); if(offset < 0) offset = consumer.maxOffset(q); if(offset < 0) offset = 0; PullResult result = consumer.pull(q, '*', offset, 32); if(result.getPullStatus() == PullStatus.FOUND) { System.out.println('消息消费成功'); consumer.updateConsumeOffset(q, result.getNextBeginOffset()); } } catch (MQClientException | MQBrokerException | RemotingException | InterruptedException e) { throw new RuntimeException(e); } }); } catch (MQClientException e) { throw new RuntimeException(e); } }); } } } ``` > 拉模式消费者 ```java package com.mq.consumer; import org.apache.rocketmq.client.consumer.DefaultLitePullConsumer; import org.apache.rocketmq.common.message.MessageExt; import org.apache.rocketmq.common.message.MessageQueue; import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.Collection; import java.util.List; public class LitePullConsumer { public static void main(String[] args) throws Exception{ pullAssignQueue(); } /** * 随机拉取某个队列的消息 * @throws Exception */ static void pullRandomQueue() throws Exception{ DefaultLitePullConsumer consumer = new DefaultLitePullConsumer('LitePullConsumer'); consumer.setNamesrvAddr('172.24.192.134:9876'); consumer.subscribe('wwb', '*'); consumer.start(); while(true) { List list = consumer.poll(); list.forEach(m -> { byte[] body = m.getBody(); System.out.println('消息消费成功: ' + new String(body, StandardCharsets.UTF_8)); }); } } /** * 指定拉取某个队列的消息 * @throws Exception */ static void pullAssignQueue() throws Exception{ DefaultLitePullConsumer consumer = new DefaultLitePullConsumer('LitePullConsumer2'); consumer.setNamesrvAddr('172.24.192.134:9876'); consumer.start(); Collection queues = consumer.fetchMessageQueues('wwb'); ArrayList li = new ArrayList<>(queues); consumer.assign(li); consumer.seek(li.get(1), 0); while(true) { List list = consumer.poll(); list.forEach(m -> { System.out.println(m); System.out.println('消息消费成功: ' + new String(m.getBody(), StandardCharsets.UTF_8)); }); } } } ``` ### Producer **消息发送的三种方式** - 同步发送：等待消息返回后再继续进行下面的操作，适用于并发较低以及可靠性较高的场景 - 异步发送：不等待消息返回直接进行后续代码流程，适用于并发高的场景 - 单向发送：只负责发送，不管消息是否发送成功，适用于日志等特殊场景 > 同步生产者： ```java package com.mq.producer; import org.apache.rocketmq.client.producer.DefaultMQProducer; import org.apache.rocketmq.client.producer.SendResult; import org.apache.rocketmq.common.message.Message; import java.nio.charset.StandardCharsets; import java.util.Random; public class SyncProducer { public static void main(String[] args) throws Exception{ DefaultMQProducer producer = new DefaultMQProducer('SyncProducer'); // set name server addr producer.setNamesrvAddr('172.24.192.134:9876'); producer.start(); for(int i = 0;i < 10;i++) { Message mess = new Message( 'wwb', String.valueOf(i), String.valueOf(new Random().nextInt(10)).getBytes(StandardCharsets.UTF_8)); SendResult result = producer.send(mess); System.out.println(result); } producer.shutdown(); } } ``` > 异步生产者 ```java package com.mq.producer; import org.apache.rocketmq.client.producer.DefaultMQProducer; import org.apache.rocketmq.client.producer.SendCallback; import org.apache.rocketmq.client.producer.SendResult; import org.apache.rocketmq.common.message.Message; import java.nio.charset.StandardCharsets; import java.util.Arrays; import java.util.Random; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; public class AsyncProducer { public static void main(String[] args) throws Exception{ DefaultMQProducer producer = new DefaultMQProducer('AsyncProducer'); // set name server addr producer.setNamesrvAddr('172.24.192.134:9876'); producer.start(); CountDownLatch cd = new CountDownLatch(10); for(int i = 0;i < 10;i++) { Message mess = new Message( 'async_wwb', String.valueOf(i), String.valueOf(new Random().nextInt(10)).getBytes(StandardCharsets.UTF_8)); producer.send(mess, new SendCallback() { @Override public void onSuccess(SendResult sendResult) { System.out.println('消息发送成功: ' + sendResult); cd.countDown(); } @Override public void onException(Throwable throwable) { System.out.println('消息发送失败' + Arrays.toString(throwable.getStackTrace())); cd.countDown(); } }); } boolean await = cd.await(5, TimeUnit.SECONDS); if(!await) { System.out.println('部分消息丢失'); } producer.shutdown(); } } ``` > 单向生产者 ```java package com.mq.producer; import org.apache.rocketmq.client.producer.DefaultMQProducer; import org.apache.rocketmq.common.message.Message; import java.nio.charset.StandardCharsets; import java.util.Random; public class OneWayProducer { public static void main(String[] args) throws Exception{ DefaultMQProducer producer = new DefaultMQProducer('OneWayProducer'); // set name server addr producer.setNamesrvAddr('172.24.192.134:9876'); producer.start(); for(int i = 0;i < 10;i++) { Message mess = new Message( 'wwb', String.valueOf(i), String.valueOf(new Random().nextInt(10)).getBytes(StandardCharsets.UTF_8)); producer.sendOneway(mess); } producer.shutdown(); } } ``` ### 消息类型 - **Normal（普通消息）** - **FIFO（顺序消息）** - **Delay（延迟消息）** 延迟消息具有18个级别：1s到2个小时几个有关的方法： 1. setDelayTimeLevel() ：根据延迟级别延迟投递 2. setDelayTimeMs() ：自定义延迟毫秒数 3. setDelayTimeSec() ：自定义延迟秒数 4. setDeliverTimeMs() ：在某个时间戳投递 |延迟级别|延迟时间| |--- |--- | |1|1s| |2|5s| |3|10s| |4|30s| |5|1m| |6|2m| |7|3m| |8|4m| |9|5m| |10|6m| |11|7m| |12|8m| |13|9m| |14|10m| |15|20m| |16|30m| |17|1h| |18|2h| - **Transaction（事务消息）** RocketMQ 的事务消息用于保证消息和本地事务操作的最终一致性。

maven

Fri, 12 Jul 2024 02:12:03 +0000

maven的本质是一个项目管理工具，将项目开发和管理抽象成一个项目对象模型（POM） POM（Project Object Model）：项目对象模型 **仓库类型** - 本地仓库 - 私服 - 中央仓库 **坐标** - groupId - artifactId - version **command** - mvn clean - mvn compile - mvn test - mvn package - mvn install **依赖传递性** - 直接依赖：直接通过依赖配置建立的依赖关系 - 间接依赖：被依赖的资源的依赖 **依赖传递冲突问题** - 路劲优先：当依赖中出现冲突，层级越深，优先级越低 - 声明优先：当冲突层级相同，root先声明优先级高 **依赖范围** - compile 默认 - provided 源码测试 - test 测试 - runtime 打包 **模块聚合** ```xml pom ``` **自定义属性** ```xml ``` **pom属性解析到配置文件** ```xml 配置文件目录 true ``` **跳过测试** ```text mvn package -D skipTests ```。

spring-boot-data-elasticsearch

Mon, 08 Jul 2024 19:55:42 +0000

##### spring-boot-data-elasticsearch **依赖** ```xml org.springframework.boot spring-boot-starter-data-elasticsearch 2.7.6 ``` **annotation** ```java @Repository @EnableElasticSearchRepositories(basePackage = '') @Document(indexName = ''， createIndex = true) 标注实体类 @Id 标注主键 @Field(type = FieldType.Text, analyzer = 'ik_max_word') 声明字段类型以及其他信息 ``` **interface** ```java @Repository public interface EsSubjectRepo extends ElasticsearchRepository { } ``` **代码demo** ```java @Service public class EsSubjectInfoServiceImpl implements EsSubjectInfoService { @Resource private EsSubjectRepo repo; @Resource private ElasticsearchRestTemplate restTemplate; @Override public void createIndex() { IndexOperations indexOps = restTemplate.indexOps(SubjectInfoEs.class); indexOps.create(); Document mapping = indexOps.createMapping(SubjectInfoEs.class); indexOps.putMapping(mapping); } @Override public void addDocs() { List subjectInfoEs = List.of( new SubjectInfoEs(1L, 'mysql是什么', 'mysql是关系型数据库', 'wwb', new Date()), new SubjectInfoEs(2L, 'redis是什么', 'redis是基于内存的键值对型数据库', 'wwb', new Date()), new SubjectInfoEs(3L, 'es是什么', 'es是搜索引擎', 'wwb', new Date())); repo.saveAll(subjectInfoEs); } @Override public void find() { Iterable all = repo.findAll(); for (SubjectInfoEs subjectInfoEs : all) { System.out.println(subjectInfoEs); } } @Override public void search() { NativeSearchQuery query = new NativeSearchQueryBuilder() .withQuery(QueryBuilders.matchQuery('createUser', 'wwb')) .build(); SearchHits searched = restTemplate.search(query, SubjectInfoEs.class); Iterator> iterator = searched.stream().iterator(); while (iterator.hasNext()) { SearchHit next = iterator.next(); SubjectInfoEs content = next.getContent(); System.out.println(content.getSubjectName()); } } } ```。

git

Mon, 08 Jul 2024 01:01:56 +0000

### 概念图 ![image](https://github.com/iamdurant/iamdurant.github.io/assets/107034526/54916701-a7d3-4c9a-b465-b69d0be73426) ![image](https://github.com/iamdurant/iamdurant.github.io/assets/107034526/a25ae0ec-eea1-4aa8-b86c-b9bae5f8d9af) ### 基础 #### 设置用户信息 `git config --global user.email '123@bbq.com'` `git config --global user.name 'kevin'` #### git log `alias gl='git log --pretty=oneline --all --graph --abbrev-commit'` `git reflog` #### 初始化仓库 `git init` #### staged `git add ...` #### 查看状态 `git status` #### 提交 `git commit -m '提交描述信息'` #### 版本回退 `git reset --hard commitID` #### .gitignore ```text .gitignore *.class *.iml *.idea ``` ### 分支相关 #### 查看分支 `git branch` #### 创建分支 `git branch ` #### 删除分支 `git branch -d ` `git branch -D ` *强制删除* #### 切换分支 ```text git checkout git switch ``` #### 创建并切换分支 `git checkout -b ` #### 合并分支 `git merge ` #### 通用分支使用图 ![image](https://github.com/iamdurant/iamdurant.github.io/assets/107034526/f0a1c210-5152-4ac9-a989-1e42fa39a0f8) ### 远程仓库相关 #### 关联仓库 `git remote add ` #### 关联分支 ```text git branch --set-upstream=/ ``` #### 查看关联仓库 `git remote` #### 关联分支 `git push --set-upstream` #### 推送代码 `git push :` #### 拉代码 ```text git fetch 抓取分支，不合并，若不指定branch，则抓取所有branch git pull 拉取分支，合并，若不指定branch，则拉取所有分支 ``` 。

编译redis、mysql、nginx

Sun, 07 Jul 2024 06:29:43 +0000

#### 环境设备：redmi6 android linux-deploy chroot 架构：arm32 无法使用systemctl，无法使用docker部署应用，应用的预编译版本都为64位，无法使用 #### 编译redis 版本：7.0.15 前置依赖：build-essential tcl 准备好源代码 1. make -j6 2. make PREFIX=/tmp/redis install 耗时：10分钟 #### 编译mysql 版本：8.0.38 前置依赖：build-essential cmake libncurses5-dev libssl-dev bison libaio-dev 准备好源代码 1. mkdir build && cd build 2. cmake .. -DDOWNLOAD_BOOST=1 -DWITH_BOOST=boost `此步骤可能提示cmake版本过低，若apt存在最低要求的版本最好，直接安装，否则准备需要cmake源码，编译安装cmake：1. apt remove cmake 2. ./bootstrap 3. make -j6 4. make install 5. echo 'export PATH=/usr/local/bin:$PATH' >> ~/.bashrc 7. source ~/.bashrc` 4. make -j8 5. make install DESTDIR=/tmp/mysql 耗时：将近6小时与此[博主](https://cloud.tencent.com/developer/article/1799089)的耗时差不多（刚开始我还以为mysql也不至于编译那么久） **意外情况：编译到73%频繁死机，检查后，内存不足，利用scene4增大了2GB的swap后，得以继续编译** #### mysql编译完成测试： 1. `groupadd mysql **not use**` 2. `useradd mysql -r -g mysql -s /bin/false mysql **not use**` 3. `./mysqld --initialize-insecure --user=mysql --basedir=/usr/local/mysql --datadir=/usr/local/mysql/data` 4. `./mysqld_safe --user=root &`。

图

Thu, 27 Jun 2024 11:40:05 +0000

### 图图由vertext以及edge组成，分为有向图和无向图。

排序算法

Tue, 25 Jun 2024 15:08:48 +0000

## 最基础的十大排序算法 - 冒泡排序 - 选择排序 - 插入排序 - 希尔排序 - 堆排序 - 归并排序 - 快速排序 - 计数排序 - 桶排序 - 基数排序 ### 基于比较的排序算法，常见有： ![各排序算法复杂度](https://github.com/iamdurant/iamdurant.github.io/assets/107034526/e9360d33-8b17-45d3-affe-1d0a7527914c) #### 冒泡排序重复遍历数组（每次遍历不断减少），每轮遍历不断比较并往后交换较大值，用一个变量记录最近的一次交换，可以减少交换次数，在部分有序的情况下，可以减少交换次数。

基督山伯爵

Sun, 23 Jun 2024 10:21:46 +0000

#### 核心人物 - 法里亚（神甫） - 埃德蒙·唐戴斯（主人公） - 卡德鲁斯 - 梅赛苔丝（德·莫尔赛夫夫人） - 费尔南（德·莫尔赛夫伯爵） - 唐格拉尔 - 德·维尔福 - 莫雷尔 #### 其他人物 - 雅各布（水手） - 朱丽（莫雷尔之女） - 马克西米利安·莫雷尔（莫雷尔之子） - 埃马纽埃尔（正追求朱丽） - 科克莱斯（莫雷尔公司出纳员） - 佩纳隆（老水手） - 戈玛尔（法老号船长） - 阿尔贝·德·莫尔赛夫（子爵） - 弗朗兹·德·埃皮奈（男爵）。

哈希表

Sat, 22 Jun 2024 05:31:16 +0000

#### 底层数据结构哈希表底层数据结构为数组＋链表或者数组+红黑树。

初识B树

Thu, 20 Jun 2024 13:04:19 +0000

### B树 B树（B-Tree）是一种自平衡的树数据结构，它在维护排序数据的同时，支持高效的插入、删除和查找操作。

重识yaml

Thu, 20 Jun 2024 08:45:56 +0000

### spring将yaml格式作为配置文件格式，必须得好好熟悉一下 ### 基本语法 - 大小写敏感 - 使用缩进表示层级关系 - 缩进值允许使用空格，不允许使用tab - 缩进的空格数不重要，只要保证相同层级的左对齐即可 - 使用`#`表示注释 ### yaml对象以键值对的方式表示中间用`: `分隔key & value，`:`号后面带**一个**空格 ```yaml key: value1 value2 ``` ### yaml数组 yaml数组用`- `号开头，`:`号后面带**一个**空格 ```yaml arr: - a - b - c ``` 也可以表示多维数组，需控制层级 ```yaml array: - - a - b - c - - x - y - z ``` 对象数组，就像java中的`Person p1 = new Person('薛大炮', 18);Person p2 = new Person('蔡徐坤', 26);Person[] persons = new Person[]{p1, p2};` ```yaml persons - name: 薛大炮 age: 18 - name: 蔡徐坤 age: 26 ``` ### 复合结构对象和数组可以构成复杂的结构关系 ```yaml languages: - Java - C++ - Go WebSites: baidu: https://www.baidu.com google: https:www.google.com bing: https:www.bing.com ``` 对应到json为 ```json { 'languages': ['Java', 'C++', 'Go'], 'WebSites': { 'baidu': 'https://www.baidu.com', 'google': 'https:www.google.com', 'bing': 'https:www.bing.com' } } ``` ### 纯量纯量是最基本的，不可再分的值 - 字符串 - 整数 - 浮点数 - 布尔值 - null - 时间（date） - 日期（datetime）以一个例子来看各纯量的使用 ```yaml string: - 哈哈 # 字符串可直接写 - 'good' # 或者单引号引表示 - '西海岸' # 或者双引号表示 - you jump # 字符串可写多行，每行被转化为空格即为` you jump i jump！` i jump！ int: - 123 - 0100_1101 # 二进制表示 float: - 66.6 - 45.1231402+e5 # 可以使用科学计数法表示 boolean: - TRUE - FALSE - True - False - true - false # 其实 true false 全小写最常用 null: - a - ~ # 使用~表示null date: 2024-06-20 # 使用ISO-8601标准：yyyy-MM-dd datetime: 2024-06-20T16:34:20+09:00 # 使用ISO-8601标准：yyyy-MM-ddTHH:mm:ss+时区 ``` ### 引用 `&`表示锚点，`*`表示引用锚点，`<<: `表示合并到当前数据流 ```yaml database: &database host: 127.0.0.1 port: 3306 user: root password: 123456 mysql: <<: *database # 若未生效则mardown解析器不兼容 ``` 。

初窥markdown

Wed, 19 Jun 2024 17:43:00 +0000

### 首先呢，要学会markdown语法，markdown语法非常强大，实在是太酷了，迫不及待要看一看它的语法了！！ ### 标题就标题来说只需在文字前面加上（# ），是的，一个#号加一个空格，后面再跟上标题即可，#号越多标题越小 ### 引用 > 只需在文本开头前加上`> `即可（后面带空格） ### 粗体、斜体、粗体斜体这是斜体 *哈哈哈哈* 文本块前后各加一个星号这是加粗 **呵呵呵呵** 文本块前后各加两个星号这是斜体与加粗 ***嘻嘻嘻嘻*** 文本块前后各加三个星号 ### 无序列表无序列表的使用也是相当清晰，就像yaml的数组一样，当然了，控制层级的话只需在前面控制空格数量就好了 - 苹果 - 香蕉 - 蔬菜 - 青菜 - 白菜 ### 有序列表有序列表只需在数字或者符号后加上`. `即可（后面有空格）, 1. 科比 2. 杜兰特 3. 乔丹 ### 链接链接的格式：`[]()` 方括号里面是文字圆括号里面是连接地址比如：[来吧，now，is movie time！！！](https://nunflix.com) ### 图片哇哇哇哦，图片就比较刺激了，格式：`![]()`，基于连接，由感叹号开头，方括号里面是文字(在这里是图片描述) 圆括号里面是连接地址比如： ![我的leetcode头像](https://assets.leetcode.cn/aliyun-lc-upload/users/tender-satoshino0/avatar_1692271843.png) ### 分割线格式：`---` 就是三个减号三个减号上面还需空一行 --- ### 表格表格就更有意思了，太new了，太潮流了格式：`|`用来分割，第二行的`:` 用来代表左对齐还是右对齐，或者中间对齐 ![表格格式](https://github.com/iamdurant/iamdurant.github.io/assets/107034526/5410dc3a-1e97-426e-b8b5-a629ca4f25d6) | 学号 | 姓名 | 年龄 | | :---------- | :--- | :-- | | 2020132238 | 蔡徐坤 | 23 | | 2020132221 | 薛大炮 | 24 | | 2020132249 | 洲饱饱 | 23 | **上述有我的idol 以及我的两个brother，能被我写进blog，是我的brother的福气** ### 脚注脚注就比较叼了格式也是基于链接：`[](脚注解释 '脚注名字')` - [全栈工程师](全栈工程师就是。