加密解密相关→EncryptUtils

2023-11-06



	import android.util.Base64;

	import java.io.File;
	import java.io.FileInputStream;
	import java.io.IOException;
	import java.security.DigestInputStream;
	import java.security.InvalidKeyException;
	import java.security.MessageDigest;
	import java.security.NoSuchAlgorithmException;
	import java.security.SecureRandom;

	import javax.crypto.Cipher;
	import javax.crypto.Mac;
	import javax.crypto.spec.SecretKeySpec;

	/**
	* <pre>
	* author: Blankj
	* blog : http://blankj.com
	* time : 2016/8/2
	* desc : 加密解密相关的工具类
	* </pre>
	*/
	public final class EncryptUtils {

	private EncryptUtils() {
	throw new UnsupportedOperationException("u can't instantiate me...");
	}

	/********************* 哈希加密相关 *********************/
	/**
	* MD2加密
	*
	* @param data 明文字符串
	* @return 16进制密文
	*/
	public static String encryptMD2ToString(String data) {
	return encryptMD2ToString(data.getBytes());
	}

	/**
	* MD2加密
	*
	* @param data 明文字节数组
	* @return 16进制密文
	*/
	public static String encryptMD2ToString(byte[] data) {
	return bytes2HexString(encryptMD2(data));
	}

	/**
	* MD2加密
	*
	* @param data 明文字节数组
	* @return 密文字节数组
	*/
	public static byte[] encryptMD2(byte[] data) {
	return hashTemplate(data, "MD2");
	}

	/**
	* MD5加密
	*
	* @param data 明文字符串
	* @return 16进制密文
	*/
	public static String encryptMD5ToString(String data) {
	return encryptMD5ToString(data.getBytes());
	}

	/**
	* MD5加密
	*
	* @param data 明文字符串
	* @param salt 盐
	* @return 16进制加盐密文
	*/
	public static String encryptMD5ToString(String data, String salt) {
	return bytes2HexString(encryptMD5((data + salt).getBytes()));
	}

	/**
	* MD5加密
	*
	* @param data 明文字节数组
	* @return 16进制密文
	*/
	public static String encryptMD5ToString(byte[] data) {
	return bytes2HexString(encryptMD5(data));
	}

	/**
	* MD5加密
	*
	* @param data 明文字节数组
	* @param salt 盐字节数组
	* @return 16进制加盐密文
	*/
	public static String encryptMD5ToString(byte[] data, byte[] salt) {
	if (data == null \|\| salt == null) return null;
	byte[] dataSalt = new byte[data.length + salt.length];
	System.arraycopy(data, 0, dataSalt, 0, data.length);
	System.arraycopy(salt, 0, dataSalt, data.length, salt.length);
	return bytes2HexString(encryptMD5(dataSalt));
	}

	/**
	* MD5加密
	*
	* @param data 明文字节数组
	* @return 密文字节数组
	*/
	public static byte[] encryptMD5(byte[] data) {
	return hashTemplate(data, "MD5");
	}

	/**
	* MD5加密文件
	*
	* @param filePath 文件路径
	* @return 文件的16进制密文
	*/
	public static String encryptMD5File2String(String filePath) {
	File file = isSpace(filePath) ? null : new File(filePath);
	return encryptMD5File2String(file);
	}

	/**
	* MD5加密文件
	*
	* @param filePath 文件路径
	* @return 文件的MD5校验码
	*/
	public static byte[] encryptMD5File(String filePath) {
	File file = isSpace(filePath) ? null : new File(filePath);
	return encryptMD5File(file);
	}

	/**
	* MD5加密文件
	*
	* @param file 文件
	* @return 文件的16进制密文
	*/
	public static String encryptMD5File2String(File file) {
	return bytes2HexString(encryptMD5File(file));
	}

	/**
	* MD5加密文件
	*
	* @param file 文件
	* @return 文件的MD5校验码
	*/
	public static byte[] encryptMD5File(File file) {
	if (file == null) return null;
	FileInputStream fis = null;
	DigestInputStream digestInputStream;
	try {
	fis = new FileInputStream(file);
	MessageDigest md = MessageDigest.getInstance("MD5");
	digestInputStream = new DigestInputStream(fis, md);
	byte[] buffer = new byte[256 * 1024];
	while (digestInputStream.read(buffer) > 0) ;
	md = digestInputStream.getMessageDigest();
	return md.digest();
	} catch (NoSuchAlgorithmException \| IOException e) {
	e.printStackTrace();
	return null;
	} finally {
	CloseUtils.closeIO(fis);
	}
	}

	/**
	* SHA1加密
	*
	* @param data 明文字符串
	* @return 16进制密文
	*/
	public static String encryptSHA1ToString(String data) {
	return encryptSHA1ToString(data.getBytes());
	}

	/**
	* SHA1加密
	*
	* @param data 明文字节数组
	* @return 16进制密文
	*/
	public static String encryptSHA1ToString(byte[] data) {
	return bytes2HexString(encryptSHA1(data));
	}

	/**
	* SHA1加密
	*
	* @param data 明文字节数组
	* @return 密文字节数组
	*/
	public static byte[] encryptSHA1(byte[] data) {
	return hashTemplate(data, "SHA1");
	}

	/**
	* SHA224加密
	*
	* @param data 明文字符串
	* @return 16进制密文
	*/
	public static String encryptSHA224ToString(String data) {
	return encryptSHA224ToString(data.getBytes());
	}

	/**
	* SHA224加密
	*
	* @param data 明文字节数组
	* @return 16进制密文
	*/
	public static String encryptSHA224ToString(byte[] data) {
	return bytes2HexString(encryptSHA224(data));
	}

	/**
	* SHA224加密
	*
	* @param data 明文字节数组
	* @return 密文字节数组
	*/
	public static byte[] encryptSHA224(byte[] data) {
	return hashTemplate(data, "SHA224");
	}

	/**
	* SHA256加密
	*
	* @param data 明文字符串
	* @return 16进制密文
	*/
	public static String encryptSHA256ToString(String data) {
	return encryptSHA256ToString(data.getBytes());
	}

	/**
	* SHA256加密
	*
	* @param data 明文字节数组
	* @return 16进制密文
	*/
	public static String encryptSHA256ToString(byte[] data) {
	return bytes2HexString(encryptSHA256(data));
	}

	/**
	* SHA256加密
	*
	* @param data 明文字节数组
	* @return 密文字节数组
	*/
	public static byte[] encryptSHA256(byte[] data) {
	return hashTemplate(data, "SHA256");
	}

	/**
	* SHA384加密
	*
	* @param data 明文字符串
	* @return 16进制密文
	*/
	public static String encryptSHA384ToString(String data) {
	return encryptSHA384ToString(data.getBytes());
	}

	/**
	* SHA384加密
	*
	* @param data 明文字节数组
	* @return 16进制密文
	*/
	public static String encryptSHA384ToString(byte[] data) {
	return bytes2HexString(encryptSHA384(data));
	}

	/**
	* SHA384加密
	*
	* @param data 明文字节数组
	* @return 密文字节数组
	*/
	public static byte[] encryptSHA384(byte[] data) {
	return hashTemplate(data, "SHA384");
	}

	/**
	* SHA512加密
	*
	* @param data 明文字符串
	* @return 16进制密文
	*/
	public static String encryptSHA512ToString(String data) {
	return encryptSHA512ToString(data.getBytes());
	}

	/**
	* SHA512加密
	*
	* @param data 明文字节数组
	* @return 16进制密文
	*/
	public static String encryptSHA512ToString(byte[] data) {
	return bytes2HexString(encryptSHA512(data));
	}

	/**
	* SHA512加密
	*
	* @param data 明文字节数组
	* @return 密文字节数组
	*/
	public static byte[] encryptSHA512(byte[] data) {
	return hashTemplate(data, "SHA512");
	}

	/**
	* hash加密模板
	*
	* @param data 数据
	* @param algorithm 加密算法
	* @return 密文字节数组
	*/
	private static byte[] hashTemplate(byte[] data, String algorithm) {
	if (data == null \|\| data.length <= 0) return null;
	try {
	MessageDigest md = MessageDigest.getInstance(algorithm);
	md.update(data);
	return md.digest();
	} catch (NoSuchAlgorithmException e) {
	e.printStackTrace();
	return null;
	}
	}

	/**
	* HmacMD5加密
	*
	* @param data 明文字符串
	* @param key 秘钥
	* @return 16进制密文
	*/
	public static String encryptHmacMD5ToString(String data, String key) {
	return encryptHmacMD5ToString(data.getBytes(), key.getBytes());
	}

	/**
	* HmacMD5加密
	*
	* @param data 明文字节数组
	* @param key 秘钥
	* @return 16进制密文
	*/
	public static String encryptHmacMD5ToString(byte[] data, byte[] key) {
	return bytes2HexString(encryptHmacMD5(data, key));
	}

	/**
	* HmacMD5加密
	*
	* @param data 明文字节数组
	* @param key 秘钥
	* @return 密文字节数组
	*/
	public static byte[] encryptHmacMD5(byte[] data, byte[] key) {
	return hmacTemplate(data, key, "HmacMD5");
	}

	/**
	* HmacSHA1加密
	*
	* @param data 明文字符串
	* @param key 秘钥
	* @return 16进制密文
	*/
	public static String encryptHmacSHA1ToString(String data, String key) {
	return encryptHmacSHA1ToString(data.getBytes(), key.getBytes());
	}

	/**
	* HmacSHA1加密
	*
	* @param data 明文字节数组
	* @param key 秘钥
	* @return 16进制密文
	*/
	public static String encryptHmacSHA1ToString(byte[] data, byte[] key) {
	return bytes2HexString(encryptHmacSHA1(data, key));
	}

	/**
	* HmacSHA1加密
	*
	* @param data 明文字节数组
	* @param key 秘钥
	* @return 密文字节数组
	*/
	public static byte[] encryptHmacSHA1(byte[] data, byte[] key) {
	return hmacTemplate(data, key, "HmacSHA1");
	}

	/**
	* HmacSHA224加密
	*
	* @param data 明文字符串
	* @param key 秘钥
	* @return 16进制密文
	*/
	public static String encryptHmacSHA224ToString(String data, String key) {
	return encryptHmacSHA224ToString(data.getBytes(), key.getBytes());
	}

	/**
	* HmacSHA224加密
	*
	* @param data 明文字节数组
	* @param key 秘钥
	* @return 16进制密文
	*/
	public static String encryptHmacSHA224ToString(byte[] data, byte[] key) {
	return bytes2HexString(encryptHmacSHA224(data, key));
	}

	/**
	* HmacSHA224加密
	*
	* @param data 明文字节数组
	* @param key 秘钥
	* @return 密文字节数组
	*/
	public static byte[] encryptHmacSHA224(byte[] data, byte[] key) {
	return hmacTemplate(data, key, "HmacSHA224");
	}

	/**
	* HmacSHA256加密
	*
	* @param data 明文字符串
	* @param key 秘钥
	* @return 16进制密文
	*/
	public static String encryptHmacSHA256ToString(String data, String key) {
	return encryptHmacSHA256ToString(data.getBytes(), key.getBytes());
	}

	/**
	* HmacSHA256加密
	*
	* @param data 明文字节数组
	* @param key 秘钥
	* @return 16进制密文
	*/
	public static String encryptHmacSHA256ToString(byte[] data, byte[] key) {
	return bytes2HexString(encryptHmacSHA256(data, key));
	}

	/**
	* HmacSHA256加密
	*
	* @param data 明文字节数组
	* @param key 秘钥
	* @return 密文字节数组
	*/
	public static byte[] encryptHmacSHA256(byte[] data, byte[] key) {
	return hmacTemplate(data, key, "HmacSHA256");
	}

	/**
	* HmacSHA384加密
	*
	* @param data 明文字符串
	* @param key 秘钥
	* @return 16进制密文
	*/
	public static String encryptHmacSHA384ToString(String data, String key) {
	return encryptHmacSHA384ToString(data.getBytes(), key.getBytes());
	}

	/**
	* HmacSHA384加密
	*
	* @param data 明文字节数组
	* @param key 秘钥
	* @return 16进制密文
	*/
	public static String encryptHmacSHA384ToString(byte[] data, byte[] key) {
	return bytes2HexString(encryptHmacSHA384(data, key));
	}

	/**
	* HmacSHA384加密
	*
	* @param data 明文字节数组
	* @param key 秘钥
	* @return 密文字节数组
	*/
	public static byte[] encryptHmacSHA384(byte[] data, byte[] key) {
	return hmacTemplate(data, key, "HmacSHA384");
	}

	/**
	* HmacSHA512加密
	*
	* @param data 明文字符串
	* @param key 秘钥
	* @return 16进制密文
	*/
	public static String encryptHmacSHA512ToString(String data, String key) {
	return encryptHmacSHA512ToString(data.getBytes(), key.getBytes());
	}

	/**
	* HmacSHA512加密
	*
	* @param data 明文字节数组
	* @param key 秘钥
	* @return 16进制密文
	*/
	public static String encryptHmacSHA512ToString(byte[] data, byte[] key) {
	return bytes2HexString(encryptHmacSHA512(data, key));
	}

	/**
	* HmacSHA512加密
	*
	* @param data 明文字节数组
	* @param key 秘钥
	* @return 密文字节数组
	*/
	public static byte[] encryptHmacSHA512(byte[] data, byte[] key) {
	return hmacTemplate(data, key, "HmacSHA512");
	}

	/**
	* Hmac加密模板
	*
	* @param data 数据
	* @param key 秘钥
	* @param algorithm 加密算法
	* @return 密文字节数组
	*/
	private static byte[] hmacTemplate(byte[] data, byte[] key, String algorithm) {
	if (data == null \|\| data.length == 0 \|\| key == null \|\| key.length == 0) return null;
	try {
	SecretKeySpec secretKey = new SecretKeySpec(key, algorithm);
	Mac mac = Mac.getInstance(algorithm);
	mac.init(secretKey);
	return mac.doFinal(data);
	} catch (InvalidKeyException \| NoSuchAlgorithmException e) {
	e.printStackTrace();
	return null;
	}
	}

	/********************** DES加密相关 *********************/
	/**
	* DES转变
	* <p>法算法名称/加密模式/填充方式</p>
	* <p>加密模式有：电子密码本模式ECB、加密块链模式CBC、加密反馈模式CFB、输出反馈模式OFB</p>
	* <p>填充方式有：NoPadding、ZerosPadding、PKCS5Padding</p>
	*/
	public static String DES_Transformation = "DES/ECB/NoPadding";
	private static final String DES_Algorithm = "DES";

	/**
	* DES加密后转为Base64编码
	*
	* @param data 明文
	* @param key 8字节秘钥
	* @return Base64密文
	*/
	public static byte[] encryptDES2Base64(byte[] data, byte[] key) {
	return base64Encode(encryptDES(data, key));
	}

	/**
	* DES加密后转为16进制
	*
	* @param data 明文
	* @param key 8字节秘钥
	* @return 16进制密文
	*/
	public static String encryptDES2HexString(byte[] data, byte[] key) {
	return bytes2HexString(encryptDES(data, key));
	}

	/**
	* DES加密
	*
	* @param data 明文
	* @param key 8字节秘钥
	* @return 密文
	*/
	public static byte[] encryptDES(byte[] data, byte[] key) {
	return desTemplate(data, key, DES_Algorithm, DES_Transformation, true);
	}

	/**
	* DES解密Base64编码密文
	*
	* @param data Base64编码密文
	* @param key 8字节秘钥
	* @return 明文
	*/
	public static byte[] decryptBase64DES(byte[] data, byte[] key) {
	return decryptDES(base64Decode(data), key);
	}

	/**
	* DES解密16进制密文
	*
	* @param data 16进制密文
	* @param key 8字节秘钥
	* @return 明文
	*/
	public static byte[] decryptHexStringDES(String data, byte[] key) {
	return decryptDES(hexString2Bytes(data), key);
	}

	/**
	* DES解密
	*
	* @param data 密文
	* @param key 8字节秘钥
	* @return 明文
	*/
	public static byte[] decryptDES(byte[] data, byte[] key) {
	return desTemplate(data, key, DES_Algorithm, DES_Transformation, false);
	}

	/********************** 3DES加密相关 *********************/
	/**
	* 3DES转变
	* <p>法算法名称/加密模式/填充方式</p>
	* <p>加密模式有：电子密码本模式ECB、加密块链模式CBC、加密反馈模式CFB、输出反馈模式OFB</p>
	* <p>填充方式有：NoPadding、ZerosPadding、PKCS5Padding</p>
	*/
	public static String TripleDES_Transformation = "DESede/ECB/NoPadding";
	private static final String TripleDES_Algorithm = "DESede";


	/**
	* 3DES加密后转为Base64编码
	*
	* @param data 明文
	* @param key 24字节秘钥
	* @return Base64密文
	*/
	public static byte[] encrypt3DES2Base64(byte[] data, byte[] key) {
	return base64Encode(encrypt3DES(data, key));
	}

	/**
	* 3DES加密后转为16进制
	*
	* @param data 明文
	* @param key 24字节秘钥
	* @return 16进制密文
	*/
	public static String encrypt3DES2HexString(byte[] data, byte[] key) {
	return bytes2HexString(encrypt3DES(data, key));
	}

	/**
	* 3DES加密
	*
	* @param data 明文
	* @param key 24字节密钥
	* @return 密文
	*/
	public static byte[] encrypt3DES(byte[] data, byte[] key) {
	return desTemplate(data, key, TripleDES_Algorithm, TripleDES_Transformation, true);
	}

	/**
	* 3DES解密Base64编码密文
	*
	* @param data Base64编码密文
	* @param key 24字节秘钥
	* @return 明文
	*/
	public static byte[] decryptBase64_3DES(byte[] data, byte[] key) {
	return decrypt3DES(base64Decode(data), key);
	}

	/**
	* 3DES解密16进制密文
	*
	* @param data 16进制密文
	* @param key 24字节秘钥
	* @return 明文
	*/
	public static byte[] decryptHexString3DES(String data, byte[] key) {
	return decrypt3DES(hexString2Bytes(data), key);
	}

	/**
	* 3DES解密
	*
	* @param data 密文
	* @param key 24字节密钥
	* @return 明文
	*/
	public static byte[] decrypt3DES(byte[] data, byte[] key) {
	return desTemplate(data, key, TripleDES_Algorithm, TripleDES_Transformation, false);
	}

	/********************** AES加密相关 *********************/
	/**
	* AES转变
	* <p>法算法名称/加密模式/填充方式</p>
	* <p>加密模式有：电子密码本模式ECB、加密块链模式CBC、加密反馈模式CFB、输出反馈模式OFB</p>
	* <p>填充方式有：NoPadding、ZerosPadding、PKCS5Padding</p>
	*/
	public static String AES_Transformation = "AES/ECB/NoPadding";
	private static final String AES_Algorithm = "AES";


	/**
	* AES加密后转为Base64编码
	*
	* @param data 明文
	* @param key 16、24、32字节秘钥
	* @return Base64密文
	*/
	public static byte[] encryptAES2Base64(byte[] data, byte[] key) {
	return base64Encode(encryptAES(data, key));
	}

	/**
	* AES加密后转为16进制
	*
	* @param data 明文
	* @param key 16、24、32字节秘钥
	* @return 16进制密文
	*/
	public static String encryptAES2HexString(byte[] data, byte[] key) {
	return bytes2HexString(encryptAES(data, key));
	}

	/**
	* AES加密
	*
	* @param data 明文
	* @param key 16、24、32字节秘钥
	* @return 密文
	*/
	public static byte[] encryptAES(byte[] data, byte[] key) {
	return desTemplate(data, key, AES_Algorithm, AES_Transformation, true);
	}

	/**
	* AES解密Base64编码密文
	*
	* @param data Base64编码密文
	* @param key 16、24、32字节秘钥
	* @return 明文
	*/
	public static byte[] decryptBase64AES(byte[] data, byte[] key) {
	return decryptAES(base64Decode(data), key);
	}

	/**
	* AES解密16进制密文
	*
	* @param data 16进制密文
	* @param key 16、24、32字节秘钥
	* @return 明文
	*/
	public static byte[] decryptHexStringAES(String data, byte[] key) {
	return decryptAES(hexString2Bytes(data), key);
	}

	/**
	* AES解密
	*
	* @param data 密文
	* @param key 16、24、32字节秘钥
	* @return 明文
	*/
	public static byte[] decryptAES(byte[] data, byte[] key) {
	return desTemplate(data, key, AES_Algorithm, AES_Transformation, false);
	}

	/**
	* DES加密模板
	*
	* @param data 数据
	* @param key 秘钥
	* @param algorithm 加密算法
	* @param transformation 转变
	* @param isEncrypt {@code true}: 加密 {@code false}: 解密
	* @return 密文或者明文，适用于DES，3DES，AES
	*/
	public static byte[] desTemplate(byte[] data, byte[] key, String algorithm, String transformation, boolean isEncrypt) {
	if (data == null \|\| data.length == 0 \|\| key == null \|\| key.length == 0) return null;
	try {
	SecretKeySpec keySpec = new SecretKeySpec(key, algorithm);
	Cipher cipher = Cipher.getInstance(transformation);
	SecureRandom random = new SecureRandom();
	cipher.init(isEncrypt ? Cipher.ENCRYPT_MODE : Cipher.DECRYPT_MODE, keySpec, random);
	return cipher.doFinal(data);
	} catch (Throwable e) {
	e.printStackTrace();
	return null;
	}
	}

	private static final char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};

	/**
	* byteArr转hexString
	* <p>例如：</p>
	* bytes2HexString(new byte[] { 0, (byte) 0xa8 }) returns 00A8
	*
	* @param bytes 字节数组
	* @return 16进制大写字符串
	*/
	private static String bytes2HexString(byte[] bytes) {
	if (bytes == null) return null;
	int len = bytes.length;
	if (len <= 0) return null;
	char[] ret = new char[len << 1];
	for (int i = 0, j = 0; i < len; i++) {
	ret[j++] = hexDigits[bytes[i] >>> 4 & 0x0f];
	ret[j++] = hexDigits[bytes[i] & 0x0f];
	}
	return new String(ret);
	}


	/**
	* hexString转byteArr
	* <p>例如：</p>
	* hexString2Bytes("00A8") returns { 0, (byte) 0xA8 }
	*
	* @param hexString 十六进制字符串
	* @return 字节数组
	*/
	private static byte[] hexString2Bytes(String hexString) {
	if (isSpace(hexString)) return null;
	int len = hexString.length();
	if (len % 2 != 0) {
	hexString = "0" + hexString;
	len = len + 1;
	}
	char[] hexBytes = hexString.toUpperCase().toCharArray();
	byte[] ret = new byte[len >> 1];
	for (int i = 0; i < len; i += 2) {
	ret[i >> 1] = (byte) (hex2Dec(hexBytes[i]) << 4 \| hex2Dec(hexBytes[i + 1]));
	}
	return ret;
	}

	/**
	* hexChar转int
	*
	* @param hexChar hex单个字节
	* @return 0..15
	*/
	private static int hex2Dec(char hexChar) {
	if (hexChar >= '0' && hexChar <= '9') {
	return hexChar - '0';
	} else if (hexChar >= 'A' && hexChar <= 'F') {
	return hexChar - 'A' + 10;
	} else {
	throw new IllegalArgumentException();
	}
	}

	/**
	* Base64编码
	*
	* @param input 要编码的字节数组
	* @return Base64编码后的字符串
	*/
	private static byte[] base64Encode(byte[] input) {
	return Base64.encode(input, Base64.NO_WRAP);
	}

	/**
	* Base64解码
	*
	* @param input 要解码的字符串
	* @return Base64解码后的字符串
	*/
	private static byte[] base64Decode(byte[] input) {
	return Base64.decode(input, Base64.NO_WRAP);
	}

	private static boolean isSpace(String s) {
	if (s == null) return true;
	for (int i = 0, len = s.length(); i < len; ++i) {
	if (!Character.isWhitespace(s.charAt(i))) {
	return false;
	}
	}
	return true;
	}
	}

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

工具类

加密解密相关→EncryptUtils 的相关文章

印章生成工具类开发

Java代码见我的资源免费使用印章生成工具类 Java开发 Java文档类资源 CSDN下载印章生成工具类 Java开发更多下载资源学习资料请访问CSDN下载频道 https download csdn net download jlo
RedisUtil工具类

package com test util import java util ArrayList import java util List import java util Map import java util Set import
身份证省市区SQL代码

转载自 https blog csdn net xiaofanku article details 18085865 身份证号码的意义前1 2位数字表示所在省份的代码第3 4位数字表示所在城市的代码第5 6位数字表示所在区县的代
vue自定义穿梭框支持远程滚动加载

欢迎点击领取前端面试题进阶指南前端登顶之巅最全面的前端知识点梳理总结分享一个使用比较久的技术框架公司的选型老项目 vue2 iview ui 方案的实现思路是共性的展现UI样式需要你们自定义进行更改因为iview是全局注入
工具类用于ajax使用json请求时返回一个json

package com noe utils import java util HashMap 工具类封装响应内容会被转成json响应 MyStatus ok gt new MyStatus 0 gt code 0 new MyStatu
手把手教你调用百度人脸识别API

在百度AI开放平台使用百度的人脸识别能力只需要三个核心步骤即可操作完成获取接口权限准备接口调用工具进行接口调用全部流程走通只需要十分钟时间获取接口权限获取接口权限是调用接口的前提主要分为以下几步 1 进入百度云的人脸识别控制
StrSubstitutor和StrUtil占位符字符串替换

目录一 commons lang包下的StrSubstitutor 1 使用场景一 2 使用场景二二 hutoo包下的StrUtil 1 使用场景一 2 使用场景二 3 使用场景三三原生的三种方式一 commons lang包下的
HBuilder html 乱码解决，java eclipse等应当同理

1 网上下载了一套html代码出现乱码一般就是编码格式问题 2 解决方式更改编码 3 剪切所有内容然后右下角修改编码为utf 8 4 再粘贴内容 5 访问页面
Ubuntu 14.04 apt-get update失效解决

当运行apt get update后出现如下错误时 E Some index files failed to download they have been ignored or old ones used instead 可以将目录下 v
window10安装CUDA7.0-8.0-9.0

因为需求没办法 window10 x64 家庭版无所谓 VS 2013 专业版 x64 现在安装CUDA 顺序 CUDA 9 0 176 CUDA 8 0 61 CUDA 7 0 27 CUDA9 0是完整安装 8 0和7 0 不要安装
Java基础——大杂烩

今天阿Q给大家来一节大杂烩讲一下专题性不强的java基础知识 main方法详解 public static void main String args 这里面只有args能改变 public 被jvm调用访问权限足够大 static 被
推荐一个将MD格式的文档轻松转换到微信公众号的工具

因为微信公众号自带的编辑器不是特别友好这也是一个痛点之前也有使用过google插件但不是特别灵活现在推荐的这款工具可以很好的支持将MD格式的文档直接进行渲染还是非常好用的话不多说先给出工具地址 https md openwri
JAVA基于Slack实现异常日志报警

一功能介绍在我们日常开发中如果系统在线上环境上发生异常开发人员不能及时知晓来修复可能会造成重大的损失因此后端服务中加入异常报警的功能是十分必要的而开发一个功能全面的异常报警服务可能会花费较长的周期今天给大家带来一种基于S
使用ADB指令永久隐藏或禁用状态栏和虚拟按键

原理是强大的ADB命令 1 手机开启开发者模式允许ADB调试 2 电脑上下载ADB包 adb rar 529 77 KB 下载次数 7681 3 解压到任意位置比如c adb 4 cmd命令定位到adb目录比如 cd c adb 5
序列化工具

import java io ByteArrayInputStream import java io ByteArrayOutputStream import java io Closeable import java io ObjectI
ubuntu 查看端口占用命令

查看端口占用情况 netstat nultp
vscode c++ 的环境配置（完美版）

怎么下载MinGW64 https blog csdn net skh2015java article details 85075032 vscode c 的环境配置 https blog csdn net qq 43041976 arti
正则表达式工具类

在实际开发中总会使用到正则表达式匹配数据我也是在后面查看了一些资料下面写一个常用的正则表达式匹配集合正则匹配模式表示匹配字符串的开始位置例外用在中括号中时可以理解为取反表示不匹配括号中字符串表示匹配字符串的结束位置表示
Java 正则表达式工具类大全

import java util regex Matcher import java util regex Pattern author nql Description 验证工具类 date now public class Validat
WSL无法访问网络的解决办法

今天在用WSL的时候突然网络抽风域名解析出了问题 apt update都用不了网上查了很多方法什么vEthernet的IP啊 ifconfigip啊 ip route add default啥的都不管用最后还是看了一下 etc r

随机推荐

1.1python中print的使用方法

1 对于初学者开始学习python 首先应该学会的就是对python中的print用法学习一个函数首先需要知道该函数的使用方法使用参数以及使用后的结果本文以pycharm解释器对python中函数print 做出以下解释 1 打开p
赣榆高中2021高考成绩查询,赣榆中考成绩查询2021

2021赣榆中考成绩查询时间方法 91中考网消息 2021年赣榆中考即将开始在中考后广大考生最关心的无疑就是中考成绩查询方法赣榆中考成绩什么时候公布根据往年经验小编收集整理了2021赣榆中考成绩查询时间方法具体如下 2021赣榆
数字黑洞 C语言

题目给定任一个各位数字不完全相同的 4 位正整数如果我们先把 4 个数字按非递增排序再按非递减排序然后用第 1 个数字减第 2 个数字将得到一个新的数字一直重复这样做我们很快会停在有数字黑洞之称的 6174 这个神奇的数字
Vue中打包压缩插件：compression-webpack-plugin

1 http gzip 介绍 Encoding type gzip GNU zip 压缩格式也是互联网上最流行的压缩格式 deflate zlib deflate 压缩格式流行程度仅次于 gzip br 一种专门为 HTTP 优化的新压
Jmeter集合点

一集合点简介 1 我们怎么实现真正的并发并发指的是系统中真正操作业务的用户在jmeter中称为线程数 jmeter中各个线程用户在进行业务操作中的顺序存在一定的随机性 2 集合点的目的让各个线程用户步调一致对系统进行
小记跨域相关问题

注解 CrossOrigin 支持跨域跨域不同的域名A 访问域名B 的数据就是跨域端口不同也是跨域 loalhost 18081 gt localhost 18082 协议不同也是跨域域名不同也是跨域协议一直端口一致域
Verilog小心得

一概念阻塞赋值在always过程块中当存在多条阻塞赋值语句时在前面的赋值语句没有完成之前后面的语句就不能被执行阻塞赋值语句顺序执行就像被阻塞了一样因此被称为阻塞赋值非阻塞赋值 lt 在always过程块中当存在多条阻塞
Golang——从入门到放弃

文章目录一 golang 简介 1 go 语言特点 2 go 语言应用领域 3 使用 go 语言的公司有哪些二安装 golang 1 golang 下载安装 2 配置环境变量三 golang 开发工具 1 安装 VSCode 2 下
C++ template的使用

1 template的使用 C 的高级玩法当然包含了模板模板 template 是实现代码重用机制的一种工具它可以实现类型参数化把类型定义为参数模板元编程从而实现了真正的代码可重用性模板是用来批量生成功能和形式都几乎相同的代码
基于tensorflow2.3.0的手写数字识别案例

本程序使用mnist训练数据集进行训练得出模型再利用mnist测试数据集进行验证得出模型的实际效果 1 引入运行需要的环境 import tensorflow as tf from tensorflow import keras fro
python中返回json 字符串时，出现转义字符\u4e09

1 问题接口中返回的json 中出现 u4e09 的 Unicode 转义字符出现在字符串中 2 原因 JSON 格式要求字符串中的非 ASCII 字符必须转义为 Unicode 序列 3 解决方法将 JSON 字符串中的转义字符还原
C++程序设计3版谭浩强（读书笔记）-1初步知识

历史知识大概是贝尔实验室C语言广泛被大众所接受但是随着软件变大 C跟不上需求 C 登上历史舞台 C 1 0增加了类 C 2 0增加了类的多继承 C 3 0增加了模板 C 4 0增加了异常处理命名空间运行时类型识别 RTTI 然后第一次
oracle 一维数转二维数组,js将一维数组转化为二维数组

遇到的问题后端返回的是一组一维数组但是需要展示的格式是二维数组常见的场景举例后台返回10个长度的数组需要分成3个一组展示在banner上例 1 2 3 4 5 6 7 8 9 10 gt 1 2 3 4 5 6 7 8 9 10
下载vimeo视频_使用Vimeo的API和Slim构建基本的视频搜索应用

下载vimeo视频 In this tutorial you ll get to know the basics of the Vimeo API With it you can fetch information on a specifi
git本地分支修改名称

给一个git分支改名的方法很简单如果对于分支不是当前分支可以使用下面代码 git branch m 原分支名新分支名如果是当前那么可以使用加上新名字 git branch m 新分支名称
密码编码学与网络安全（2）：对称密码之传统加密技术

对称密码之传统加密技术关于对称加密对称密码模型密码编码学密码分析学与穷举攻击古典加密算法代替技术置换技术转轮机隐写术关于对称加密对称加密也称为传统加密或单密钥加密是20世纪70年代公钥密码产生之前唯一的加密类型
达梦数据库图形化界面工具打开常见报错

在使用工具时有时会存在打开报错的情况最常见的就是manager及dts 某次练习时dts产生了如下报错此类报错基本都是由于用root用户启动了某些需要用dmdba用户启动的程序导致部分目录及包的权限受到影响变为root root 比
Maven基础——什么是Maven

目录 Maven概述一什么是maven 二 Maven能解决什么问题三依赖管理的概念四一键构建概念 Maven基础 Maven安装与仓库类型介绍 Maven概述一什么是maven Maven是一个项目管理工具它包含了一个项
加密解密相关→EncryptUtils

import android util Base64 import java io File import java io FileInputStream import java io IOException import java sec

加密解密相关→EncryptUtils

加密解密相关→EncryptUtils 的相关文章

随机推荐

热门标签