RSA工具类，可以直接使用的有不足之处还请见谅

这是RSA工具类，可以使用 

/**
 * RSA加密工具类
 * <p>
 * Create by Mazhanzhu on 2019/8/10
 */
public class RSAUtils {
    private static final String TAG = "RSAUtils";
    public static final String KEY_ALGORITHM = "RSA";
    public static final String split = " ";// 分隔符
    public static final int max = 117;// 加密分段长度//不可超过117
    
    private static RSAUtils me;

    private RSAUtils() {
    }// 单例

    public static RSAUtils create() {
        if (me == null) {
            me = new RSAUtils();
        }
        try {
            //随机生成公钥、私钥，这里只是演示使用，实际使用中，只生成一次就好
            KeyPairGenerator kpg = KeyPairGenerator.getInstance(KEY_ALGORITHM);
            kpg.initialize(1024);
            KeyPair kp = kpg.generateKeyPair();
            me.publicKey = (RSAPublicKey) kp.getPublic();
            me.privateKey = (RSAPrivateCrtKey) kp.getPrivate();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return me;
    }

    private RSAPublicKey publicKey;
    private RSAPrivateCrtKey privateKey;

    /**
     * 获取公钥
     */
    public String getPublicKey() {
        return parseByte2HexStr(publicKey.getEncoded());
    }

    /**
     * 获取私钥
     */
    public String getPrivateKey() {
        return parseByte2HexStr(privateKey.getEncoded());
    }

    /**
     * 加密-公钥
     */
    public String encodeByPublicKey(String res, String key) {
        byte[] resBytes = res.getBytes();
        byte[] keyBytes = parseHexStr2Byte(key);// 先把公钥转为2进制
        StringBuffer result = new StringBuffer();// 结果
        // 如果超过了100个字节就分段
        if (keyBytes.length <= max) {// 不超过直接返回即可
            return encodePub(resBytes, keyBytes);
        } else {
            int size = resBytes.length / max
                    + (resBytes.length % max > 0 ? 1 : 0);
            for (int i = 0; i < size; i++) {
                int len = i == size - 1 ? resBytes.length % max : max;
                byte[] bs = new byte[len];// 临时数组
                System.arraycopy(resBytes, i * max, bs, 0, len);
                result.append(encodePub(bs, keyBytes));
                if (i != size - 1)
                    result.append(split);
            }
            return result.toString();
        }
    }

    /**
     * 加密-私钥
     */
    public String encodeByPrivateKey(String res, String key) {
        byte[] resBytes = res.getBytes();
        byte[] keyBytes = parseHexStr2Byte(key);
        StringBuffer result = new StringBuffer();
        // 如果超过了100个字节就分段
        if (keyBytes.length <= max) {// 不超过直接返回即可
            return encodePri(resBytes, keyBytes);
        } else {
            int size = resBytes.length / max
                    + (resBytes.length % max > 0 ? 1 : 0);
            for (int i = 0; i < size; i++) {
                int len = i == size - 1 ? resBytes.length % max : max;
                byte[] bs = new byte[len];// 临时数组
                System.arraycopy(resBytes, i * max, bs, 0, len);
                result.append(encodePri(bs, keyBytes));
                if (i != size - 1)
                    result.append(split);
            }
            return result.toString();
        }
    }

    /**
     * 解密-公钥
     */
    public String decodeByPublicKey(String res, String key) {
        byte[] keyBytes = parseHexStr2Byte(key);
        // 先分段
        String[] rs = res.split("\\" + split);
        // 分段解密
        if (rs != null) {
            int len = 0;
            // 组合byte[]
            byte[] result = new byte[rs.length * max];
            for (int i = 0; i < rs.length; i++) {
                byte[] bs = decodePub(parseHexStr2Byte(rs[i]), keyBytes);
                System.arraycopy(bs, 0, result, i * max, bs.length);
                len += bs.length;
            }
            byte[] newResult = new byte[len];
            System.arraycopy(result, 0, newResult, 0, len);
            // 还原字符串
            return new String(newResult);
        }
        return null;
    }

    /**
     * 解密-私钥
     */
    public String decodeByPrivateKey(String res, String key) {
        byte[] keyBytes = parseHexStr2Byte(key);
        // 先分段
        String[] rs = res.split("\\" + split);
        // 分段解密
        if (rs != null) {
            int len = 0;
            // 组合byte[]
            byte[] result = new byte[rs.length * max];
            for (int i = 0; i < rs.length; i++) {
                byte[] bs = decodePri(parseHexStr2Byte(rs[i]), keyBytes);
                System.arraycopy(bs, 0, result, i * max, bs.length);
                len += bs.length;
            }
            byte[] newResult = new byte[len];
            System.arraycopy(result, 0, newResult, 0, len);
            // 还原字符串
            return new String(newResult);
        }
        return null;
    }

    /**
     * 将二进制转换成16进制
     */
    public static String parseByte2HexStr(byte buf[]) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < buf.length; i++) {
            String hex = Integer.toHexString(buf[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            sb.append(hex.toUpperCase());
        }
        return sb.toString();
    }

    /**
     * 将16进制转换为二进制
     */
    public static byte[] parseHexStr2Byte(String hexStr) {
        if (hexStr.length() < 1)
            return null;
        byte[] result = new byte[hexStr.length() / 2];
        for (int i = 0; i < hexStr.length() / 2; i++) {
            int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
            int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2),
                    16);
            result[i] = (byte) (high * 16 + low);
        }
        return result;
    }

    /**
     * 加密-公钥-无分段
     */
    private String encodePub(byte[] res, byte[] keyBytes) {
        X509EncodedKeySpec x5 = new X509EncodedKeySpec(keyBytes);// 用2进制的公钥生成x509
        try {
            KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM);
            Key pubKey = kf.generatePublic(x5);// 用KeyFactory把x509生成公钥pubKey
            Cipher cp = Cipher.getInstance(kf.getAlgorithm());// 生成相应的Cipher
            cp.init(Cipher.ENCRYPT_MODE, pubKey);// 给cipher初始化为加密模式，以及传入公钥pubKey
            return parseByte2HexStr(cp.doFinal(res));// 以16进制的字符串返回
        } catch (Exception e) {
            System.out.println("公钥加密失败");
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 加密-私钥-无分段
     */
    private String encodePri(byte[] res, byte[] keyBytes) {
        PKCS8EncodedKeySpec pk8 = new PKCS8EncodedKeySpec(keyBytes);
        try {
            KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM);
            Key priKey = kf.generatePrivate(pk8);
            Cipher cp = Cipher.getInstance(kf.getAlgorithm());
            cp.init(Cipher.ENCRYPT_MODE, priKey);
            return parseByte2HexStr(cp.doFinal(res));
        } catch (Exception e) {
            System.out.println("私钥加密失败");
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 解密-公钥-无分段
     */
    private byte[] decodePub(byte[] res, byte[] keyBytes) {
        X509EncodedKeySpec x5 = new X509EncodedKeySpec(keyBytes);
        try {
            KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM);
            Key pubKey = kf.generatePublic(x5);
            Cipher cp = Cipher.getInstance(kf.getAlgorithm());
            cp.init(Cipher.DECRYPT_MODE, pubKey);
            return cp.doFinal(res);
        } catch (Exception e) {
            System.out.println("公钥解密失败");
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 解密-私钥-无分段
     */
    private byte[] decodePri(byte[] res, byte[] keyBytes) {
        PKCS8EncodedKeySpec pk8 = new PKCS8EncodedKeySpec(keyBytes);
        try {
            KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM);
            Key priKey = kf.generatePrivate(pk8);
            Cipher cp = Cipher.getInstance(kf.getAlgorithm());
            cp.init(Cipher.DECRYPT_MODE, priKey);
            return cp.doFinal(res);
        } catch (Exception e) {
            System.out.println("私钥解密失败");
            e.printStackTrace();
        }
        return null;
    }
}