java

import java.security.SecureRandom;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.SecretKeyFactory;
import javax.crypto.SecretKey;
import javax.crypto.Cipher;

public class zte1 {
    public static void main(String[] args) {
//        System.out.println(htol("ff"));
      /*  System.out.println(ltoh(255));
        System.out.println(atoh("a"));
        System.out.println(htoa("61"));*/
       /* String str = "我在写工具类";
        //密码，长度要是8的倍数
        String password = "12345678";
        byte[] result = zte1.encrypy(str.getBytes(), password);
        System.out.println("加密后：" + new String(result));

        byte[] decryresult = zte1.decrypt(result, password);
        System.out.println("解密后：" + new String(decryresult));*/

//        System.out.println(hexString2binaryString("a1"));
//        System.out.println(hexString2binaryString("b0"));
//        System.out.println(BIT_XOR("a1","b0"));
//        System.out.println(BIT_INV("a"));
    }

    /**
     * 16进制转换成10进制无符号数
     *
     * @param hexString
     * @param
     * @return
     */
    public static int htol(String hexString) {
       /* int  desc=0;
        for (int i = 0; i <hexString.length() ; i++) {
            desc+=Integer.parseInt(hexString.substring(i,i+1),16);
        }*/
        if (hexString == null || "".equals(hexString)) {
            return 0;
        }
        int desc = 0;
        for (char c : hexString.toCharArray())
            desc = desc * 16 + Character.digit(c, 16);
        return desc;
    }

    /**
     * 10进制数转换成16进制串
     *
     * @param res
     * @return
     */
    public static String ltoh(int res) {
        String hexString = Integer.toHexString(res);
        return hexString;
    }

    /**
     * ASCII码转换成16进制
     *
     * @param asciiString
     * @return
     */
    public static String atoh(String asciiString) {
        char[] chars = asciiString.toCharArray();
        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < chars.length; i++) {
            stringBuffer.append(Integer.toHexString(chars[i]));
        }
        return stringBuffer.toString();
    }

    /**
     * 16进制转换成ASCII码
     *
     * @param hexString
     * @return
     */
    public static String htoa(String hexString) {
        StringBuffer stringBuffer = new StringBuffer();
        StringBuffer temp = new StringBuffer();
        for (int i = 0; i < hexString.length() - 1; i += 2) {
            String output = hexString.substring(i, i + 2);
            int decimal = Integer.parseInt(output, 16);
            temp.append((char) decimal);
        }
        return temp.toString();
    }

    /**
     * DES加密
     *
     * @param datasource
     * @param password
     * @return
     */
    public static byte[] encrypy(byte[] datasource, String password) {
        try {
            SecureRandom random = new SecureRandom();
            DESKeySpec desKeySpec = new DESKeySpec(password.getBytes());
            //创建秘钥工厂，然后用它把DESKeySpec转换成
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
            //Cipher对象实际完成加密过程
            Cipher cipher = Cipher.getInstance("DES");
            //用秘钥初始化Cipher对象
            cipher.init(Cipher.ENCRYPT_MODE, secretKey, random);
            //现在，获取数据并加密
            //正式执行加密操作
            return cipher.doFinal(datasource);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * DES解密
     *
     * @param src
     * @param password
     * @return
     */
    public static byte[] decrypt(byte[] src, String password) {

        try {
            //DES算法要求有同一个可信任的随机数源
            SecureRandom random = new SecureRandom();
            //创建一个DESKeySpec对象
            DESKeySpec desKeySpec = new DESKeySpec(password.getBytes());
            //创建一个秘钥工厂，
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            //将DESKeySpec对象转换成SecretKey对象。
            SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
            //Cipher对象完成解密操作
            Cipher cipher = Cipher.getInstance("DES");
            //用秘钥初始化Cipher对象
            cipher.init(Cipher.DECRYPT_MODE, secretKey, random);
            return cipher.doFinal(src);

        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 将16进制转换成2进制
     *
     * @param hexString
     * @return
     */
    public static String hexString2binaryString(String hexString) {
//        if (hexString == null || hexString.length() % 2 != 0)
//            return null;
        String bString = "", tmp;
        for (int i = 0; i < hexString.length(); i++) {
            tmp = "0000" + Integer.toBinaryString(Integer.parseInt(hexString.substring(i, i + 1), 16));
            bString += tmp.substring(tmp.length() - 4);
//            bString=Integer.toBinaryString(Integer.parseInt(hexString.substring(i, i + 1),16));
        }
        return bString;
    }

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

    /**
     * 16进制位异或,返回16进制
     *
     * @param str1
     * @param str2
     * @return
     */
    public static String BIT_XOR(String str1, String str2) {
        if (str1.length() != str2.length()) {
            return null;
        }
        String string = new String();
        for (int i = 0; i < hexString2binaryString(str1).length(); i++) {
            if (hexString2binaryString(str1).charAt(i)== hexString2binaryString(str2).charAt(i)) {
                string+="0";
            } else {
                string+="1";
            }
//            System.out.println(string);
        }
//        System.out.println(stringBuffer);
        return binaryString2hexString(string);
    }

    /**
     * 16进制按位取反,返回16进制
     *
     * @param hexString
     * @return
     */
    public static String BIT_INV(String hexString) {
        String str_binary = hexString2binaryString(hexString);
//        System.out.println(str_binary+"==========================");
        String binary = "";
        for (int i = 0; i < str_binary.length(); i++) {
            if (str_binary.charAt(i) == '0') {
                binary += "1";
            }
            if (str_binary.charAt(i) == '1') {
                binary += "0";
            }
//            System.out.println(binary+"================");
        }
        return binaryString2hexString(binary);
    }

}