这个问题其实在Java里有很直接的解决思路——核心就是利用RSA的加签验签（或加密解密）特性：如果一对公私钥能完成完整的签名-验证流程（或者加密-解密流程），那它们就是有效的、互相匹配的。下面分两部分具体说：

一、验证RSA公私钥对的有效性 #

最可靠的方式是用私钥对一段随机数据签名，再用公钥验证签名是否有效。如果整个流程无异常且验证通过，就说明密钥对是有效的。

示例代码： #

import java.security.*;
import java.util.Base64;

public class RSAKeyValidator {
    public static boolean validateKeyPair(PrivateKey privateKey, PublicKey publicKey) {
        try {
            // 选择签名算法，这里用SHA256withRSA（安全性较高且兼容性好）
            Signature signature = Signature.getInstance("SHA256withRSA");
            
            // 用私钥初始化签名对象
            signature.initSign(privateKey);
            // 准备一段测试数据（随便什么内容都可以，只要前后一致）
            byte[] testData = "Test data for RSA key validation".getBytes();
            signature.update(testData);
            // 生成签名
            byte[] signedData = signature.sign();
            
            // 用公钥初始化验证对象
            signature.initVerify(publicKey);
            signature.update(testData);
            // 验证签名是否有效
            return signature.verify(signedData);
            
        } catch (NoSuchAlgorithmException | InvalidKeyException | SignatureException e) {
            // 出现异常说明密钥无效（比如格式错误、算法不匹配、密钥本身损坏）
            e.printStackTrace();
            return false;
        }
    }

    // 测试用：生成一对临时密钥对验证逻辑是否可行
    public static void main(String[] args) throws NoSuchAlgorithmException {
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
        keyGen.initialize(2048); // 生成2048位的密钥对
        KeyPair keyPair = keyGen.generateKeyPair();
        
        boolean isValid = validateKeyPair(keyPair.getPrivate(), keyPair.getPublic());
        System.out.println("密钥对是否有效？" + isValid); // 正常情况会输出true
    }
}

二、验证本地.key私钥文件与.pub公钥文件是否匹配 #

实际场景中，我们通常是读取本地的PEM格式密钥文件（比如private.key和public.pub），需要先把文件内容转换成Java能识别的PrivateKey和PublicKey对象，再用上面的方法验证。

步骤1：读取并解析PEM格式的密钥文件 #

PEM格式的密钥会有类似-----BEGIN RSA PRIVATE KEY-----和-----END RSA PRIVATE KEY-----的页眉页脚，需要先去掉这些行，再对剩余的Base64编码内容解码。

读取私钥文件的方法：

import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.KeyFactory;

public static PrivateKey loadPrivateKeyFromFile(String filePath) throws Exception {
    String keyContent = new String(Files.readAllBytes(Paths.get(filePath)));
    // 去掉PKCS#1格式的页眉页脚（如果是PKCS#8格式则是BEGIN PRIVATE KEY）
    keyContent = keyContent.replace("-----BEGIN RSA PRIVATE KEY-----", "")
                           .replace("-----END RSA PRIVATE KEY-----", "")
                           .replaceAll("\\s", ""); // 去掉所有空白字符（换行、空格等）
    
    byte[] decodedKey = Base64.getDecoder().decode(keyContent);
    KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    // PKCS#8格式的私钥用PKCS8EncodedKeySpec解析
    PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedKey);
    return keyFactory.generatePrivate(keySpec);
}

读取公钥文件的方法：

import java.security.spec.X509EncodedKeySpec;

public static PublicKey loadPublicKeyFromFile(String filePath) throws Exception {
    String keyContent = new String(Files.readAllBytes(Paths.get(filePath)));
    keyContent = keyContent.replace("-----BEGIN PUBLIC KEY-----", "")
                           .replace("-----END PUBLIC KEY-----", "")
                           .replaceAll("\\s", "");
    
    byte[] decodedKey = Base64.getDecoder().decode(keyContent);
    KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodedKey);
    return keyFactory.generatePublic(keySpec);
}

步骤2：验证文件中的密钥是否匹配 #

把上面的方法结合起来，就可以验证本地文件的密钥对了：

public static void main(String[] args) {
    try {
        PrivateKey privateKey = loadPrivateKeyFromFile("path/to/your/private.key");
        PublicKey publicKey = loadPublicKeyFromFile("path/to/your/public.pub");
        
        boolean isMatched = validateKeyPair(privateKey, publicKey);
        System.out.println("私钥与公钥是否匹配？" + isMatched);
    } catch (Exception e) {
        e.printStackTrace();
        System.out.println("密钥文件读取或验证失败");
    }
}

注意事项： #

• 如果你的私钥是PKCS#1格式（页眉是BEGIN RSA PRIVATE KEY），JDK自带的PKCS8EncodedKeySpec无法直接解析，这时候可以：
  1. 用OpenSSL转换格式：openssl pkcs8 -topk8 -inform PEM -in private.key -outform PEM -nocrypt
  2. 引入BouncyCastle库，用它的PKCS1EncodedKeySpec来解析
• 密钥长度建议至少2048位，1024位已经不再安全

内容的提问来源于stack exchange，提问作者Aravind S