字节与其他类型转化的小工具

mfct 项目小工具 BytesToAll

字节与其他类型的互换

package com.hjz.mfct.util;
public class BytesToAll {
     public static final String HEX_STR = "0123456789ABCDEF";
//   用于 字符串（有数据意义的）与 字节相互转化的时候
//   字节到字符串（有数据意义的）  先将字节分为两段   前四位 转化位int
//   然后生成字符串利用charAt（int 数据）
//   字符串（有数据意义的）转化为字节  利用 字符串的indexOf（字符）
//   即得到下标也就是 得到了字符串代表的数值
     
     public BytesToAll() {
     }
     
     public static final  String  bytesToString1(long size) {
          if(size< 1024) {
               return size+"B";
          }
          if(size< (1<<20)) {
               return String.valueOf(size>>10)+"."+
                         String.valueOf((size & 0x3FF)/1024.0*100)+"kB";
//             size的前10位表示多少k  后十位是B
//             给后十位先乘以 100 再换算成多少k  即可给小数点后直接加 多少K
//             如 1000 b 换算成k 即0.976 k  先乘以100 变成97  然后直接加到小数点后面
          }
          if(size< (1<<30)) {
               System.out.println("ha");
               return String.valueOf(size>>20)+"."+
                         String.valueOf((size & 0xFFFFF)/(1024*1024.0)*100)+"MB";
          }
          if(size< (1<<40)) {
               return String.valueOf(size>>30)+"."+
                         String.valueOf((size & 0x3FFFFFFF)/(1024*1024*1024.0)*100)+"GB";
          }
          return null;
     }
     
          public static String byteToString(byte value) {
          return ""+HEX_STR.charAt(value>>4 & 0x0F)
                         +HEX_STR.charAt(value & 0x0F);
//        因为四位 二进制可以用以为16进制来表示
     }
     
     
     public static String bytesToString(byte[] bytes) {
          
          StringBuffer result=new StringBuffer();
          for (int i = 0; i < bytes.length; i++) {
               result.append(byteToString(bytes[i]));
          }
          return result.toString();
     }
     
     public static String bytesToString(byte[] bytes, int maxColumn) {
          
          StringBuffer result=new StringBuffer();
          for(int i=0;i<bytes.length;i++) {
               result.append(byteToString(bytes[i]));
               if((i+1)%maxColumn==0) {
                    result.append("\n");
               }
          }
          return result.toString();
     }
     
     public static Byte stringToByte(String str) {
//        将字符串转化成为一个字节
//        要求字符串是双字符  因为 一个字节八位  采用的是十六进制
//        因此最多  4位 转化成为一个 字符  八位则两个字符
          byte result=0;
          if((str.length()==0)||str.length()>2) {
               return null;
          }
          str=  str.length()==1? "0"+str :str;
          result|=HEX_STR.indexOf(str.indexOf(str.substring(0)))<<4;
          result|=HEX_STR.indexOf(str.indexOf(str.substring(1,1+1)));
          return result;
     }
     
     public static byte[] stringToBytes(String str) {
          
          int len = str.length();
          if (len % 2 != 0) {
               return null;
          }
          byte[] result = new byte[len / 2];
          for (int i = 0; i < len / 2; i++) {
               result[i] = stringToByte(str.substring(2*i, 2*i+2));
          }
          return result;
     }
     
     public static byte[] intToBytes(int value) {
          
          byte[] result=new byte[4];
          int mod=0xFF;
          for(int i=0;i<4;i++) {
               result[i] =(byte) (value >>(8*i) & mod);
          }
          return result;
     }
     
     public static int bytesToInt(byte[] values) {
          int result=0;
          int mod=0xFF;
          for(int i=0;i<4;i++) {
               result |= ((values[i]<<(i*8)) & mod);
//             或运算符 表示若是两个位只要有一个1 则为1
               System.out.println(result);
               mod=mod<<8;
          }
               return result;
     }
     
     public static byte[] longToBytes(long value) {
          byte[] result=new byte[8];
          int mod=0xFF;
          for(int i=0;i<8;i++) {
               result[i] =(byte) (value >>(8*i) & mod);
          }
          return result;
     }
     
     public static long bytesToLong(byte[] bytes) {
          long result = 0;
          
          long mod = 0xFF;
          for (int i = 0; i < 8; i++) {
               result |= (((bytes[i]) << (i*8)) & mod);
               mod <<= 8;
          }
          return result;
     }
     
     public static byte[] getBytesAt(byte[] value, int offset, int len) {
          byte[] result=new byte[len];
          for(int i=0;i<len;i++) {
               result[i]=value[offset++];
          }
          return result;
     }
     
     public static byte[] setBytesAt(byte[] target, int offset, byte[] resource) {
          
          for (int i = 0; i < resource.length; i++) {
               target[offset + i] = resource[i];
          }
          return target;
     }
}