RiverMao

Java Launcher Introduction

Fri, 11 Jul 2025 10:19:25 +0800

Java Launcher

⭐️ 中文介绍

Java Launcher is a powerful and intuitive VS Code extension for discovering, running, managing, and debugging your Java applications. Its design is inspired by the seamless run and debug experience in JetBrains IntelliJ IDEA.

Say goodbye to the tedious work of manually editing launch.json. Java Launcher automatically discovers all runnable entry points in your project—including main methods, Spring Boot applications, and tests—and displays them in a dedicated view in the Activity Bar. You can even start, restart, or stop your entire microservice stack with a single click.

Java Launcher 中文介绍

Fri, 11 Jul 2025 10:19:25 +0800

Java Launcher

⭐️ Instructions in English

Java Launcher 是一款功能强大、操作直观的 VS Code 插件，用于发现、运行、管理和调试您的 Java 应用。其设计灵感来源于 JetBrains IntelliJ IDEA 中流畅的运行和调试体验。

告别手动编辑 launch.json 的繁琐工作。Java Launcher 会自动发现您项目中所有可运行的入口点——包括 main 方法、Spring Boot 应用和测试——并将它们展示在活动栏的一个专属视图中。您甚至可以一键启动,重启, 停止整个微服务技术栈。

知识图谱与图数据库Neo4j--Part03

Sat, 16 Nov 2024 21:03:44 +0800

知识图谱与图数据库Neo4j–Part02 <— Part02

Spring Data Neo4j(SDN)

可以说目前这个系列就是为了SDN这点醋才包的饺子, 笔者写到这里的时候已经踩过了太多的坑

版本

如果不想和不久前的我一样痛苦,版本就跟我保持一致

知识图谱与图数据库Neo4j--Part02

Sat, 16 Nov 2024 20:32:11 +0800

知识图谱与图数据库Neo4j–Part01 <— Part01

一. 图数据库和关系型DB的对比

从技术上来说, 用关系型数据库(如pgSQL, MariaDB)来存储知识图谱,是完全没问题的, 但一旦知识图谱变复杂,用传统的[关系数据存储], 查询效率会显著低于[图数据库], 在一些涉及到2,3度的关联查询场景, 图数据库能把查询效率提升几千倍甚至几百万倍. 而且基于图的存储在设计上会非常灵活, 一般只需要有局部的改动即可, 当场景数据规模较大时, 建议使用图数据库来进行存储

知识图谱与图数据库Neo4j--Part01

Sat, 16 Nov 2024 19:46:11 +0800

知识图谱

{ 此Part较枯燥, 看不下去可以直接看Part02–> 知识图谱与图数据库Neo4j–Part02 }

1. 什么是知识图谱

基本概念: 知识图谱是一种结构化的语义知识库, 用于快速描述物理世界中的概念及其相互关系. 它通常以图形结构的方式来直观展示实体(对象, 事件, 状况或概念)及其关系. 知识图谱的基本组成为: “实体—->关系—->实体”三元组, 这些信息常常存储在图形数据库中.
直观描述: 知识图谱本质为存储实体之间的复杂关系,并让资源更易于计算,理解和评价
目前的应用:
- 搜索结果优化
- 电商智能推荐与智能客服
- 金融风控分析
- 公安情报分析与反欺诈
- 自然语言分析
- …
组成: 知识图谱由模式层和数据层两部分组成. 1).模式层: 存储着经过提炼的知识 2).数据层: 存储着事实

2. 知识图谱的原始数据类型和存储方式

原始数据结构: 知识图谱的原始数据结构一般来说有三类:
- 结构化数据(关系型数据库, 链接数据等)
- 半结构化数据(XML, JSON, 百科等)
- 非结构化数据(图片,音频,视频等)
存储方式:
- 通过RDF(资源描述框架)这样的存储格式来存储, 比如Jena
- 使用图数据库来存储, 常用的有Neo4j

下一Part介绍Neo4j: Part02

Git中的Git-SVN使用指南

Thu, 26 Sep 2024 19:30:49 +0800

献给所有习惯使用了Git但不得不使用SVN的人们, 比如我

使用git-svn拉下来的仓库本质上是一个git仓库, 但所有push和fetch都必须使用git-svn而不是git

Mybatis & Spring Data Jpa 多数据源配置

Fri, 13 Sep 2024 09:07:06 +0800

Mybatis多数据源

Master:

package com.xxx.xxx.kotlin.config.hikari.mybatis

import com.xxx.xxx.config.hikari.map.specific.MasterMyHikariSetting
import com.xxx.xxx.util.HikariSetting2ConfigUtils
import com.zaxxer.hikari.HikariDataSource
import org.apache.ibatis.session.SqlSessionFactory
import org.mybatis.spring.SqlSessionFactoryBean
import org.mybatis.spring.SqlSessionTemplate
import org.mybatis.spring.annotation.MapperScan
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.Primary
import org.springframework.jdbc.datasource.DataSourceTransactionManager
import javax.sql.DataSource


/**
 * Master数据源加载
 * @author: River
 * @version: 1.0
 */
@Configuration
//扫receive包
@MapperScan(basePackages = ["com.xxx.xxx.mapper.master"], sqlSessionFactoryRef = "masterSqlSessionFactory")
class MasterDatasourceConfig {
    //获取日志对象
    val log: Logger = LoggerFactory.getLogger(this.javaClass)

    //初始化第一个数据源(master/接收方)
    @Bean(name = ["materDatasource"])
    @Primary
    fun masterDatasource(myHikariSetting: MasterMyHikariSetting): DataSource {
        log.info("正在初始化Master数据源...")
        return HikariDataSource(HikariSetting2ConfigUtils.mySetting2Config(myHikariSetting))
    }

    /**
     * mybatis sqlSession
     */
    @Bean(name = ["masterSqlSessionFactory"])
    @Primary
    fun sqlSessionFactory(@Qualifier("materDatasource") dataSource: DataSource): SqlSessionFactory? {
        val sqlBean = SqlSessionFactoryBean()
        sqlBean.setDataSource(dataSource)
//        val resolver = PathMatchingResourcePatternResolver()
//        sqlBean.setMapperLocations(*resolver.getResources("classpath:mapper/*.xml"))
        return sqlBean.`object`
    }

    @Bean(name = ["masterTransactionManager"])
    @Primary
    fun transactionManager(@Qualifier("materDatasource") dataSource: DataSource): DataSourceTransactionManager {
        return DataSourceTransactionManager(dataSource)
    }

    @Primary
    @Bean(name = ["masterSqlSessionTemplate"])
    fun sqlSessionTemplate(@Qualifier("masterSqlSessionFactory") sqlSessionFactory: SqlSessionFactory): SqlSessionTemplate {
        log.info("Master数据源SqlSessionFactory创建成功...")
        return SqlSessionTemplate(sqlSessionFactory)
    }
}

package com.xxx.xxx.kotlin.config.hikari.mybatis

import com.xxx.xxx.kotlin.config.hikari.map.specific.SourceFirstMyHikariSetting
import com.xxx.xxx.kotlin.util.HikariSetting2ConfigUtils
import com.zaxxer.hikari.HikariDataSource
import org.apache.ibatis.session.SqlSessionFactory
import org.mybatis.spring.SqlSessionFactoryBean
import org.mybatis.spring.SqlSessionTemplate
import org.mybatis.spring.annotation.MapperScan
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.jdbc.datasource.DataSourceTransactionManager
import javax.sql.DataSource

/**
 * 第一个副数据源加载
 * @author River
 * @since 1.0
 */
@Configuration
@MapperScan(basePackages = ["com.xxx.xxx.mapper.first"], sqlSessionFactoryRef = "sourceFirstSqlSessionFactory")
class SourceFirstDatasourceConfig {
    //获取日志对象
    val log: Logger = LoggerFactory.getLogger(this.javaClass)
    
    @Bean(name = ["sourceFirstDatasource"])
    fun sourceFirstDatasource(myHikariSetting: SourceFirstMyHikariSetting): DataSource {
        log.info("正在初始化第一个副数据源...")
        return HikariDataSource(HikariSetting2ConfigUtils.mySetting2Config(myHikariSetting))
    }

    /**
     * mybatis sqlSession
     */
    @Bean(name = ["sourceFirstSqlSessionFactory"])
    fun sqlSessionFactory(@Qualifier("sourceFirstDatasource") dataSource: DataSource): SqlSessionFactory? {
        val sqlBean = SqlSessionFactoryBean()
        sqlBean.setDataSource(dataSource)
//        val resolver = PathMatchingResourcePatternResolver()
//        sqlBean.setMapperLocations(*resolver.getResources("classpath:mapper/*.xml"))
        return sqlBean.`object`
    }

    @Bean(name = ["sourceFirstTransactionManager"])
    fun transactionManager(@Qualifier("sourceFirstDatasource") dataSource: DataSource): DataSourceTransactionManager {
        return DataSourceTransactionManager(dataSource)
    }

    @Bean(name = ["sourceFirstSqlSessionTemplate"])
    fun sqlSessionTemplate(@Qualifier("sourceFirstSqlSessionFactory") sqlSessionFactory: SqlSessionFactory): SqlSessionTemplate {
        log.info("第一个副数据源SqlSessionFactory创建成功...")
        return SqlSessionTemplate(sqlSessionFactory)
    }
}

Spring Data Jpa 多数据源

Primary:

package com.xxx.xxx.kotlin.config.hikari.jpa

import com.xxx.xxx.kotlin.config.hikari.map.specific.MasterMyHikariSetting
import com.xxx.xxx.kotlin.util.HikariSetting2ConfigUtils
import com.zaxxer.hikari.HikariDataSource
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.Primary
import org.springframework.data.jpa.repository.config.EnableJpaRepositories
import org.springframework.orm.jpa.JpaTransactionManager
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean
import org.springframework.orm.jpa.persistenceunit.PersistenceUnitManager
import org.springframework.orm.jpa.vendor.AbstractJpaVendorAdapter
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.annotation.EnableTransactionManagement
import javax.persistence.EntityManager
import javax.sql.DataSource


@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
    entityManagerFactoryRef = "entityManagerFactoryPrimary",
    transactionManagerRef = "transactionManagerPrimary",
    basePackages = ["com.xxx.xxx.kotlin.repository.first"]
)
class PrimaryDatasourceConfig {
    //获取日志对象
    val log: Logger = LoggerFactory.getLogger(this::class.java)

    @Autowired
    private lateinit var jpaProperties: JpaProperties

    @Autowired
    private lateinit var hibernateProperties: HibernateProperties

    @Autowired(required = false)
    private val persistenceUnitManager: PersistenceUnitManager? = null


    @Bean(name = ["primaryDatasource"])
    fun primaryDatasource(myHikariSetting: MasterMyHikariSetting): DataSource {
        log.info("正在初始化JPA master数据源...")
        return HikariDataSource(HikariSetting2ConfigUtils.mySetting2Config(myHikariSetting))
    }

    private fun getVendorProperties(): Map<String?, Any?>? {
        return hibernateProperties.determineHibernateProperties(jpaProperties.properties, HibernateSettings())
    }

    @Bean(name = ["myEntityManagerFactoryBuilder"])
    fun customerEntityManagerFactoryBuilder(customerJpaProperties: JpaProperties): EntityManagerFactoryBuilder? {
        val adapter: AbstractJpaVendorAdapter = HibernateJpaVendorAdapter()
        return EntityManagerFactoryBuilder(
            adapter,
            customerJpaProperties.properties, persistenceUnitManager
        )
    }

    @Bean(name = ["entityManagerPrimary"])
    @Primary
    fun entityManager(@Qualifier("myEntityManagerFactoryBuilder")builder: EntityManagerFactoryBuilder, @Qualifier("primaryDatasource") datasource: DataSource): EntityManager? {
        return entityManagerFactoryPrimary(builder, datasource).getObject()!!.createEntityManager()
    }

    @Bean(name = ["entityManagerFactoryPrimary"])
    @Primary
    fun entityManagerFactoryPrimary(@Qualifier("myEntityManagerFactoryBuilder")builder: EntityManagerFactoryBuilder, @Qualifier("primaryDatasource") datasource: DataSource): LocalContainerEntityManagerFactoryBean {
        return builder
            .dataSource(datasource)
            .packages("com.xxx.xxx.kotlin.entity.master") //设置实体类所在位置
            .persistenceUnit("primary")
            .properties(getVendorProperties())
            .build()
    }
    @Bean(name = ["transactionManagerPrimary"])
    @Primary
    fun transactionManagerPrimary(@Qualifier("myEntityManagerFactoryBuilder")builder: EntityManagerFactoryBuilder, @Qualifier("primaryDatasource") datasource: DataSource): PlatformTransactionManager? {
        return JpaTransactionManager(entityManagerFactoryPrimary(builder, datasource).getObject()!!)
    }

}

package com.xxx.xxx.kotlin.config.hikari.jpa

import com.xxx.xxx.kotlin.config.hikari.map.specific.SourceSecondMyHikariSetting
import com.xxx.xxx.kotlin.util.HikariSetting2ConfigUtils
import com.zaxxer.hikari.HikariDataSource
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.data.jpa.repository.config.EnableJpaRepositories
import org.springframework.orm.jpa.JpaTransactionManager
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.annotation.EnableTransactionManagement
import javax.persistence.EntityManager
import javax.sql.DataSource

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
    entityManagerFactoryRef = "entityManagerFactorySecondary",
    transactionManagerRef = "transactionManagerSecondary",
    basePackages = ["com.xxx.xxx.kotlin.repository.second"]
)
class SecondaryDatasourceConfig {
    //获取日志对象
    val log: Logger = LoggerFactory.getLogger(this::class.java)

    @Autowired
    private lateinit var jpaProperties: JpaProperties

    @Autowired
    private lateinit var hibernateProperties: HibernateProperties

    @Bean(name = ["secondaryDatasource"])
    fun secondaryDatasource(myHikariSetting: SourceSecondMyHikariSetting): DataSource {
        log.info("正在初始化JPA Second数据源...")
        return HikariDataSource(HikariSetting2ConfigUtils.mySetting2Config(myHikariSetting))
    }

    private fun getVendorProperties(): Map<String?, Any?>? {
        return hibernateProperties.determineHibernateProperties(jpaProperties.properties, HibernateSettings())
    }

    @Bean(name = ["entityManagerSecondary"])
    fun entityManager(
        builder: EntityManagerFactoryBuilder,
        @Qualifier("secondaryDatasource") datasource: DataSource
    ): EntityManager? {
        return entityManagerFactorySecondary(builder, datasource).getObject()!!.createEntityManager()
    }

    @Bean(name = ["entityManagerFactorySecondary"])
    fun entityManagerFactorySecondary(
        builder: EntityManagerFactoryBuilder,
        @Qualifier("secondaryDatasource") datasource: DataSource
    ): LocalContainerEntityManagerFactoryBean {
        return builder
            .dataSource(datasource)
            .packages("com.xxx.xxx.kotlin.entity.second") //设置实体类所在位置
            .persistenceUnit("secondary")
            .properties(getVendorProperties())
            .build()
    }

    @Bean(name = ["transactionManagerSecondary"])
    fun transactionManagerSecondary(
        builder: EntityManagerFactoryBuilder,
        @Qualifier("secondaryDatasource") datasource: DataSource
    ): PlatformTransactionManager? {
        return JpaTransactionManager(entityManagerFactorySecondary(builder, datasource).getObject()!!)
    }
}

工具类与其他实体

MasterMyHikariSetting (其他以MyHikariSetting结尾的类与此类似,父类BaseMyHikariSetting属性与此相同):

package com.xxx.xxx.kotlin.config.hikari.map.specific

import com.xxx.xxx.kotlin.config.hikari.map.BaseMyHikariSetting
import com.xxx.xxx.kotlin.config.factory.YamlPropertySourceFactory
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.PropertySource
import java.util.*

/**
 * master配置实体
 */
@Configuration
@PropertySource(value = ["classpath:datasources/datasources.yml"], factory = YamlPropertySourceFactory::class)
@ConfigurationProperties(prefix = "spring.datasources.master.hikari")
class MasterMyHikariSetting : BaseMyHikariSetting(){
    override var maximumPoolSize: Int? = null
    override var idleTimeout: Long? = null
    override var maxLifetime: Long? = null
    override var dataSourceProperties: Properties? = null
    override var driverClassName: String? = null
    override var jdbcUrl: String? = null
    override var username: String? = null
    override var password: String? = null

}

HikariSetting2ConfigUtils:

package com.xxx.xxx.kotlin.util

import com.xxx.xxx.kotlin.config.hikari.map.BaseMyHikariSetting
import com.zaxxer.hikari.HikariConfig

/**
 * Hikari数据源配置工具类
 * @author River
 * @since 1.0
 */
class HikariSetting2ConfigUtils {
    companion object {
        /**
         * 自定义Hikari配置转换为标准Hikari配置
         */
        fun mySetting2Config(baseSetting: BaseMyHikariSetting): HikariConfig {
            val hikariConfig = HikariConfig()
            hikariConfig.driverClassName = baseSetting.driverClassName
            hikariConfig.jdbcUrl = baseSetting.jdbcUrl
            hikariConfig.username = baseSetting.username
            hikariConfig.password = baseSetting.password
            hikariConfig.maximumPoolSize = baseSetting.maximumPoolSize!!
            hikariConfig.maxLifetime = baseSetting.maxLifetime!!
            hikariConfig.idleTimeout = baseSetting.idleTimeout!!
            hikariConfig.dataSourceProperties = baseSetting.dataSourceProperties
            return hikariConfig
        }
    }
}

位于项目resources/datasources目录下的datasources.yml文件:

spring:
  datasources:
    #    主数据源(pg)
    master:
      hikari:
        driver-class-name: org.postgresql.Driver
        jdbc-url: jdbc:postgresql://127.0.0.1/xxx
        username: postgres
        password: testpostgres
        maximum-pool-size: 20 
        max-lifetime: 30000
        idle-timeout: 30000
        data-source-properties:
          prepStmtCacheSize: 250
          prepStmtCacheSqlLimit: 2048
          cachePrepStmts: true
          useServerPrepStmts: true
    #    access数据源
    first:
      hikari:
        driver-class-name: net.ucanaccess.jdbc.UcanaccessDriver
        jdbc-url: jdbc:ucanaccess:////xxx/xxx/xxx.mdb
        username:
        password:
        maximum-pool-size: 20
        max-lifetime: 30000
        idle-timeout: 30000
        data-source-properties:
          prepStmtCacheSize: 250
          prepStmtCacheSqlLimit: 2048
          cachePrepStmts: true
          useServerPrepStmts: true
    second:
      hikari:
        driver-class-name: org.postgresql.Driver
        jdbc-url: jdbc:postgresql://127.0.0.1:5432/xxx
        username: postgres
        password: postgres
        maximum-pool-size: 20
        max-lifetime: 30000
        idle-timeout: 30000
        data-source-properties:
          prepStmtCacheSize: 250
          prepStmtCacheSqlLimit: 2048
          cachePrepStmts: true
          useServerPrepStmts: true

Tip:

如果在一个项目中mybatis和spring data jpa同时开启了多数据源,在Spring的事务注解中需指定当前事务管理bean

有向图的邻接矩阵表示与路径可达分析

Thu, 12 Sep 2024 14:23:49 +0800

数据结构

Node

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 用于图的邻接矩阵与搜索算法的数据结构, 只保留唯一标识这一种属性,减少内存开销
 * @author rxz
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class Node<T> {
    T pre;
    T after;
}

Pair

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * 放置两个平级数据, 此对象用于推入栈或加入队列, 简化算法可读性
 * @param <K> /
 * @param <V> /
 */
@Data
@AllArgsConstructor
public class Pair<K, V> {
    private K key;
    private V value;

}

GraphMatrixEntity

import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import java.io.Serializable;
import java.util.List;

/**
 * 有向图的邻接矩阵对象
 * @param <T> Node节点的类型 一般为Long
 * @param <K> 原始对象集合的类型
 */
@Slf4j
@Data
public class GraphMatrixEntity<T,K> implements Serializable {
    /**
     * 原始node集合
     */
    private List<Node<T>> nodes;

    /**
     * 邻接矩阵对照尺, 是一个线性表
     */
    private List<T> standardRuler;

    /**
     * 有向图的邻接矩阵表示
     */
    private int[][] graph;

    /**
     * 有向图的所有头节点
     */
    private List<Integer> headNodeIndex;

    /**
     * 有向图的所有尾节点
     */
    private List<Integer> tailNodeIndex;

    /**
     * 原始集合(此数据结构在算法中不会被赋值,请注意判空)
     */
    private List<K> rawList;
}

邻接矩阵转换与路径可达性分析

import cn.hutool.core.collection.CollUtil;
import lombok.extern.slf4j.Slf4j;

import java.util.*;

/**
 * 图的邻接矩阵转换算法与基于广度优先搜算法的路径可达节点查找算法实现
 * 使用此算法时必须声明泛型!
 *
 * @param <T> id的类型, 出入库单中总是为Long
 * @author rxz
 */
@Slf4j
public class GraphMatrixHandler<T,K> {
    public GraphMatrixEntity<T,K> matrixTransfer(List<Node<T>> nodeList) {
        GraphMatrixEntity<T,K> matrix = new GraphMatrixEntity<>();
        if (CollUtil.isEmpty(nodeList)) {
            return matrix;
        }
        //1. 去重nodes
        HashSet<Node<T>> nodes = new HashSet<>(nodeList);
        Set<T> allIdSet = new HashSet<>();
        //2. 将node集合转换为有向图, 用邻接矩阵的方式实现这个有向图
        // 2.1 构造一个辅助map,对node集合进行数据整理(支持null的存在)
        Map<T, Set<T>> map = new HashMap<>();
        nodes.forEach(node -> {
            Set<T> valueList = Optional.ofNullable(map.get(node.pre)).orElse(new HashSet<>());
            valueList.add(node.after);
            map.put(node.pre, valueList);

            allIdSet.add(node.pre);
            allIdSet.add(node.after);
        });
        // 2.2 初始化邻接矩阵
        List<T> nodeIdList = new ArrayList<>(allIdSet);
        int size = nodeIdList.size();
        int[][] graph = new int[size][size];
        for (int i = 0; i < graph.length; i++) {
            //i 严格对应preList的下标
            T iElement = nodeIdList.get(i);
            Set<T> matchingSet = map.get(iElement);
            for (int j = 0; j < graph[i].length; j++) {
                T jElement = nodeIdList.get(j);
                if (matchingSet != null && matchingSet.contains(jElement)) {
                    graph[i][j] = 1;
                } else {
                    graph[i][j] = 0;
                }
            }
        }
        //3. 获取所有的头节点和尾节点(的索引)
        List<Integer> headNodeIndex = new ArrayList<>();
        List<Integer> tailNodeIndex = new ArrayList<>();
        for (int i = 0; i < nodeIdList.size(); i++) {
            boolean tailFlag = false;
            boolean headFlag = false;
            for (int j = 0; j < nodeIdList.size(); j++) {
                if (!tailFlag && graph[i][j] == 1) {
                    tailFlag = true;
                }
                if (!headFlag && graph[j][i] == 1) {
                    headFlag = true;
                }
            }
            if (!tailFlag) {
                tailNodeIndex.add(i);
            }
            if (!headFlag) {
                headNodeIndex.add(i);
            }
        }

        //TODO: 如果有向图中没有任何端点(所有头和尾都存在环), 要如何处理?

        //4. 整理结果, 返回
        matrix.setGraph(graph);
        matrix.setNodes(nodeList);
        matrix.setStandardRuler(nodeIdList);
        matrix.setHeadNodeIndex(headNodeIndex);
        matrix.setTailNodeIndex(tailNodeIndex);

        return matrix;
    }

    /**
     * 使用广度优先算法, 在有向图的邻接矩阵中获取某个给定节点(索引)在n步数内可以到达的所有节点的索引
     *
     * @param nodeIdList    矩阵对照尺
     * @param graph         有向图的邻接矩阵
     * @param headNodeIndex 开始节点的索引集合(在对照尺中的下标)
     * @param n             步数
     * @return Map < 开始节点的索引,所有可达节点在矩阵对照尺中的下标>
     */
    public Map<Integer, List<Integer>> findNodesWithNPossiblePaths(List<T> nodeIdList, int[][] graph, List<Integer> headNodeIndex, int n) {
        Map<Integer, List<Integer>> nPathLengthNodeIndexMap = new HashMap<>();
        if (CollUtil.isEmpty(headNodeIndex)) {
            return nPathLengthNodeIndexMap;
        }
        for (Integer index : headNodeIndex) {
            T headNode = nodeIdList.get(index);
            List<Integer> reachableNodesOnPathN = bfs(nodeIdList, graph, headNode, n);
            nPathLengthNodeIndexMap.put(index, reachableNodesOnPathN);
        }
        return nPathLengthNodeIndexMap;
    }

    /**
     * 使用广度优先算法, 在有向图的邻接矩阵中获取某个给定节点(索引)在n步数内可以到达的所有节点的索引
     *
     * @param nodeIdList 矩阵对照尺
     * @param graph      有向图的邻接矩阵
     * @param startNode  开始节点的索引(在对照尺中的下标)
     * @param n          步数
     * @return 所有可达节点在矩阵对照尺中的下标
     */
    private List<Integer> bfs(List<T> nodeIdList, int[][] graph, T startNode, int n) {
        List<Integer> result = new ArrayList<>();
        int startIndex = nodeIdList.indexOf(startNode);
        Queue<Pair<Integer, Integer>> queue = new LinkedList<>();
        queue.offer(new Pair<>(startIndex, 0));

        while (!queue.isEmpty()) {
            Pair<Integer, Integer> current = queue.poll();
            int currentNodeIndex = current.getKey();
            int currentDepth = current.getValue();

            if (currentDepth < n) {
                for (int j = 0; j < graph[currentNodeIndex].length; j++) {
                    if (graph[currentNodeIndex][j] == 1) {
                        queue.offer(new Pair<>(j, currentDepth + 1));
                    }
                }
            } else if (currentDepth == n) {
                result.add(currentNodeIndex);
            }
        }
        return result;
    }

    /**
     * 使用广度优先搜索, 获取有向图中在给定步数m下, 可以到达给定节点(索引)的所有节点(索引)
     * @param nodeIdList 矩阵对照尺
     * @param graph 有向图的邻接矩阵
     * @param tailNodeIndex 最终到达节点的索引(在对照尺中的下标)
     * @param m 步数
     * @return 所有可出发节点在矩阵对照尺中的下标
     */
    public Map<Integer, List<Integer>> findNodesReachingCanReach(List<T> nodeIdList, int[][] graph, List<Integer> tailNodeIndex, int m) {
        Map<Integer, List<Integer>> goForwardnPathLengthNodeIndexMap = new HashMap<>();
        if (CollUtil.isEmpty(tailNodeIndex)) {
            return goForwardnPathLengthNodeIndexMap;
        }
        for (Integer index : tailNodeIndex) {
            T tailNode = nodeIdList.get(index);
            List<Integer> reachableNodesOnPathM = bfsToReachNode(nodeIdList, graph, tailNode, m);
            goForwardnPathLengthNodeIndexMap.put(index, reachableNodesOnPathM);
        }
        return goForwardnPathLengthNodeIndexMap;
    }


    private List<Integer> bfsToReachNode(List<T> nodeIdList, int[][] graph, T targetNode, int m) {
        List<Integer> result = new ArrayList<>();
        if (nodeIdList.isEmpty()) {
            return result;
        }
        int targetIndex = nodeIdList.indexOf(targetNode);
        Queue<Pair<Integer, Integer>> queue = new LinkedList<>();
        queue.offer(new Pair<>(targetIndex, 0));

        while (!queue.isEmpty()) {
            Pair<Integer, Integer> current = queue.poll();
            int currentNodeIndex = current.getKey();
            int currentDepth = current.getValue();

            if (currentDepth < m) {
                for (int j = 0; j < graph.length; j++) {
                    if (graph[j][currentNodeIndex] == 1) {
                        queue.offer(new Pair<>(j, currentDepth + 1));
                    }
                }
            } else if (currentDepth == m) {
                result.add(currentNodeIndex);
            }
        }
        return result;
    }

}

2024-09-12记

Thu, 12 Sep 2024 12:31:30 +0800

2024-09-12 重启Blog

Birthday_25

Fri, 18 Aug 2023 19:44:30 +0800

无法评价的: 公元2023年

很庆幸自己依然平静的度过了25岁生日

看着上一条记录生日的md

感慨万千,恍如隔日

愿你我都有光明的未来;

在java或kotlin中使用jna调用dll动态链接库

Fri, 10 Mar 2023 08:39:51 +0800

1.jna介绍

Java Native Access (JNA),Github地址:JNA

在仓库的README.md中有:

JNA provides Java programs easy access to native shared libraries without writing anything but Java code - no JNI or native code is required. This functionality is comparable to Windows’ Platform/Invoke and Python’s ctypes.

Compose Multiplatform自定义可下拉输入框组件

Wed, 08 Mar 2023 14:39:51 +0800

compose自带库中的TextField和outlinedTextField有默认的大小,都属于Material风格的输入框,最小尺寸很大,如果要创建UI上比较紧凑的表单,就需要自定义组件了,同时让这个自定义组件也可作为下拉框来使用

线性最小二乘法的参数解

Thu, 02 Mar 2023 14:09:40 +0800

定义

最小二乘法（英语：least squares method），又称最小平方法，是一种数学优化建模方法。它通过最小化误差的平方和寻找数据的最佳函数匹配。利用最小二乘法可以简便的求得未知的数据，并使得求得的数据与实际数据之间误差的平方和为最小。

在PostgreSQL中使用窗口函数解决取分组后前n条数据的问题

Thu, 23 Feb 2023 11:09:40 +0800

先描述一个业务场景:

现有一张数据表,结构如下:
现在要查询每个不同number的最后一条(create_time)的完整记录
保证查询结果中的number不重复

Birthday_24

Sun, 31 Jul 2022 19:39:30 +0800

Happy 24th birthday! 🎂

祝自己24岁生日快乐

Kotlin中select关键字与Channel的用法

Fri, 08 Jul 2022 16:39:51 +0800

Kotlin中Channel的使用

类似Go中的Channel,Kotlin中的Channel也可以在协程间通信

创建

最基本的声明方式:(Channel位于kotlinx.coroutines.channels.Channel)

Rust中的切片

Tue, 31 May 2022 20:59:22 +0800

切片(Slice)

Rust的另一种不持有所有权的数据类型: 切片(slice)

一道题,编写一个函数:

它接收字符串作为参数
返回它在这个字符串的第一个空格的索引
如果函数没有找到任何空格,那么返回整个字符串的长度

fn main(){
    let s = String::from("see you");
    println!("{}",first_word(&s));
}
fn first_word(s:&String) -> usize{
    let my_bytes = s.as_bytes();
    for (i, &item) in my_bytes.iter().enumerate() {
        if item == b' '{
            return i;
        }
    }
    s.len()
}

Rust特性(1)--所有权,深浅拷贝,引用,借用,悬空引用(野指针)

Tue, 31 May 2022 20:59:22 +0800

内存模型

Rust的内存可分为**栈(stack)和堆(heap)**两种
标量会被分配在栈上
栈为后进先出
分配在堆上的变量在使用时要注意一个叫做所有权的概念

所有权(Ownership)

变量的所有权与变量的声明作用域相同,在变量离开作用域时,变量会发生Drop操作,除非发生所有权的移交(move)

深拷贝(deep copy)与浅拷贝(shallow copy)

堆上数据的拷贝:

分配在堆上的变量默认使用的是浅拷贝

Rust的函数

Tue, 31 May 2022 20:59:22 +0800

函数

函数的声明

fn main() {
    println!("This");
    another_function();
}

fn another_function(){
    println!("Another")
}

函数不必定义在main前,声明在在其后依然可以在main中调用

函数的参数

形参 parameters
实参 arguments

在函数的声明里,必须声明每个参数的类型:

Rust的变量、常量与遮蔽(Shadowing)

Tue, 31 May 2022 20:59:22 +0800

Rust的变量,常量,Shadowing

变量

声明变量使用let关键字
默认情况下,Rust的变量是不可变的(immediate),但这与常量仍有很大的区别
在声明变量时,如果变量名前加上_mut_关键字,就可以使此变量可变

Rust的数据类型

Tue, 31 May 2022 20:59:22 +0800

Rust数据类型

标量和复合类型

Rust是静态编译语言,在编译时必须知道所有变量的类型
1. 基于使用的值编译器通常能够推断出变量的具体类型
2. 但如果可能的类型比较多,就必须标注变量的具体类型,否则在编译期就会报错,例:

Jetbrains系IDE快捷键对照

Tue, 31 May 2022 10:38:55 +0800

Win 快捷键	Mac 快捷键	介绍
Ctrl + F	Command + F	在当前文件进行文本查找
Ctrl + R	Command + R	在当前文件进行文本替换
Ctrl + Z	Command + Z	撤销
Ctrl + Y	Command + Delete	删除光标所在行或删除选中的行
Ctrl + D	Command + D	复制光标所在行或复制选择内容，并把复制内容插入光标位置下面
Ctrl + H	Command + D	显示当前类继承关系图
Ctrl + W	Option + 方向键上	递进式选择代码块。可选中光标所在的单词或段落，连续按会在原有选中的基础上再扩展选中范围
Ctrl + E	Command + E	显示最近打开的文件记录列表
Ctrl + N	Command + O	根据输入的类名查找类文件
Ctrl + J	Command + J	插入自定义动态代码模板
Ctrl + P	Command + P	方法参数提示显示
Ctrl + U	Command + U	前往当前光标所在的方法的父类的方法 / 接口定义
Ctrl + B	Command + B	进入光标所在的方法/变量的接口或是定义处，等效于Ctrl + 左键单击
Ctrl + /	Command + /	注释光标所在行代码，会根据当前不同文件类型使用不同的注释符号
Ctrl + F1	Command + F1	在光标所在的错误代码处显示错误信息
Ctrl + F11	Option + F3	选中文件 / 文件夹，使用助记符设定 / 取消书签
Ctrl + Space	Control + Space	基础代码补全，默认在 Windows 系统上被输入法占用，需要进行修改，建议修改为Ctrl + 逗号
Ctrl + Delete	Option + Fn + Delete	删除光标后面的单词或是中文句
Ctrl + BackSpace	Option + Delete	删除光标前面的单词或是中文句
Ctrl + 1,2,3…9	Control + 1,2,3…9	定位到对应数值的书签位置
Ctrl + 加号	Command + 加号	展开代码
Ctrl + 减号	Command + 减号	折叠代码
Ctrl + 左键单击	Control + 左键单击	在打开的文件标题上，弹出该文件路径
Ctrl + 左方向键	Option + 左方向键	光标跳转到当前单词 / 中文句的左侧开头位置
Ctrl + 右方向键	Option + 右方向键	光标跳转到当前单词 / 中文句的右侧开头位置
Ctrl + 前方向键	预设中没有该快捷键	等效于鼠标滚轮向前效果
Ctrl + 后方向键	预设中没有该快捷键	等效于鼠标滚轮向后效果

Win 快捷键	Mac 快捷键	介绍
Alt + `	Control + V	显示版本控制常用操作菜单弹出层
Alt + F1	Option + F1	显示当前文件选择目标弹出层，弹出层中有很多目标可以进行选择
Alt + F7	Option + F7	查询所选对象/变量被引用
Alt + Enter	Option + Enter	IntelliJ IDEA 根据光标所在问题，提供快速修复选择，光标放在的位置不同提示的结果也不同
Alt + Insert	Command + N	代码自动生成，如生成对象的 set / get 方法，构造函数，toString() 等
Alt + 左方向键	Control + 左方向键	切换当前已打开的窗口中的子视图，比如Debug窗口中有Output、Debugger等子视图，用此快捷键就可以在子视图中切换
Alt + 右方向键	Control + 右方向键	切换当前已打开的窗口中的子视图，比如Debug窗口中有Output、Debugger等子视图，用此快捷键就可以在子视图中切换
Alt + 前方向键	Control + 前方向键	当前光标跳转到当前文件的前一个方法名位置
Alt + 后方向键	Control + 后方向键	当前光标跳转到当前文件的后一个方法名位置
Alt + 1,2,3…9	Command + 1,2,3…9	显示对应数值的选项卡，其中 1 是 Project 用得最多
Win 快捷键	Mac 快捷键	介绍
Shift + F11	Command + F3	弹出书签显示层
Shift + Tab	Shift + Tab	取消缩进
Shift + Enter	Shift + Enter	开始新一行。光标所在行下空出一行，光标定位到新行位置
Shift + 左键单击	Shift + 左键单击	在打开的文件名上按此快捷键，可以关闭当前打开文件
Win 快捷键	Mac 快捷键	介绍
Ctrl + Alt + L	Command + Option + L	格式化代码，可以对当前文件和整个包目录使用
Ctrl + Alt + O	Control + Option + O	优化导入的类，可以对当前文件和整个包目录使用
Ctrl + Alt + T	Command + Option + T	对选中的代码弹出环绕选项弹出层
Ctrl + Alt + S	Command + 逗号	打开 IntelliJ IDEA 系统设置
Ctrl + Alt + Enter	Command + Option + Enter	光标所在行上空出一行，光标定位到新行
Ctrl + Alt + 左方向键	Command + Option + 左方向键	退回到上一个操作的地方
Ctrl + Alt + 右方向键	Command + Option + 右方向键	前进到上一个操作的地方

Win 快捷键	Mac 快捷键	介绍
Ctrl + Shift + F	Command + Shift + F	根据输入内容查找整个项目或指定目录内文件
Ctrl + Shift + R	Command + Shift + F	根据输入内容替换对应内容，范围为整个项目或指定目录内文件
Ctrl + Shift + J	Control + Shift + J	自动将下一行合并到当前行末尾
Ctrl + Shift + Z	Command + Shift + Z	取消撤销
Ctrl + Shift + W	Option + 方向键下	递进式取消选择代码块。可选中光标所在的单词或段落，连续按会在原有选中的基础上再扩展取消选中范围
Ctrl + Shift + N	Command + Shift + O	通过文件名定位 / 打开文件 / 目录，打开目录需要在输入的内容后面多加一个正斜杠
Ctrl + Shift + U	Command + Shift + U	对选中的代码进行大 / 小写轮流转换
Ctrl + Shift + T	Command + Shift + T	对当前类生成单元测试类，如果已经存在的单元测试类则可以进行选择
Ctrl + Shift + C	Command + Shift + C	复制当前文件磁盘路径到剪贴板
Ctrl + Shift + B	Control + Shift + B	跳转到类型声明处
Ctrl + Shift + /	Command + Option + /	代码块注释
Ctrl + Shift + [	Command + Shift + [	选中从光标所在位置到它的顶部中括号位置
Ctrl + Shift + ]	Command + Shift + ]	选中从光标所在位置到它的底部中括号位置
Ctrl + Shift + 加号	Command + Shift + 加号	展开所有代码
Ctrl + Shift + 减号	Command + Shift + 减号	折叠所有代码
Ctrl + Shift + F7	Command + Shift + F7	高亮显示所有该选中文本，按Esc高亮消失
Ctrl + Shift + F12	Command + Shift + F12	编辑器最大化
Ctrl + Shift + Enter	Command + Shift + Enter	自动结束代码，行末自动添加分号
Ctrl + Shift + Backspace	Ctrl + Shift + Backspace	退回到上次修改的地方
Ctrl + Shift + 1,2,3…9	Control + Shift + 1,2,3…9	快速添加指定数值的书签
Ctrl + Shift + 左键单击	Command + Shift + 左键单击	把光标放在某个类变量上，按此快捷键可以直接定位到该类中
Ctrl + Shift + 左方向键	Option + Shift + 左方向键	在代码文件上，光标跳转到当前单词 / 中文句的左侧开头位置，同时选中该单词 / 中文句
Ctrl + Shift + 右方向键	Option + Shift + 右方向键	在代码文件上，光标跳转到当前单词 / 中文句的右侧开头位置，同时选中该单词 / 中文句
Ctrl + Shift + 前方向键	Command + Shift + 前方向键	光标放在方法名上，将方法移动到上一个方法前面，调整方法排序
Ctrl + Shift + 后方向键	Command + Shift + 后方向键	光标放在方法名上，将方法移动到下一个方法前面，调整方法排序
Win 快捷键	Mac 快捷键	介绍
Alt + Shift + N	Option + Shift + B	选择 / 添加 task
Alt + Shift + 左键双击	Option + Shift + 左键双击	选择被双击的单词 / 中文句，按住不放，可以同时选择其他单词 / 中文句
Alt + Shift + 前方向键	Option + Shift + 前方向键	移动光标所在行向上移动
Alt + Shift + 后方向键	Option + Shift + 后方向键	移动光标所在行向下移动

Win 快捷键	Mac 快捷键	介绍
Ctrl + Shift + Alt + V	Command + Shift + Option + V	无格式黏贴
Ctrl + Shift + Alt + S	Command + ;	打开当前项目设置
Win 快捷键	Mac 快捷键	介绍
F2	F2	跳转到下一个高亮错误或警告位置
F4	F4	编辑源
F11	F3	添加书签
F12	F12	回到前一个工具窗口
Tab	Tab	缩进
ESC	ESC	从工具窗口进入代码文件窗口

About Me

Mon, 01 Jan 0001 00:00:00 +0000

CS major, currently working in software development, based in Nanjing.
Github Homepage
~~Java,Kotlin,JavaScript,Go,Python,C,C++ ,Rust, Swift;~~ | AI;
My Product: DevSwitcher2
Email: rivermao@outlook.com

Sponsor

Solana

GjKB96Tu2vb2trtUyDxM1JZqsz5d5oQvN7xHdRotqme3

📱 Scan & Send ⚡