java对称加密与非对称加密
2024-05-31 10:50:29
java对称加密与非对称加密
加密方式大致分为两种，对称加密和非对称加密。对称加密是最快速、最简单的一种加密方式，加密（encryption）与解密（decryption）用的是同样的密钥（secret key）。非对称加密为数据的加密与解密提供了一个非常安全的方法，它使用了一对密钥，公钥（public key）和私钥（private key）。私钥只能由一方安全保管，不能外泄，而公钥则可以发给任何请求它的人。因此安全性大大提高。
对称加密
所谓对称加密算法即：加密和解密使用相同密钥的算法。常见的有DES、3DES、AES、PBE等加密算法，这几种算法安全性依次是逐渐增强的。
DES加密
DES是一种对称加密算法，是一种非常简便的加密算法，但是密钥长度比较短。DES加密算法出自IBM的研究，后来被美国政府正式采用，之后开始广泛流传，但是近些年使用越来越少，因为DES使用56位密钥，以现代计算能力，24小时内即可被破解。虽然如此，在某些简单应用中，我们还是可以使用DES加密算法.简单的DES加密算法实现：
public class DESUtil {private static final String KEY_ALGORITHM = "DES";private static final String DEFAULT_CIPHER_ALGORITHM = "DES/ECB/PKCS5Padding";//默认的加密算法/*** DES 加密操作** @param content 待加密内容* @param key 加密密钥* @return 返回Base64转码后的加密数据*/public static String encrypt(String content, String key) {try {Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器byte[] byteContent = content.getBytes("utf-8");cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(key));// 初始化为加密模式的密码器byte[] result = cipher.doFinal(byteContent);// 加密return Base64.encodeBase64String(result);//通过Base64转码返回} catch (Exception ex) {Logger.getLogger(DESUtil.class.getName()).log(Level.SEVERE, null, ex);}return null;}/*** DES 解密操作** @param content* @param key* @return*/public static String decrypt(String content, String key) {try {//实例化Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);//使用密钥初始化，设置为解密模式cipher.init(Cipher.DECRYPT_MODE, getSecretKey(key));//执行操作byte[] result = cipher.doFinal(Base64.decodeBase64(content));return new String(result, "utf-8");} catch (Exception ex) {Logger.getLogger(DESUtil.class.getName()).log(Level.SEVERE, null, ex);}return null;}/*** 生成加密秘钥** @return*/private static SecretKeySpec getSecretKey(final String key) {//返回生成指定算法密钥生成器的 KeyGenerator 对象KeyGenerator kg = null;try {kg = KeyGenerator.getInstance(KEY_ALGORITHM);//DES 要求密钥长度为 56kg.init(56, new SecureRandom(key.getBytes()));//生成一个密钥SecretKey secretKey = kg.generateKey();return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为DES专用密钥} catch (NoSuchAlgorithmException ex) {Logger.getLogger(DESUtil.class.getName()).log(Level.SEVERE, null, ex);}return null;}public static void main(String[] args) {String content = "hello,您好";String key = "sde@5f98H*^hsff%dfs$r344&df8543*er";System.out.println("content:" + content);String s1 = DESUtil.encrypt(content, key);System.out.println("s1:" + s1);System.out.println("s2:"+ DESUtil.decrypt(s1, key));}}3DES加密
3DES是一种对称加密算法，在 DES 的基础上，使用三重数据加密算法，对数据进行加密，它相当于是对每个数据块应用三次 DES 加密算法。由于计算机运算能力的增强，原版 DES 密码的密钥长度变得容易被暴力破解；3DES 即是设计用来提供一种相对简单的方法，即通过增加 DES 的密钥长度来避免类似的攻击，而不是设计一种全新的块密码算法这样来说，破解的概率就小了很多。缺点由于使用了三重数据加密算法，可能会比较耗性能。简单的3DES加密算法实现：
public class TripDESUtil {private static final String KEY_ALGORITHM = "DESede";private static final String DEFAULT_CIPHER_ALGORITHM = "DESede/ECB/PKCS5Padding";//默认的加密算法/*** DESede 加密操作** @param content 待加密内容* @param key 加密密钥* @return 返回Base64转码后的加密数据*/public static String encrypt(String content, String key) {try {Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器byte[] byteContent = content.getBytes("utf-8");cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(key));// 初始化为加密模式的密码器byte[] result = cipher.doFinal(byteContent);// 加密return Base64.encodeBase64String(result);//通过Base64转码返回} catch (Exception ex) {Logger.getLogger(TripDESUtil.class.getName()).log(Level.SEVERE, null, ex);}return null;}/*** DESede 解密操作** @param content* @param key* @return*/public static String decrypt(String content, String key) {try {//实例化Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);//使用密钥初始化，设置为解密模式cipher.init(Cipher.DECRYPT_MODE, getSecretKey(key));//执行操作byte[] result = cipher.doFinal(Base64.decodeBase64(content));return new String(result, "utf-8");} catch (Exception ex) {Logger.getLogger(TripDESUtil.class.getName()).log(Level.SEVERE, null, ex);}return null;}/*** 生成加密秘钥** @return*/private static SecretKeySpec getSecretKey(final String key) {//返回生成指定算法密钥生成器的 KeyGenerator 对象KeyGenerator kg = null;try {kg = KeyGenerator.getInstance(KEY_ALGORITHM);//DESedekg.init(new SecureRandom(key.getBytes()));//生成一个密钥SecretKey secretKey = kg.generateKey();return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为DESede专用密钥} catch (NoSuchAlgorithmException ex) {Logger.getLogger(TripDESUtil.class.getName()).log(Level.SEVERE, null, ex);}return null;}public static void main(String[] args) {String content = "hello,您好";String key = "sde@5f98H*^hsff%dfs$r344&df8543*er";System.out.println("content:" + content);String s1 = TripDESUtil.encrypt(content, key);System.out.println("s1:" + s1);System.out.println("s2:"+ TripDESUtil.decrypt(s1, key));}}AES加密
AES是一种对称加密算法，在 DES 的基础上，使用三重数据加密算法，对数据进行加密，它相当于是对每个数据块应用三次 DES 加密算法。由于计算机运算能力的增强，原版 DES 密码的密钥长度变得容易被暴力破解；3DES 即是设计用来提供一种相对简单的方法，即通过增加 DES 的密钥长度来避免类似的攻击，而不是设计一种全新的块密码算法这样来说，破解的概率就小了很多。缺点由于使用了三重数据加密算法，可能会比较耗性能。简单的AES加密算法实现：
public class AESUtil {private static final String KEY_ALGORITHM = "AES";private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";//默认的加密算法/*** AES 加密操作** @param content 待加密内容* @param key 加密密钥* @return 返回Base64转码后的加密数据*/public static String encrypt(String content, String key) {try {Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器byte[] byteContent = content.getBytes("utf-8");cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(key));// 初始化为加密模式的密码器byte[] result = cipher.doFinal(byteContent);// 加密return Base64.encodeBase64String(result);//通过Base64转码返回} catch (Exception ex) {Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);}return null;}/*** AES 解密操作** @param content* @param key* @return*/public static String decrypt(String content, String key) {try {//实例化Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);//使用密钥初始化，设置为解密模式cipher.init(Cipher.DECRYPT_MODE, getSecretKey(key));//执行操作byte[] result = cipher.doFinal(Base64.decodeBase64(content));return new String(result, "utf-8");} catch (Exception ex) {Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);}return null;}/*** 生成加密秘钥** @return*/private static SecretKeySpec getSecretKey(final String key) {//返回生成指定算法密钥生成器的 KeyGenerator 对象KeyGenerator kg = null;try {kg = KeyGenerator.getInstance(KEY_ALGORITHM);//AES 要求密钥长度为 128kg.init(128, new SecureRandom(key.getBytes()));//生成一个密钥SecretKey secretKey = kg.generateKey();return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为AES专用密钥} catch (NoSuchAlgorithmException ex) {Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);}return null;}public static void main(String[] args) {String content = "hello,您好";String key = "sde@5f98H*^hsff%dfs$r344&df8543*er";System.out.println("content:" + content);String s1 = AESUtil.encrypt(content, key);System.out.println("s1:" + s1);System.out.println("s2:"+AESUtil.decrypt(s1, key));}}
非对称加密
非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。一般公钥是公开的，私钥是自己保存。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。安全性相对对称加密来说更高，是一种高级加密方式。
RSA加密
RSA是一种非对称加密算法.RSA有两个密钥，一个是公开的，称为公开密钥；一个是私密的，称为私密密钥。公开密钥是对大众公开的，私密密钥是服务器私有的，两者不能互推得出。用公开密钥对数据进行加密，私密密钥可解密；私密密钥对数据加密，公开密钥可解密。速度较对称加密慢。简单的RSA加密算法实现：
/*** <p>* RSA公钥/私钥/签名工具包* </p>* <p>* 罗纳德·李维斯特（Ron [R]ivest）、阿迪·萨莫尔（Adi [S]hamir）和伦纳德·阿德曼（Leonard [A]dleman）* </p>* <p>* 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/>* 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，<br/>* 非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据的安全* </p>** @author IceWee* @date 2012-4-26* @version 1.0*/
public class RSAUtils {/*** 加密算法RSA*/public static final String KEY_ALGORITHM = "RSA";/*** 签名算法*/public static final String SIGNATURE_ALGORITHM = "MD5withRSA";/*** 获取公钥的key*/private static final String PUBLIC_KEY = "RSAPublicKey";/*** 获取私钥的key*/private static final String PRIVATE_KEY = "RSAPrivateKey";/*** RSA最大加密明文大小*/private static final int MAX_ENCRYPT_BLOCK = 117;/*** RSA最大解密密文大小*/private static final int MAX_DECRYPT_BLOCK = 128;/*** <p>* 生成密钥对(公钥和私钥)* </p>** @return* @throws Exception*/public static Map<String, Object> genKeyPair() throws Exception {KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);keyPairGen.initialize(1024);KeyPair keyPair = keyPairGen.generateKeyPair();RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();Map<String, Object> keyMap = new HashMap<String, Object>(2);keyMap.put(PUBLIC_KEY, publicKey);keyMap.put(PRIVATE_KEY, privateKey);return keyMap;}/*** <p>* 用私钥对信息生成数字签名* </p>** @param data 已加密数据* @param privateKey 私钥(BASE64编码)** @return* @throws Exception*/public static String sign(byte[] data, String privateKey) throws Exception {byte[] keyBytes = Base64Utils.decode(privateKey);PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);signature.initSign(privateK);signature.update(data);return Base64Utils.encode(signature.sign());}/*** <p>* 校验数字签名* </p>** @param data 已加密数据* @param publicKey 公钥(BASE64编码)* @param sign 数字签名** @return* @throws Exception**/public static boolean verify(byte[] data, String publicKey, String sign)throws Exception {byte[] keyBytes = Base64Utils.decode(publicKey);X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);PublicKey publicK = keyFactory.generatePublic(keySpec);Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);signature.initVerify(publicK);signature.update(data);return signature.verify(Base64Utils.decode(sign));}/*** <P>* 私钥解密* </p>** @param encryptedData 已加密数据* @param privateKey 私钥(BASE64编码)* @return* @throws Exception*/public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)throws Exception {byte[] keyBytes = Base64Utils.decode(privateKey);PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());cipher.init(Cipher.DECRYPT_MODE, privateK);int inputLen = encryptedData.length;ByteArrayOutputStream out = new ByteArrayOutputStream();int offSet = 0;byte[] cache;int i = 0;// 对数据分段解密while (inputLen - offSet > 0) {if (inputLen - offSet > MAX_DECRYPT_BLOCK) {cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);} else {cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);}out.write(cache, 0, cache.length);i++;offSet = i * MAX_DECRYPT_BLOCK;}byte[] decryptedData = out.toByteArray();out.close();return decryptedData;}/*** <p>* 公钥解密* </p>** @param encryptedData 已加密数据* @param publicKey 公钥(BASE64编码)* @return* @throws Exception*/public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)throws Exception {byte[] keyBytes = Base64Utils.decode(publicKey);X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);Key publicK = keyFactory.generatePublic(x509KeySpec);Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());cipher.init(Cipher.DECRYPT_MODE, publicK);int inputLen = encryptedData.length;ByteArrayOutputStream out = new ByteArrayOutputStream();int offSet = 0;byte[] cache;int i = 0;// 对数据分段解密while (inputLen - offSet > 0) {if (inputLen - offSet > MAX_DECRYPT_BLOCK) {cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);} else {cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);}out.write(cache, 0, cache.length);i++;offSet = i * MAX_DECRYPT_BLOCK;}byte[] decryptedData = out.toByteArray();out.close();return decryptedData;}/*** <p>* 公钥加密* </p>** @param data 源数据* @param publicKey 公钥(BASE64编码)* @return* @throws Exception*/public static byte[] encryptByPublicKey(byte[] data, String publicKey)throws Exception {byte[] keyBytes = Base64Utils.decode(publicKey);X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);Key publicK = keyFactory.generatePublic(x509KeySpec);// 对数据加密Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());cipher.init(Cipher.ENCRYPT_MODE, publicK);int inputLen = data.length;ByteArrayOutputStream out = new ByteArrayOutputStream();int offSet = 0;byte[] cache;int i = 0;// 对数据分段加密while (inputLen - offSet > 0) {if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);} else {cache = cipher.doFinal(data, offSet, inputLen - offSet);}out.write(cache, 0, cache.length);i++;offSet = i * MAX_ENCRYPT_BLOCK;}byte[] encryptedData = out.toByteArray();out.close();return encryptedData;}/*** <p>* 私钥加密* </p>** @param data 源数据* @param privateKey 私钥(BASE64编码)* @return* @throws Exception*/public static byte[] encryptByPrivateKey(byte[] data, String privateKey)throws Exception {byte[] keyBytes = Base64Utils.decode(privateKey);PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());cipher.init(Cipher.ENCRYPT_MODE, privateK);int inputLen = data.length;ByteArrayOutputStream out = new ByteArrayOutputStream();int offSet = 0;byte[] cache;int i = 0;// 对数据分段加密while (inputLen - offSet > 0) {if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);} else {cache = cipher.doFinal(data, offSet, inputLen - offSet);}out.write(cache, 0, cache.length);i++;offSet = i * MAX_ENCRYPT_BLOCK;}byte[] encryptedData = out.toByteArray();out.close();return encryptedData;}/*** <p>* 获取私钥* </p>** @param keyMap 密钥对* @return* @throws Exception*/public static String getPrivateKey(Map<String, Object> keyMap)throws Exception {Key key = (Key) keyMap.get(PRIVATE_KEY);return Base64Utils.encode(key.getEncoded());}/*** <p>* 获取公钥* </p>** @param keyMap 密钥对* @return* @throws Exception*/public static String getPublicKey(Map<String, Object> keyMap)throws Exception {Key key = (Key) keyMap.get(PUBLIC_KEY);return Base64Utils.encode(key.getEncoded());}}public class Base64Utils {/*** 文件读取缓冲区大小*/private static final int CACHE_SIZE = 1024;/*** <p>* BASE64字符串解码为二进制数据* </p>** @param base64* @return* @throws Exception*/public static byte[] decode(String base64) throws Exception {return Base64.decode(base64.getBytes());}/*** <p>* 二进制数据编码为BASE64字符串* </p>** @param bytes* @return* @throws Exception*/public static String encode(byte[] bytes) throws Exception {return new String(Base64.encode(bytes));}/*** <p>* 将文件编码为BASE64字符串* </p>* <p>* 大文件慎用，可能会导致内存溢出* </p>** @param filePath* 文件绝对路径* @return* @throws Exception*/public static String encodeFile(String filePath) throws Exception {byte[] bytes = fileToByte(filePath);return encode(bytes);}/*** <p>* BASE64字符串转回文件* </p>** @param filePath* 文件绝对路径* @param base64* 编码字符串* @throws Exception*/public static void decodeToFile(String filePath, String base64) throws Exception {byte[] bytes = decode(base64);byteArrayToFile(bytes, filePath);}/*** <p>* 文件转换为二进制数组* </p>** @param filePath* 文件路径* @return* @throws Exception*/public static byte[] fileToByte(String filePath) throws Exception {byte[] data = new byte[0];File file = new File(filePath);if (file.exists()) {FileInputStream in = new FileInputStream(file);ByteArrayOutputStream out = new ByteArrayOutputStream(2048);byte[] cache = new byte[CACHE_SIZE];int nRead = 0;while ((nRead = in.read(cache)) != -1) {out.write(cache, 0, nRead);out.flush();}out.close();in.close();data = out.toByteArray();}return data;}/*** <p>* 二进制数据写文件* </p>** @param bytes* 二进制数据* @param filePath* 文件生成目录*/public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception {InputStream in = new ByteArrayInputStream(bytes);File destFile = new File(filePath);if (!destFile.getParentFile().exists()) {destFile.getParentFile().mkdirs();}destFile.createNewFile();OutputStream out = new FileOutputStream(destFile);byte[] cache = new byte[CACHE_SIZE];int nRead = 0;while ((nRead = in.read(cache)) != -1) {out.write(cache, 0, nRead);out.flush();}out.close();in.close();}}
java对称加密与非对称加密相关推荐
- Java安全之对称加密、非对称加密、数字签名
Java中加密分为两种方式一个是对称加密,另一个是非对称加密.对称加密是因为加密和解密的钥匙相同,而非对称加密是加密和解密的钥匙不同. 对称加密与非对称加密的区别: 对称加密称为密钥加密,速度快,但加 ...
- 基于Java Cipher封装通用对称加密、非对称加密、数字信封
背景:与第三方交互经常会使用加密.验签等安全策略.有的加密工具由第三方提供,有的提供算法等参数自己开发,为减少加密等功能的开发工作量,决定封装一个通用的加解密工具. 1. 名词解释 1.1. 对称加密 ...
- 对称加密、非对称加密深度解析
密码学的发展 加密的发展史随着人类的进化逐步复杂.严谨也更安全,对于早期的移位和字母对应等加密方式我们不难理解. 移位 : 比如恺撒密码, 简单点说将 26个英文字母的顺序打乱,得到一个新的字母顺序, ...
- 对称加密和非对称加密原理
对称加密和非对称加密原理 私钥加密(对称加密 symmetric cryptography):私钥加密算法使用单个私钥来加密和解密数据.由于具有密钥的任意一方都可以使用该密钥解密数据,因此必须保护密钥 ...
- 安全HTTPS-全面详解对称加密，非对称加密，数字签名，数字证书和HTTPS
一,对称加密 所谓对称加密,就是它们在编码时使用的密钥e和解码时一样d(e=d),我们就将其统称为密钥k. 对称加解密的过程如下: 发送端和接收端首先要共享相同的密钥k(即通信前双方都需要知道对应的密 ...
- 对称加密、非对称加密、数字签名、消息摘要的简单学习
对称加密.非对称加密.数字签名.消息摘要的简单学习 前言 对称加密算法 DES 特点: 为什么不使用: 3DES(Triple DES 或者 DESede) 特点: 使用场景: 为什么不用: AES( ...
- 加解密基础——（对称加密、非对称加密和混合加密）
本文对之前学习过的加解密相关知识做一简单总结,以备后用. 1. 基本概念 加密算法 通常是复杂的数学公式,这些公式确定如何将明文转化为密文的过程和规则. 密钥 是一串被加入到算法中的随机比特. 待续 ...
- 对称加密和非对称加密介绍和区别
什么是对称加密技术? 对称加密采用了对称密码编码技术,它的特点是文件加密和解密使用相同的密钥,即加密密钥也可以用作解密密钥,这种方法在密码学中叫做对称加密算法,对称加密算法使用起来简单快捷,密钥较短, ...
- 【上】安全HTTPS-全面详解对称加密，非对称加密，数字签名，数字证书和HTTPS
此文章转载来源于http://blog.csdn.net/tenfyguo/article/details/40922813点击打开链接 一,对称加密 所谓对称加密,就是它们在编码时使用的密钥e和解码 ...
最新文章
- java Map 怎么遍历
- Intervals on the Ring 环状数轴区间-模数-构造-区间交并集
- [学习笔记]带修改主席树
- html type=text/css,type=text/css 有什么用啊 ？
- php str_replice_详解PHP字符串替换str_replace()函数四种用法
- CloudIDE插件开发实战：教你如何调试代码
- C/C++库函数math用法案例篇一
- .NET程序中常用的28种代码
- 设计模式GOF23之工厂模式01
- no symbol version section for versioned symbol `memcpy@GLIBC_2.4'
- 【Matlab】滤波函数
- 句法分析 依存句法分析
- iOS adhoc ipa 安装
- 用Java输出高频词_高频词汇提取的Java实现
- My 2007 Fash game: Elite Shooter
- magic3是鸿蒙系统吗,如果荣耀Magic3搭载屏下镜头和鸿蒙系统，你会做第一批吗？...
- ArcGIS Pro教程 | 1#数据准备
- 几款常见的数学教学软件
- 7080生化分析仪使用说明书—— 测定原理篇
- 打造高逼格的开发利器，让你的代码敲出打字机的效果，甚至更……