//常用算法：MD5、SHA、CRC
MessageDigest digest = MessageDigest.getInstance("MD5");
byte[] result = digest.digest(content.getBytes());
//消息摘要的结果一般都是转换成16 进制字符串形式展示
String hex = Hex.encode(result);
//MD5 结果为16 字节（128 个比特位）、转换为16 进制表示后长度是32 个字符
//SHA 结果为20 字节（160 个比特位）、转换为16 进制表示后长度是40 个字符
System.out.println(hex);

//获取MD5算法对象
MessageDigest digest = MessageDigest.getInstance("MD5");
digest.update(key.getBytes());
// 对字符串加密，返回加密后的字节数组
byte[] bytes = digest.digest(key.getBytes());
StringBuilder sb = new StringBuilder();
for (int i = 0; i < bytes.length; i++) {
  	// 获取有效的低8位
    String hex = Integer.toHexString(bytes[i]&0xff);
    if (hex.length() == 1){
        sb.append("0");
    }
    sb.append(hex);
}
String hexstring = sb.toString();

public class MD5Utils {
    
    public static String encode(String pwd) {
        // MessageDigest 消息摘要
        try {
            MessageDigest digester = MessageDigest.getInstance("MD5");
            // 加密，将要加密的字符串转换成字节数组
            byte[] digest = digester.digest(pwd.getBytes());

            StringBuffer buffer = new StringBuffer();
            // 0000-0101
            // 1111-1111
            // 0000-0101
            for (byte b : digest) {
                // 0xff 表示低8位
                int number = b & 0xff;
                // int 32位，一个int是四个字节，一个字节8位
                // 任何一个值& 0等于0
                // & 1 = 1
                String hexString = Integer.toHexString(number);
                if (hexString.length() == 1) {
                    buffer.append("0" + hexString);
                } else {
                    buffer.append(hexString);
                }
            }
            System.out.println("密码长度---" + buffer.toString().length());
            System.out.println("密码---" + buffer.toString());
            return buffer.toString();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }
}

/**
 * 字节数组与16进制字符串转换工具
 */
public class Hex {

	private static final char[] HEX_CHAR = { '0', '1', '2', '3', '4', '5', '6',
			'7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };

	/**
	 * 字节数组转换成16进制字符串
	 * 
	 * @param bytes
	 * @return
	 */
	public static String encode(byte[] bytes) {
		if (bytes == null || bytes.length == 0) {
			return null;
		}

		StringBuffer sb = new StringBuffer(bytes.length * 2);
		// 27对应的十六进制为1b,对应的二进制是00011011
		// 取高位和低位：00011011-》0001,1011-》1,b
		for (int i = 0; i < bytes.length; ++i) {
			// 取高位：跟0xf0做与运算后再右移4位
			int high = (bytes[i] & 0xf0) >> 4;// 0xf0: 11110000
			// 取低位：跟0x0f做与运算
			int low = bytes[i] & 0x0f;// 0x0f: 00001111
			// 字符映射
			sb.append(HEX_CHAR[high]).append(HEX_CHAR[low]);
		}
		return sb.toString();
	}

	/**
	 * 16进制字符串转换为字节数组
	 * 
	 * @param hex 16进制字符  
	 * @return
	 */
	public static byte[] decode(String hex) {
		if (hex == null || hex.length() == 0) {
			return null;
		}

		// 16进制转byte，长度减半，"1b"-->27
		int len = hex.length() / 2;
		byte[] result = new byte[len];
		String highStr = null;
		String lowStr = null;
		int high = 0;
		int low = 0;
		for (int i = 0; i < len; i++) {
			// 高位值
			highStr = hex.substring(i * 2, i * 2 + 1);// "1b"的高位为"1"
			high = Integer.parseInt(highStr, 16);// 高位转为10进制
			// 低位值
			lowStr = hex.substring(i * 2 + 1, i * 2 + 2);// "1b"的低位为"b"
			low = Integer.parseInt(lowStr, 16);// 低位转为10进制
			// 合计值
			result[i] = (byte) ((high << 4) + low);// 相当于:(高位*16) + 低位
		}
		return result;
	}

}