Java中字符串常用工具类（数据间的转换和格式化）

package com.util;

import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.util.Arrays;

public class StringUtil {
    /**
     * 16进制的字符串表示转成字节数组
     *
     * @param hexString
     * 16进制格式的字符串
     * @return 转换后的字节数组
     **/
    public static byte[] toByteArray(String hexString) {
        hexString = hexString.toLowerCase();
        final byte[] byteArray = new byte[hexString.length() / 2];
        int k = 0;
        for (int i = 0; i < byteArray.length; i++) {// 因为是16进制，最多只会占用4位，转换成字节需要两个16进制的字符，高位在先
            byte high = (byte) (Character.digit(hexString.charAt(k), 16) & 0xff);
            byte low = (byte) (Character.digit(hexString.charAt(k + 1), 16) & 0xff);
            byteArray[i] = (byte) (high << 4 | low);
            k += 2;
        }
        return byteArray;
    }

    /**
     * 异或校验运算
     *
     * @param datas
     * @return
     */
    public static byte getXor(byte[] datas) {
        byte temp = datas[0];
        for (int i = 1; i < datas.length; i++) {
            temp ^= datas[i];
        }
        return temp;
    }

    /**
     * char数组转为byte数组
     * @param chars
     * @return
     */
    public byte[] getBytes(char[] chars) {
        Charset cs = Charset.forName("UTF-8");
        CharBuffer cb = CharBuffer.allocate(chars.length);
        cb.put(chars);
        cb.flip();
        ByteBuffer bb = cs.encode(cb);

        return bb.array();
    }

    /**
     * byte转char
     * @param bytes
     * @return
     */
    public char[] getChars(byte[] bytes) {
        Charset cs = Charset.forName("UTF-8");
        ByteBuffer bb = ByteBuffer.allocate(bytes.length);
        bb.put(bytes);
        bb.flip();
        CharBuffer cb = cs.decode(bb);

        return cb.array();
    }
/**
 * 字节数组转成16进制表示格式的字符串
 *
 * @param byteArray
 * 需要转换的字节数组
 * @return 16进制表示格式的字符串
 **/
public static String toHexString(byte[] byteArray) {
    String str = null;
    if (byteArray != null && byteArray.length > 0) {
        StringBuffer stringBuffer = new StringBuffer(byteArray.length);
        for (byte byteChar : byteArray) {
            stringBuffer.append(String.format("%02X", byteChar));
        }
        str = stringBuffer.toString();
    }
    return str;
}

    /**
     * 下面该方法等同于Integer.toBinaryString(b)
     *字节转换成二进制
     * @param b
     * @return
     */
    public static String byte2bits(byte b) {
        int z = b;
        z |= 256;
        String str = Integer.toBinaryString(z);
        int len = str.length();
        return str.substring(len - 8, len);
    }

    /**
     * 二进制转换为字节
     * @param bString
     * @return
     */
    public static byte bit2byte(String bString){
        byte result=0;
        for(int i=bString.length()-1,j=0;i>=0;i--,j++){
            result+=(Byte.parseByte(bString.charAt(i)+"")*Math.pow(2, j));
        }
        return result;
    }

    /**
     * @param @param  str 传入一个字符串
     * @param @return 设定文件
     * @return String 返回类型
     * @throws
     * @Title: formatString
     * @Description: TODO(这里用一句话描述这个方法的作用) 格式化字符串
     */
    public String formatString(String str) {

        int m = str.length() / 2;
        if (m * 2 < str.length()) {
            m++;
        }
        String[] strs = new String[m];
        int j = 0;
        for (int i = 0; i < str.length(); i++) {
            if (i % 2 == 0) {
                strs[j] = "" + str.charAt(i);
            } else {
                strs[j] = strs[j] + str.charAt(i);
                j++;
            }
        }
        return Arrays.toString(strs).toUpperCase();
    }

    /**
     * 　　* 将元数据前补零，补后的总长度为指定的长度，以字符串的形式返回
     * 　　* @param sourceDate 元数据
     * 　　* @param formatLength 补充成指定长度
     * 　　* @return 重组后的数据
     */
    public static String frontCompWithZore(int sourceDate, int formatLength) {
        /*
         * 0 指前面补充零
         * formatLength 字符总长度为 formatLength
         * d 代表为正数。
         */
        String newString = String.format("%0" + formatLength + "d", sourceDate);

        return newString;
    }
}