Android代码中编码和加解密方式
Base64算法
单向加密算法
MD5(消息摘要算法)
SHA(安全散列算法)
对称加密算法
DES（Data Encryption Standard）数据标准加密
AES（Advanced  Encryption Standrad）高级加密标准
非对称加密


加解密方式有很多种；大体可分成，Base64加密、单向加密（MD5、SHA)、对称加密(DES,AES)、非对称加密(RSA)、非数字签名等等，对于每种方式不多说了，直接看代码吧~~~

Base64算法
Base64是一种基于64个基本字符，加密后的内容只包含这64个字符；它是一种最简单的算法，只是我们肉眼看不出来罢了，一般用于加密ulr.
package com.app.sercet;
import java.util.Base64;

public class Base64Demo {

	/**
	 * Base64加密
	 * @param str
	 * @return
	 */
	private static String encode(String str) {
		byte[] encodeBytes = Base64.getEncoder().encode(str.getBytes());
		return new String(encodeBytes);
	}

	/**
	 * Base64解密
	 * @param str
	 * @return
	 */

	private static String decode(String str) {
		byte[] decodeBytes = Base64.getDecoder().decode(str.getBytes());
		return new String(decodeBytes);
	}
	}

单向加密算法
包含MD5和SHA,就是只能加密不能解密；下面上代码
MD5(消息摘要算法)
package com.app.sercet;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class MD5Demo {

	// MD5加密
	private static String toMd5(String str) {

		// 实例化一个指定摘要算法为MD5的MessageDigest对象
		MessageDigest algorithm;
		try {
			algorithm = MessageDigest.getInstance("MD5");
			// 重置摘要以供再次使用
			algorithm.reset();
			// 使用bytes更新摘要
			algorithm.update(str.getBytes());
			// 使用指定的byte数组对摘要进行最后更新,然后完成摘要计算
			return toHexString(algorithm.digest(), "");
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}

		return null;
	}

	// 将字符串中的每个字符转换为十六进制
	private static String toHexString(byte[] bytes, String separtor) {
		StringBuilder hexString = new StringBuilder();
		for (byte b : bytes) {
			String hex = Integer.toHexString(0xff & b);
			if (hex.length() == 1) {
				hexString.append("0");
			}
			hexString.append(hex).append(separtor);
		}
		return hexString.toString();
	}
}

SHA(安全散列算法)
package com.app.sercet;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class SHADemo {

	// MD5加密
	private static String toSHA(String str) {

		// 实例化一个指定摘要算法为MD5的MessageDigest对象
		MessageDigest algorithm;
		try {//e84e30b9390cdb64db6db2c9ab87846d
			algorithm = MessageDigest.getInstance("SHA");
			// 重置摘要以供再次使用
			algorithm.reset();
			// 使用bytes更新摘要
			algorithm.update(str.getBytes());
			// 使用指定的byte数组对摘要进行最后更新,然后完成摘要计算
			return toHexString(algorithm.digest(), "");
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}

		return null;
	}

	// 将字符串中的每个字符转换为十六进制
	private static String toHexString(byte[] bytes, String separtor) {
		StringBuilder hexString = new StringBuilder();
		for (byte b : bytes) {
			String hex = Integer.toHexString(0xff & b);
			if (hex.length() == 1) {
				hexString.append("0");
			}
			hexString.append(hex).append(separtor);
		}
		return hexString.toString();
	}
}


对称加密算法
同一个秘钥可以同时作为信息的加密和解密。
DES（Data Encryption Standard）数据标准加密
public class DES {
	// 初始化向量，随意填充
	private static byte[] iv = { 'a', 'b', 'c', 'd', 'e', 1, 2, '*' };

	public static void main(String[] args) {
		// 指定密匙
		String key = "*()&^%$#";
		// 指定需要加密的明文
		String text = "4454069u =o 5h6u= bopregkljoj";
		try {
			// 调用DES加密方法
			String encryString = DES.encryptDES(text, key);
			System.out.println("DES加密结果： " + encryString);
			// 调用DES解密方法
			String decryString = DES.decryptDES(encryString, key);
			System.out.println("DES解密结果： " + decryString);
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	// DES加密
	// encryptText为原文
	// encryptKey为密匙
	private static String encryptDES(String encryptText, String encryptKey)
			throws Exception {
		// 实例化IvParameterSpec对象，使用指定的初始化向量
		IvParameterSpec spec = new IvParameterSpec(iv);
		// 实例化SecretKeySpec类,根据字节数组来构造SecretKeySpec
		SecretKeySpec key = new SecretKeySpec(encryptKey.getBytes(), "DES");
		// 创建密码器
		Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
		// 用密码初始化Cipher对象
		cipher.init(Cipher.ENCRYPT_MODE, key, spec);
		// 执行加密操作
		byte[] encryptData = cipher.doFinal(encryptText.getBytes());
		// 返回加密后的数据
		return Base64.getEncoder().encodeToString(encryptData);
	}

	// 解密
	private static String decryptDES(String decryptString, String decryptKey)
			throws Exception {
		// 先使用Base64解密
		byte[] base64byte = Base64.getDecoder().decode(decryptString);
		// 实例化IvParameterSpec对象，使用指定的初始化向量
		IvParameterSpec spec = new IvParameterSpec(iv);
		// 实例化SecretKeySpec类,根据字节数组来构造SecretKeySpec
		SecretKeySpec key = new SecretKeySpec(decryptKey.getBytes(), "DES");
		// 创建密码器
		Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
		// 用密码初始化Cipher对象
		cipher.init(Cipher.DECRYPT_MODE, key, spec);
		// 获取解密后的数据
		byte decryptedData[] = cipher.doFinal(base64byte);
		// 将解密后数据转换为字符串输出
		return new String(decryptedData);
	}

}


AES（Advanced  Encryption Standrad）高级加密标准
public class AES {

	public static void main(String[] args) throws Exception {
		// 设置加密密匙
		String masterPassword = "AndroidERHJ";
		// 设置原文
		String originalText = "ABCDEFGHIJKLMNOPQRS547KYU,N;[HTUVWXYZ";
		// 调用AES加密方法
		String encryptingCode = AES.encrypt(masterPassword, originalText);
		System.out.println("加密结果：" + encryptingCode);
		// 调用AES解密方法
		String decryString = AES.decrypt(masterPassword, encryptingCode);
		System.out.println("解密结果：" + decryString);
	}

	// AES加密
	// encryptText为要加密的内容
	// seed为密匙
	public static String encrypt(String seed, String encryptText)
			throws Exception {
		byte[] rawKey = getRawKey(seed.getBytes());
		byte[] result = encrypt(rawKey, encryptText.getBytes());
		return toHex(result);
	}

	// AES解密
	// decryptText为需要解密的内容
	// seed为密匙
	public static String decrypt(String seed, String decryptText)
			throws Exception {
		byte[] rawKey = getRawKey(seed.getBytes());
		byte[] enc = toByte(decryptText);
		byte[] result = decrypt(rawKey, enc);
		return new String(result);

	}

	// 加密
	private static byte[] encrypt(byte[] raw, byte[] bytes) throws Exception {
		// 生成一组扩展密匙，并放入一个数组之中
		SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
		Cipher cipher = Cipher.getInstance("AES");
		// 用ENCRYPT_MODE模式,用skeySpec密码组，生成AES加密方法
		cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
		// 得到加密数据
		byte[] encrypted = cipher.doFinal(bytes);
		return encrypted;
	}

	// 解密
	private static byte[] decrypt(byte[] rawKey, byte[] enc) throws Exception {
		// 生成一组扩展密匙，并放入一个数组之中
		SecretKeySpec skeyKeySpec = new SecretKeySpec(rawKey, "AES");
		Cipher cipher = Cipher.getInstance("AES");
		// 用DECRYPT_MODE模式,用skeySpec密码组，生成AES解密方法
		cipher.init(Cipher.DECRYPT_MODE, skeyKeySpec);
		// 得到解密数据
		byte[] decrypted = cipher.doFinal(enc);
		return decrypted;
	}

	// 对密匙进行编码
	private static byte[] getRawKey(byte[] bytes) throws Exception {
		// 获取密匙生成器
		KeyGenerator kgen = KeyGenerator.getInstance("AES");
		SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
		sr.setSeed(bytes);
		// 生成128位的AES密码生成器
		kgen.init(128, sr);
		// 生成密匙
		SecretKey sKey = kgen.generateKey();
		// 编码格式
		byte[] raw = sKey.getEncoded();
		return raw;
	}

	// 将十六进制字符串为十进制字符串
	private static String fromHex(String hex) {
		return new String(toByte(hex));
	}

	// 将十六进制字符串为十进制字节数组
	private static byte[] toByte(String hex) {
		int len = hex.length() / 2;
		byte[] result = new byte[len];
		for (int i = 0; i < len; i++) {
			result[i] = Integer.valueOf(hex.substring(2 * i, 2 * i + 2), 16)
					.byteValue();
		}
		return result;
	}

	// 把一个十进制字节数组转换成十六进制
	private static String toHex(String txt) {
		return toHex(txt.getBytes());
	}

	// 把一个十进制字节数组转换成十六进制
	private static String toHex(byte[] buf) {
		if (buf == null)
			return "";
		StringBuffer result = new StringBuffer(2 * buf.length);
		for (int i = 0; i < buf.length; i++) {
			appendHex(result, buf[i]);
		}
		return result.toString();
	}

	private final static String HEX = "0123456789ABCDEF";

	private static void appendHex(StringBuffer result, byte b) {
		result.append(HEX.charAt((b >> 4) & 0x0f)).append(HEX.charAt(b & 0X0f));

	}

}


非对称加密
RSA加密：
public class RSA {

	public static void main(String[] args) {
		rsa();
	}

	private static String str = "姑娘,我爱你!";// 要加密的内容

	private static void rsa() {
		try {
			// 1.初始化秘钥
			KeyPairGenerator keyPairGenerator = KeyPairGenerator
					.getInstance("RSA");
			// 设置长度，一定是64整倍数
			keyPairGenerator.initialize(512);
			KeyPair keyPair = keyPairGenerator.generateKeyPair();
			RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
			RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
			System.out.println("publicKey："
					+ Base64.getEncoder().encodeToString(
							rsaPublicKey.getEncoded()));
			System.out.println("privateKey："
					+ Base64.getEncoder().encodeToString(
							rsaPrivateKey.getEncoded()));
			// 2.私钥加密、 公钥解密--加密
			PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(
					rsaPrivateKey.getEncoded());
			KeyFactory keyFactory = KeyFactory.getInstance("RSA");
			PrivateKey privateKey = keyFactory
					.generatePrivate(pkcs8EncodedKeySpec);
			Cipher cipher = Cipher.getInstance("RSA");
			cipher.init(Cipher.ENCRYPT_MODE, privateKey);
			byte[] result = cipher.doFinal(str.getBytes());
			System.out.println("私钥加密、 公钥解密--加密："
					+ Base64.getEncoder().encodeToString(result));

			// 3.私钥加密、公钥解密--解密
			X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(
					rsaPublicKey.getEncoded());
			keyFactory = KeyFactory.getInstance("RSA");
			PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
			cipher = Cipher.getInstance("RSA");
			cipher.init(Cipher.DECRYPT_MODE, publicKey);
			result = cipher.doFinal(result);
			System.out.println("私钥加密、公钥解密--解密: " + new String(result));

			// 4.公钥加密、私钥解密--加密
			x509EncodedKeySpec = new X509EncodedKeySpec(
					rsaPublicKey.getEncoded());
			keyFactory = KeyFactory.getInstance("RSA");
			publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
			cipher = Cipher.getInstance("RSA");
			cipher.init(Cipher.ENCRYPT_MODE, publicKey);
			result = cipher.doFinal(str.getBytes());
			System.out.println("公钥加密、私钥解密--加密: "
					+ Base64.getEncoder().encodeToString(result));

			// 5.公钥加密、私钥解密--解密
			pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(
					rsaPrivateKey.getEncoded());
			keyFactory = KeyFactory.getInstance("RSA");
			privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
			cipher = Cipher.getInstance("RSA");
			cipher.init(Cipher.DECRYPT_MODE, privateKey);
			result = cipher.doFinal(result);
			System.out.println("公钥加密、私钥解密--解密: " + new String(result));
		} catch (Exception e) {
			e.printStackTrace();
		}

	}
}

start = time()

from keras.models import Sequential
from keras.layers import Dense, Dropout,Input
from keras.layers import Embedding
from keras.layers import Conv1D, GlobalAveragePooling1D, MaxPooling1D
from keras import layers
from keras.models import Model


# Parameters for denoising autoencoder
nb_visible = 120
nb_hidden = 64
batch_size = 16
# Build autoencoder model
input_img = Input(shape=(nb_visible,))

encoded = Dense(nb_hidden, activation='relu')(input_img)
decoded = Dense(nb_visible, activation='sigmoid')(encoded)

autoencoder = Model(input=input_img, output=decoded)
autoencoder.compile(loss='mean_squared_error',optimizer='adam',metrics=['mae'])
autoencoder.summary()

# Train
### 加一个early_stooping
import keras 

early_stopping = keras.callbacks.EarlyStopping(
    monitor='val_loss',
    min_delta=0.0001,
    patience=5, 
    verbose=0, 
    mode='auto'
)
autoencoder.fit(X_train_np, y_train_np, nb_epoch=50, batch_size=batch_size , shuffle=True,
                callbacks = [early_stopping],verbose = 1,validation_data=(X_test_np, y_test_np))
# Evaluate
evaluation = autoencoder.evaluate(X_test_np, y_test_np, batch_size=batch_size , verbose=1)
print('val_loss: %.6f, val_mean_absolute_error: %.6f' % (evaluation[0], evaluation[1]))

end = time()
print('耗时：'+str((end-start)/60))
keras各种自编码代码

博客来自：http://www.gbtags.com/gb/tutorials/215/1163.htm


个人主页：http://www.itit123.cn/ 更多干货等你来拿




 HTML代码编码规范

为了保证项目代码的质量，书写HTML和CSS相关代码的时候，需要遵循一定的规则和逻辑，虽然HTML相关代码没有太复杂的逻辑，并且记得一定要验证代码正确性，下面是一些相关的编码规范
书写符合兼容性的代码
为了保证代码一致性，需要保证HTML代码嵌套正确，比如，是否正确的闭合元素
不符合编码规范
<p id="intro">New items on the menu today include <strong>caramel apple cider and breakfast crepes</p>.</strong>
<p id="intro">The caramel apple cider is delicious.
符合编码规范
<p class="intro">New items on the menu today include <strong>caramel apple cider and breakfast crepes</strong>.</p>
<p class="intro">The caramel apple cider is delicious.</p>
使用语义化的元素
选择和使用具体元素的时候，注意一定要选择能够正确表达HTML结构和逻辑的元素，否则不利于他人理解书写代码的逻辑性
不符合编码规范
<span class="heading"><strong>欢迎登陆</span></strong>
<br><br>
好久没有登录本站，最近如何？
<br><br>
符合编码规范
<h1>Welcome Back</h1>
<p>It has been a while. What have you been up to lately?</p>
使用正确的文档结构
文档结构是HTML编辑基础，确定使用最新正确的文档结构，不要随意的删除和添加基础文档结构

不符合编码规范
<html>
  <h1>Hello World</h1>
  <p>This is a web page.</p>
</html>
符合编码规范
<!DOCTYPE html>
<html>
  <head>
    <title>Hello World</title>
  </head>
  <body>
    <h1>Hello World</h1>
    <p>This is a web page.</p>
  </body>
</html>
保证语法的统一

随着页面内容的增加，管理HTML会非常的麻烦，好在这里有一些规则能够帮助我们将语法设计的更加干净和有组织。包扩：
在元素名称，属性，值中使用小写字母
缩进嵌套的元素
严格使用双引号，不要写单引号，或者干脆不使用引号
自闭合的元素不要写斜杠（例如，<img>）
忽略boolean属性对应的值
下面是一对例子：
不符合编码规范
<Aside>
<h3>Chicago</h3>
<H5 HIDDEN='HIDDEN'>City in Illinois</H5>
<img src=chicago.jpg alt="Chicago, the third most populous city in the United States" />
<ul>
<li>234 square miles</li>
<li>2.715 million residents</li>
</ul>
</ASIDE>
符合编码规范
<aside>
  <h3>Chicago</h3>
  <h5 hidden>City in Illinois</h5>
  <img src="chicago.jpg" alt="Chicago, the third most populous city in the United States">
  <ul>
    <li>234 square miles</li>
    <li>2.715 million residents</li>
  </ul>
</aside>
使用实在的ID或者Class值
创建id和class可能是书写HTML代码最坑的地方。这些定义必须和页面逻辑和结构息息相关，而并非仅仅用来定义页面的样式。下面是具体代码例子：
不符合编码规范
<p class="red">出错，请刷新~</p>
符合编码规范
<p class="alert">出错，请刷新~</p>
在图片中使用说明文字
书写图片中alt属性对应值，会帮助其它相关体验软件更好的识别文字，同时对于搜索引擎来说，alt属性能更好的帮助搜索引擎找到对应的内容
不符合编码规范
<img src="puppy.jpg">
符合编码规范
<img src="puppy.jpg" alt="漂亮的小宠物">
将内容和样式隔离
千万不要使用行内的样式。 这样会造成非常差的代码维护性和重用性。尽量使用外部的样式文件来定义样式。

不符合编码规范
<p style="color: #393; font-size: 24px;">Thank you!</p>
符合编码规范
<p class="alert-success">Thank you!</p>
避免过度使用div
div在过去的前端代码开发中会被广泛的使用，用来定义布局或者具体内容，但随着HTML5标准的发布，带来了一些新的HTML元素，例如：
section
article
aside
更多
因此我们尽量使用语义明显的标签来构建布局，例子如下：
不符合编码规范
<div class="container">
  <div class="article">
    <div class="headline">Headlines Across the World</div>
  </div>
</div>
符合编码规范
<div class="container">
  <article>
    <h1>Headlines Across the World</h1>
  </article>
</div>

1、下载的代码在这一轮

现在最近的时候3.0版本，可能到你的时候已经不是最近，你就进去下最新的代码就好了。下载链接如下：

https://vcgit.hhi.fraunhofer.de/jvet/VVCSoftware_VTM


2、下载完成之后，解压，在代码目录下面新建一个build文件夹




3、然后打开命令窗口，切换到你的build目录下面，因为我的VS是2017,所以我在readme.txt文件中找到这句话，然后输入


cmake .. -G "Visual Studio 15 2017 Win64"



注意：你首先要得安装cmake这个软件。下载地址。

http://www.cmake.org/


4、返回到build文件夹中，然后打开.sin文件。


5、打开后，在vs2017下面，将EncoderAPP设置为启动项，点击重新生成，然后按F5，编译，编译完成后是这样子的。








6、接下来，我自己建立两个文件夹，一个放配置文件，一个放是视频的序列。比如我的mycfg文件夹是放配置文件，mysequence是放的是视频序列文件。




7、将源码目录下的cfg文件夹打开，里面有个 encoder_intra_vtm.cfg 文件，和per-sequence文件夹下面有很多的视频配置信息。因为我没有相应的视频序列。我只有要给forma序列，我就修改配置文件成forman信息就好。修改后的代码这样的。视频的路径一定要修改，不然找不到视频序列。











#======== File I/O ===============
                               //这个是视频的路径
InputFile                     : C:/home/H266/VVCSoftware_VTM-master30/build/mysequence/foreman_cif.yuv
InputBitDepth                 : 8           # Input bitdepth
InputChromaFormat             : 420         # Ratio of luminance to chrominance samples
FrameRate                     : 50          # Frame Rate per second
FrameSkip                     : 0           # Number of frames to be skipped in input
SourceWidth                   : 352         # Input  frame width
SourceHeight                  : 288         # Input  frame height
FramesToBeEncoded             : 5         # Number of frames to be coded

Level                         : 3.1




7、修改完成配置文件以后，你就可以开始配置vs2017了




8、首先要打开EncoderAPP的输行，在输入参数中，填入你的信息。release和debug都要配置哦，因为你可能会用到release，因为它跑的很快。就像你追你喜欢的女孩子，她不喜欢你的话，她会跑的很快，同理的。




9、配置完成就可以开始按f5。然后开始编译了。




10、编译完就好了