zoukankan      html  css  js  c++  java
  • 最全面的Java字节byte操作,处理Java基本数据的转换及进制转换操作工具,流媒体及java底层开发项目常用工具类

    前言:用于处理Java基本数据的转换及进制转换操作工具

    一、实现功能

    1、int与byte互转

    2、int与byte[]互转

    3、short与byte互转

    4、short与byte[]互转

    5、16位short与byte[]互转

    6、long与byte[]互转

    7、byte[]与inputstream互转

    8、byte与String互转

    9、16进制字符转int

    10、十进制转2进制

    11、byte[]转16进制字符

    12、byte[]数组指定位置抽取byte[]

    二、代码实现

    package cc.eguid.util;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.UnsupportedEncodingException;
    import java.nio.ByteBuffer;
    /**
     * 基本数据互转工具
     * @author eguid
     * eguid的官网:www.eguid.cc
     * eguid的csdn博客:http://blog.csdn.net/eguid_1,博客园:http://www.cnblogs.com/eguid 
     */
    public class ByteUtil {
    	private static ByteBuffer buffer = ByteBuffer.allocate(8);
    	 /**
    	  * int转byte
    	  * @param x
    	  * @return
    	  */
        public static byte intToByte(int x) {  
            return (byte) x;  
        }  
        /**
         * byte转int
         * @param b
         * @return
         */
        public static int byteToInt(byte b) {  
            //Java的byte是有符号,通过 &0xFF转为无符号
            return b & 0xFF;  
        }  
          
        /**
         * byte[]转int
         * @param b
         * @return
         */
        public static int byteArrayToInt(byte[] b) {  
            return   b[3] & 0xFF |  
                    (b[2] & 0xFF) << 8 |  
                    (b[1] & 0xFF) << 16 |  
                    (b[0] & 0xFF) << 24;  
        }
        public static int byteArrayToInt(byte[] b, int index){
        	  return   b[index+3] & 0xFF |  
                      (b[index+2] & 0xFF) << 8 |  
                      (b[index+1] & 0xFF) << 16 |  
                      (b[index+0] & 0xFF) << 24;  
        }
        /**
         * int转byte[]
         * @param a
         * @return
         */
        public static byte[] intToByteArray(int a) {  
            return new byte[] {  
                (byte) ((a >> 24) & 0xFF),  
                (byte) ((a >> 16) & 0xFF),     
                (byte) ((a >> 8) & 0xFF),     
                (byte) (a & 0xFF)  
            };  
        }  
        /** 
         * short转byte[]
         *  
         * @param b 
         * @param s 
         * @param index 
         */  
        public static void byteArrToShort(byte b[], short s, int index) {  
            b[index + 1] = (byte) (s >> 8);  
            b[index + 0] = (byte) (s >> 0);  
        }
        /** 
         * byte[]转short 
         *  
         * @param b 
         * @param index 
         * @return 
         */  
        public static short byteArrToShort(byte[] b, int index) {  
            return (short) (((b[index + 0] << 8) | b[index + 1] & 0xff));  
        }
        /** 
         * 16位short转byte[] 
         *  
         * @param s 
         *            short 
         * @return byte[]
         * */  
        public static byte[] shortToByteArr(short s) {  
            byte[] targets = new byte[2];  
            for (int i = 0; i < 2; i++) {  
                int offset = (targets.length - 1 - i) * 8;  
                targets[i] = (byte) ((s >>> offset) & 0xff);  
            }  
            return targets;  
        }
        /**
         * byte[]转16位short
         * @param b
         * @return
         */
        public static short byteArrToShort(byte[] b){
        	return byteArrToShort(b,0);
        }
        
        /**
         * long转byte[]
         * @param x
         * @return
         */
        public static byte[] longToBytes(long x) {  
            buffer.putLong(0, x);  
            return buffer.array();  
        }  
        /**
         * byte[]转Long
         * @param bytes
         * @return
         */
        public static long bytesToLong(byte[] bytes) {  
            buffer.put(bytes, 0, bytes.length);  
            buffer.flip();//need flip   
            return buffer.getLong();  
        }
        /**
         * 从byte[]中抽取新的byte[]
         * @param data - 元数据
         * @param start - 开始位置
         * @param end - 结束位置
         * @return 新byte[]
         */
        public static byte[] getByteArr(byte[]data,int start ,int end){
    		byte[] ret=new byte[end-start];
    		for(int i=0;(start+i)<end;i++){
    			ret[i]=data[start+i];
    		}
    		 return ret;
    	}
    	
    	/**
    	 * 流转换为byte[]
    	 * @param inStream
    	 * @return
    	 */
    	public static byte[] readInputStream(InputStream inStream) {
    		ByteArrayOutputStream outStream = null;
    		try {
    			outStream = new ByteArrayOutputStream();
    			byte[] buffer = new byte[1024];
    			byte[] data = null;
    			int len = 0;
    			while ((len = inStream.read(buffer)) != -1) {
    				outStream.write(buffer, 0, len);
    			}
    			data = outStream.toByteArray();
    			return data;
    		}catch (IOException e) {
    			return null;
    		} finally {
    			try {
    				if (outStream != null) {
    					outStream.close();
    				}
    				if (inStream != null) {
    					inStream.close();
    				}
    			} catch (IOException e) {
    				return null;
    			}
    		}
    	}
    	/**
    	 * byte[]转inputstream
    	 * @param b
    	 * @return
    	 */
    	public static InputStream readByteArr(byte[] b){
    		return new ByteArrayInputStream(b);
    	}
    	/**
    	 * byte数组内数字是否相同
    	 * @param s1
    	 * @param s2
    	 * @return
    	 */
    	public static boolean isEq(byte[] s1,byte[] s2){
    		int slen=s1.length;
    		if(slen==s2.length){
    			for(int index=0;index<slen;index++){
    				if(s1[index]!=s2[index]){
    					return false;
    				}
    			}
    			return true;
    		}
    		return  false;
    	}
    	/**
    	 * byte数组转换为Stirng
    	 * @param s1 -数组
    	 * @param encode -字符集
    	 * @param err -转换错误时返回该文字
    	 * @return
    	 */
    	public static String getString(byte[] s1,String encode,String err){
    		try {
    			return new String(s1,encode);
    		} catch (UnsupportedEncodingException e) {
    			return err==null?null:err;
    		}
    	}
    	/**
    	 * byte数组转换为Stirng
    	 * @param s1-数组
    	 * @param encode-字符集
    	 * @return
    	 */
    	public static String getString(byte[] s1,String encode){
    		return getString(s1,encode,null);
    	}
    	//测试
    	public static void main(String []args){
    		System.err.println(isEq(new byte[]{1,2},new byte[]{1,2}));
    	}
    	/**
    	 * 字节数组转16进制字符串
    	 * @param b
    	 * @return
    	 */
    	public static String byteArrToHexString(byte[] b){
    		  String result="";
    		  for (int i=0; i < b.length; i++) {
    		    result += Integer.toString( ( b[i] & 0xff ) + 0x100, 16).substring(1);
    		  }
    		  return result;
    	}
    	
    	/**
    	 * 16进制字符创转int
    	 * @param hexString
    	 * @return
    	 */
    	public static int hexStringToInt(String hexString){
    		return Integer.parseInt(hexString,16);
    	}
    	/**
    	 * 十进制转二进制
    	 * @param i
    	 * @return
    	 */
    	public static String intToBinary(int i){
    		return Integer.toBinaryString(i);
    	}
    }
    



  • 相关阅读:
    1026 Table Tennis (30)
    1029 Median
    1025 PAT Ranking (25)
    1017 Queueing at Bank (25)
    1014 Waiting in Line (30)
    1057 Stack (30)
    1010 Radix (25)
    1008 Elevator (20)
    字母大小写转换
    Nmap的基础知识
  • 原文地址:https://www.cnblogs.com/eguid/p/6846170.html
Copyright © 2011-2022 走看看