Java Base64数据解码

做了部分缺省处理

    public class Base64 {
//    	加密前要将已经转换成16进制的字符串还原成16进制的Byte数组，这个数组不能用getbyte得到，要调用hexStringToByteArray
    	
    	
    	public static void main(String[] args) {
    		String str = "//8ADfEAeQATkQCRgf//AA3xAHkAE50A1Oz//wAN8QB5ABOPALH9";
    		String base64DecodeResult = getBase64DecodeResult(str);
    		System.out.println(base64DecodeResult);


		}
    	
        /** 
         * 编码 
         * @param bstr 
         * @return String 
         */  
        public static String encode(byte[] bstr){  
        return new sun.misc.BASE64Encoder().encode(bstr);  
        }  
      
        /** 
         * 解码 
         * @param str 
         * @return string 
         */  
        public static byte[] decode(String str){  
        byte[] bt = null;  
        try {  
            sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder();  
            bt = decoder.decodeBuffer( str );  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
      
            return bt;  
        } 
        

        /**
         * 16进制表示的字符串转换为字节数组
         *
         * @param s 16进制表示的字符串
         * @return byte[] 字节数组
         */
        public static byte[] hexStringToByteArray(String s) {
            int len = s.length();
            byte[] b = new byte[len / 2];
            for (int i = 0; i < len; i += 2) {
                // 两位一组，表示一个字节,把这样表示的16进制字符串，还原成一个字节
                b[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character
                        .digit(s.charAt(i + 1), 16));
            }
            return b;
        }
        
        /**
         * byte[]数组转换为16进制的字符串
         *
         * @param bytes 要转换的字节数组
         * @return 转换后的结果
         */
        private static String bytesToHexString(byte[] bytes) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < bytes.length; i++) {
                String hex = Integer.toHexString(0xFF & bytes[i]);
                if (hex.length() == 1) {
                    sb.append('0');
                }
                sb.append(hex);
            }
            return sb.toString();
        }
        
        public static String getBase64DecodeResult(String EncodeData){

        	String RepairEncodeData = "";
        	String bytesToHexString = "";
        	byte[] decode = {};
        	
        	//若余数是2，需要补一个=；若是4，需补2个=
        	switch( (EncodeData.length()*6)%8 ){
        		case 0:
        			bytesToHexString = EncodeData;
        			logger.debug("入参bit数为8*N，原样输出入参");
					RepairEncodeData = EncodeData;
					decode = Base64.decode(RepairEncodeData);
        			bytesToHexString = bytesToHexString(decode);
        			break;
        		case 2:		//若余数是2，需要补一个=
        			RepairEncodeData = EncodeData + "=";
        			decode = Base64.decode(RepairEncodeData);
        			logger.debug("入参修复=");
        			bytesToHexString = bytesToHexString(decode);
        			break;
        			
        		case 4:		//若余数是4，需补2个=
        			RepairEncodeData = EncodeData + "=" + "=";
        			decode = Base64.decode(RepairEncodeData);
        			logger.debug("入参修复==");
        			bytesToHexString = bytesToHexString(decode);
        			break;
        			
        		default:
        			bytesToHexString = EncodeData;
        			logger.debug("default message in DecodeResult");
//        			System.out.println("case default");
        	}
        	
        	return bytesToHexString;
        }
    }