十进制字符串转换为多种进制（压缩字符串）

package com.ybjdw.base.utils;

import java.math.BigDecimal;

import com.ybjdw.base.constant.SysStaticConstData;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 
 * <一句话功能简述> 数组转换
 * <功能详细描述> 1、16进制转2进制（位）数组
 *             2、2进制（位）数组转16进制
 *             3、10进制转换52（纯字母）进制
 *             4、52（纯字母）进制换10进制转
 *             5、10进制转换26（纯小写字母）进制
 *             6、26（纯小写字母）进制换10进制转
 *             7、10进制转换62（字母数字）进制
 *             8、62（字母数字）进制换10进制转
 * 
 * @author  user
 * @version  [版本号, 2019年4月10日]
 * @see  [相关类/方法]
 * @since  [产品/模块版本]
 */
public class TransOfNumber 
{
	private static final Logger logger = LoggerFactory.getLogger(TransOfNumber.class);

	/**
	 * 数字转换周期  26个小写字母
	 */
	public static final int TRANSFER_CYCLE_LOWERCASE = 26;
	/**
	 * 数字转换周期  52个大、小写字母
	 */
	public static final int TRANSFER_CYCLE_ALLCASE = 52;
	/**
	 * 数字转换周期  62个大、小写字母和数字
	 */
	public static final int TRANSFER_CYCLE_NUMBER_LETTERS = 62;
	/**
	 * 数字转换周期  76个大、小写字母、数字和字符
	 */
	public static final int TRANSFER_CYCLE_NUMBER_LETTER_SYMBOLS = 76;
	/**
	 * <一句话功能简述>16进制转2进制（位）数组
	 * <功能详细描述>
	 * author: user
	 * 创建时间:  2019年4月10日
	 * @param data
	 * @return
	 * @see [类、类#方法、类#成员]
	 */
	public static byte[] hexStringToByteArray(String data) {
		int k = 0;
		if (data == null || data.length() < 1)
		{
			return null;
		}
		byte[] results = new byte[data.length() / 2];
		for (int i = 0; i < data.length();) {
			results[k] = (byte) (Character.digit(data.charAt(i++), 16) << 4);
			results[k] += (byte) (Character.digit(data.charAt(i++), 16));
			k++;
		}
		return results;
	}
	
	/**
	 * <一句话功能简述>2进制（位）数组转16进制
	 * <功能详细描述>
	 * author: user
	 * 创建时间:  2019年4月10日
	 * @param src
	 * @return
	 * @see [类、类#方法、类#成员]
	 */
	public static String bytesToHexString(byte[] src){
	    StringBuilder stringBuilder = new StringBuilder("");
	    if (src == null || src.length <= 0) {
	        return null;
	    }
	    for (int i = 0; i < src.length; i++) {
	        int v = src[i] & 0xFF;
	        String hv = Integer.toHexString(v);
	        if (hv.length() < 2) {
	            stringBuilder.append(0);
	        }
	        stringBuilder.append(hv);
	    }
	    return stringBuilder.toString();
	}
	
	public static BigDecimal decimalRoundUp2(BigDecimal decimal)
	{
		 return decimal.setScale(2, BigDecimal.ROUND_UP);
	}
	
    /**
     * <一句话功能简述> 十进制（dec）字符串转换成XX进制system（小写字母）字符串
     * <功能详细描述>
     * author: user
     * 创建时间:  2019年4月10日
     * @param decStr 十进制数字字符串  
     * @param system 要转换的进制（ 26、小写字母, 52、大小写字母 , 62、大小写字母数字 , 76、 大小写字母数字字符)
     */
    public static String decToBigSys(String decStr, int system) {
    	if (StringUtils.isBlank(decStr)) {
    		return null;
    	}
    	// 如果长整形能处理，尽量不用BigDecimal
    	if (decStr.length() < 19) {
    		return decToBigSys(Long.parseLong(decStr), system);
    	}
    	
    	BigDecimal bigDecimal = new BigDecimal(decStr);
    	String str = getBaseStr(system);
        int scale = str.length(); //转化目标进制
        StringBuilder s = new StringBuilder();
        if(bigDecimal.compareTo(new BigDecimal(0)) == 0)
        {
            return str.charAt(0)+"";
        }
        bigDecimal = bigDecimal.abs();
        while(bigDecimal.compareTo(new BigDecimal(0)) > 0){
            if(bigDecimal.compareTo(new BigDecimal(scale)) < 0){
            	int index = bigDecimal.intValue();
            	 s.insert(0, str.charAt(index));
            	 bigDecimal = new BigDecimal(0);
            }else{
            	BigDecimal [] results = bigDecimal.divideAndRemainder(new BigDecimal(scale));
                s.insert(0, str.charAt(results[1].intValue()));
                bigDecimal  = results[0];
            }
        }
        return s.toString();
    }
    
    /**
     * <一句话功能简述> 十进制（dec）长整型数 转换成XX进制system（小写字母）字符串
     * <功能详细描述>
     * author: user
     * 创建时间:  2019年4月10日
     * @param decimal 十进制数
     *         system 要转换的进制（ 26、小写字母, 52、大小写字母 , 62、大小写字母数字 , 76、 大小写字母数字字符)
     * @return
     * @see [类、类#方法、类#成员]
     */
    public static String decToBigSys(long decimal, int system) {
        String str = getBaseStr(system);
        int scale = str.length(); //转化目标进制
        StringBuilder s = new StringBuilder();
        if(decimal == 0)
        {
            return str.charAt(0) + "";
        }
        while(decimal > 0){
            if(decimal < scale){
            	int index = (int) decimal;
            	 s.insert(0, str.charAt(index));
            	 decimal = 0;
            }else{
                int r = (int) (decimal % scale);
                s.insert(0, str.charAt(r));
                decimal  = (decimal - r) / scale;
            }
        }
        return s.toString();
    }

    
    /**
     * <一句话功能简述> XX进制转换10进制字符串
     * <功能详细描述>
     * author: user
     * 创建时间:  2019年4月10日
     * @param bigSys 其他进制字符串
     *        system 传入字符的进制进制（ 26、小写字母, 52、大小写字母 , 62、大小写字母数字 , 76、 大小写字母数字字符)
     * @return
     * @see [类、类#方法、类#成员]
     */
    public static String bigSysToDec(String bigSys, int system)
    {
    	String str = getBaseStr(system);
        int scale = str.length(); //转化目标进制
        BigDecimal decimal = new BigDecimal(0);
    	
    	char[] dataChars = bigSys.toCharArray();
    	for (int i = 0; i < dataChars.length; i++)
    	{
    		long num = StringUtils.indexOf(str, dataChars[i]);
    		if (i == 0 && dataChars[i] == '0')
    		{
    			continue;
    		}
    		decimal = decimal.add(new BigDecimal(num).multiply(new BigDecimal(scale).pow(dataChars.length - i - 1)));
    	}

    	return decimal.toString();
    }
    
    public static long bigSysToLongDec(String bigSys, int system)
    {
    	if (StringUtils.isBlank(bigSys)) {
        	return 0;
    	}
    	String decStr = bigSysToDec(bigSys, system);
    	if (decStr != null && decStr.length() < 19) {
    		return Long.parseLong(decStr);
    	} else {
    		return -1;
    	}
    }

    
    private static String getBaseStr(int system)
    {
        switch(system) {
        case 26:
        	return "abcdefghijklnmopqrstuvwxyz";
        case 52:
        	return "ABCDEFGHIJKLNMOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        case 62:
        	return "ABCDEFGHIJKLNMOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz";

        case 76:
        	return "ABCDEFGHIJKLNMOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz!@#$%^&*()_+-=";
        default :
        	return "abcdefghijklnmopqrstuvwxyz";
        }
    }

    public static String getUserIdByCode(String userCode){
    	try{
			String recommendUserId = TransOfNumber.bigSysToDec(userCode, 62);
			for (int i = recommendUserId.length(); i < SysStaticConstData.SQL_ID_LENGTH; i++) {
				recommendUserId = "0" + recommendUserId;
			}
			return recommendUserId;
		}catch (Exception e){
			logger.error("通过code获取userId失败!", e);
		}
		return null;
	}

    public static void main(String[] args)
	{
		String numStr = "100001016282207063650000";
		// 10进制字符串转换为62进制，压缩
		String productCry = decToBigSys(numStr, 62);
		System.out.println(productCry);
		// 62进制转变回10进制
		System.out.println(bigSysToDec(productCry, 62));
		System.out.println(numStr);
	}

}