256 <--> 64算法 互转 （ Java实现）

256--->64转换算法：即将一个字节256用64进制表示，首先将信息转化为16进制，再转为2进制，例：刘A—— 0xC1 0xF5 0x41（1100 0001 1111 0101 0100 0001），从高位开始依次取6位，不足后面补零：110000 011111 010101 000001，再在其高位补0后可得30 1F 15 01，直接转换成十进制48 31 21 01后从下面的函数中取出对应的值即可。

CHANG_256_64[64]={'0','1','2','3','4','5','6','7','8','9',':',';','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f','g','h','i','j',

'k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};

64转256算法则把整个过程反过来，下面来看看java程序

算法过程：字符先转换为2进制，取6位再转换为10进制，根据转换表中取出可见字符，

算法目的：确保发送的数据都是可见字符把, 原始数据不确保输入什么信息，可能会有非打印字符，经过改算法转换以后所有数据均为可见。

package com.util;

import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;

/**
 * @author dxt  
 * 2013年5月30日 14:37:43
 *  256《--》64   各进制之间转化
 */
public class HexTransform {
	
	/**
	 * 64 转化为 256
	 * @param str
	 * @return
	 */
	public static String chg64_to_256(String str) {
		String binary = "";

		char[] hex = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a',
				'b', 'c', 'd', 'e', 'f' };
		String[] bina = { "0000", "0001", "0010", "0011", "0100", "0101",
				"0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101",
				"1110", "1111" };
		HashMap<Character, String> map = new HashMap<Character, String>();
		for (int i = 0; i < hex.length; i++) {
			map.put(hex[i], bina[i]);
		}

		char[] CHANG_256_64 = { '0', '1', '2', '3', '4', '5', '6', '7', '8',
				'9', ':', ';', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
				'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',
				'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
				'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
				't', 'u', 'v', 'w', 'x', 'y', 'z' };
		for (int i = 0; i < str.length(); i++) {
			int index = -1;
			String tempbina = "";
			for (int j = 0; j < CHANG_256_64.length; j++) {
				if (str.charAt(i) == CHANG_256_64[j]) {
					index = j;//找到位置，即10进制数
					String tempHex = Integer.toHexString(index);// 16进制 （最大两位）
					//取低6位，高两位是不需要的
					if (tempHex.length() == 1) {
						tempbina += "00" + map.get(tempHex.charAt(0));
					} else {
						tempbina += map.get(tempHex.charAt(0)).substring(2)
								+ map.get(tempHex.charAt(1));
					}
					continue;
				}
			}
			binary += tempbina; // 获得的2进制数
		}

		String hexResult = "";
		// 接下来从高位8位8位取，多余的不要
		while (true) {
			hexResult += binaryString2hexString(binary.substring(0, 8));
			binary = binary.substring(8);
			if (binary.length() < 8) {
				break;
			}
		}
		System.out.println(hexResult);
		byte[] bytes = hexStringToBytes(hexResult);
		String r = "";
		try {
			r = new String(bytes, "gbk");
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		return r;

	}

	/**
	 * 16进制转化为 byte 数组（便于转化为字符串，每个byte字节  转换成两个相应的16进制字符）
	 * @param hexString
	 * @return
	 */
	public static byte[] hexStringToBytes(String hexString) {
		if (hexString == null || hexString.equals("")) {
			return null;
		}
		hexString = hexString.toUpperCase();
		int length = hexString.length() / 2;
		char[] hexChars = hexString.toCharArray();
		byte[] d = new byte[length];
		for (int i = 0; i < length; i++) {
			int pos = i * 2;
			d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
		}
		return d;
	}

	private static byte charToByte(char c) {
		return (byte) "0123456789ABCDEF".indexOf(c);
	}

	/**
	 * 进制转化 2-->16
	 * @param bString
	 * @return
	 */
	public static String binaryString2hexString(String bString) {
		if (bString == null || bString.equals("") || bString.length() % 8 != 0)
			return null;
		StringBuffer tmp = new StringBuffer();
		int iTmp = 0;
		for (int i = 0; i < bString.length(); i += 4) {
			iTmp = 0;
			for (int j = 0; j < 4; j++) {
				iTmp += Integer.parseInt(bString.substring(i + j, i + j + 1)) << (4 - j - 1);
			}
			tmp.append(Integer.toHexString(iTmp));
		}
		return tmp.toString();
	}

	/**
	 * 256转化为64          转换算法
	 * @param str
	 * @return
	 */
	public static String chg256_to_64(String str) {
		String hexStr = "";
		byte[] bs;
		try {
			bs = str.getBytes("gbk");
			for (byte b : bs) {
				hexStr = hexStr + Integer.toHexString((b) & (0xFF));
			}
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		System.out.println(hexStr);// 16进制表示

		// 2进制表示
		char[] hex = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a',
				'b', 'c', 'd', 'e', 'f' };
		String[] bina = { "0000", "0001", "0010", "0011", "0100", "0101",
				"0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101",
				"1110", "1111" };
		HashMap<Character, String> map = new HashMap<Character, String>();
		for (int i = 0; i < hex.length; i++) {
			map.put(hex[i], bina[i]);
		}
		String binaStr = "";
		for (int i = 0; i < hexStr.length(); i++) {
			binaStr += map.get(hexStr.charAt(i));
		}

		ArrayList<String> temp = new ArrayList<String>();// 6位2进制
		int i;
		for (i = 0; i < binaStr.length(); i = i + 6) {
			if ((i + 6) <= binaStr.length()) {
				temp.add(binaStr.substring(i, i + 6));
			} else {
				String rest = binaStr.substring(i);// 剩下的字串
				int a = 6 - rest.length();// 剩下字串的长度
				for (int j = 0; j < a; j++) {
					rest += "0";
				}
				temp.add(rest);
			}
		}

		ArrayList<Integer> temp2 = new ArrayList<Integer>();
		// 查看6位2进制结果
		for (int j = 0; j < temp.size(); j++) {
			temp2.add(Integer.valueOf(temp.get(j), 2));
		}

		char[] CHANG_256_64 = { '0', '1', '2', '3', '4', '5', '6', '7', '8',
				'9', ':', ';', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
				'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',
				'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
				'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
				't', 'u', 'v', 'w', 'x', 'y', 'z' };
		String resultString = "";
		for (int j = 0; j < temp2.size(); j++) {
			resultString += CHANG_256_64[temp2.get(j)];
		}
		// System.out.println(resultString);
		return resultString;
	}
}