通过密码 加密解密算法，java

加密原理：把要加密的内容和密码转换为16进制文本（16进制文本内容为0-F之间，Unicode代码点范围为200内，数字小运算起来不会超出char类型的最大值，达到内容“变身”的效果）加密内容的16进制 和 密码的16进制 相互计算形成新的字符（Unicode代码点改变后的字符）；

先说下流程：

加密1：将密码和内容转到16进制字符串

加密2：将加密1得到的内容和密码的16进制字符串的每个字符的Unicode运算得到一个新的字符串（加密完成）

加密3：再将加密2后的字符串内容转到 16进制（开发时可以省略，直接使用加密过的内容）

解密1：将加密3的十六进制内容还原到加密2的内容，即是加密过的内容（如果加密3没使用，这个也不要）

解密2：将加密过的内容和密码每个字符的Unicode值通过加密2的反运算得到原来内容Unicode16进制字符值

解密3：将解密2得到的16进制字符串还原（解密完成）

再有一个小问题：在加密解密运行时换行符加密解密出错，自定义一个格式替代加密，解密后替代回来就可以啦

下面是本人写的java代码：

import java.io.File;

public class Test1 {
	public static void main(String[] args) {
		// 密码
		String paw = "密码";
		// 内容
		String text = "helloworld 你是我的小啊小苹果，怎么咬你都不嫌多\n换行了 OK了";
		File file = new File("D:\\eclipse\\Test\\src\\Test1.java");//读入文件内容
		System.out.println("***内容：" + text);
		// 换行符 装换失效 用符号替代
		text = text.replaceAll("\n", "&abcs");

		// 16进制文本内容
		StringBuffer textHex = formatHex(text);
		StringBuffer pawHex = formatHex(paw);
		System.out.println("***原始十六进制：" + textHex);
		// 加密后
		String strC = charEncryption(textHex, pawHex);
		System.out.println("***加密：" + strC);

		StringBuffer s = formatHex(strC);
		System.out.println("***加密后的十六进制：" + s.toString());
		System.out
				.println("\n加密\n------------------------------------------------\n解密\n");
		String aText = toStringHex(s.toString());
		System.out.println("***还原加密的内容：" + aText);

		String str = charDecryption(aText, pawHex);
		System.out.println("***还原原始十六进制：" + str);
		// 还原 换行符
		String result = toStringHex(str).replaceAll("&abcs", "\n");
		System.out.println("***解密：" + result);
		// System.out.println(0xff & Integer.parseInt("39", 16));
	}

	/**
	 * 解密数据
	 * 
	 * @param text
	 *            加密的文本
	 * @param pawHex
	 *            密码
	 * @return
	 */
	private static String charDecryption(String text, StringBuffer pawHex) {
		char[] textChars = text.toString().toCharArray();
		char[] pawChars = pawHex.toString().toCharArray();

		for (int i = 0; i < textChars.length; i++) {
			//解密 通过加密的反运算得到原数据
			textChars[i] = (char) (textChars[i] - pawChars[i % pawChars.length] * 2);
		}

		return new String(textChars);
	}

	/**
	 * 
	 * @param textBin
	 *            要加密16进制内容
	 * @param pawBin
	 *            16的密码内容<br>
	 *            16进制文本范围在0-F 不影响加密超出范围损失数据
	 * @return
	 */
	private static String charEncryption(StringBuffer textBin,
			StringBuffer pawBin) {
		char[] textChars = textBin.toString().toCharArray();
		char[] pawChars = pawBin.toString().toCharArray();
		for (int i = 0; i < textChars.length; i++) {
			// 加密就这一行 +号改变Unicode的值 % 作用是使密码内容都用上
			// *2代表Unicode*2 可以自定义 但要保证不要超出 char 类型范围 解密的时候别忘了改一致
			textChars[i] = (char) (textChars[i] + pawChars[i % pawChars.length] * 2);
		}

		return new String(textChars);
	}

	/**
	 * 转为十六进制
	 * 
	 * @param text
	 * @return
	 */
	private static StringBuffer formatHex(String text) {
		StringBuffer sb = new StringBuffer();
		byte[] by = text.getBytes();
		String str;
		for (int i = 0; i < by.length; i++) {
			str = Integer.toHexString(by[i]);
			str = str.toUpperCase();

			while (str.startsWith("F")) {
				str = str.substring(1, str.length());
			}

			sb.append(str);
		}

		return sb;
	}

	public static String toStringHex(String s) {
		byte[] baKeyword = new byte[s.length() / 2];
		for (int i = 0; i < baKeyword.length; i++) {
			try {
				baKeyword[i] = (byte) (0xff & Integer.parseInt(
						s.substring(i * 2, i * 2 + 2), 16));
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

		try {
			s = new String(baKeyword, "utf-8");// UTF-16le:Not
		} catch (Exception e1) {
			e1.printStackTrace();
		}
		return s;
	}
}