Java中的byte和二进制梳理

最新推荐文章于 2023-07-10 19:29:53 发布

小强签名设计

最新推荐文章于 2023-07-10 19:29:53 发布

阅读量2.5w

点赞数 4

分类专栏： Java 文章标签： Java byte 二进制

Java 专栏收录该内容

38 篇文章 1 订阅

订阅专栏

java byte 和Byte（来自https://www.cnblogs.com/SevenwindMa/p/3671057.html）

java的基本数据类型中有byte这种，byte存储整型数据，占据1个字节(8 bits)，能够存储的数据范围是-128～+127。
Byte是java.lang中的一个类，目的是为基本数据类型byte进行封装。封装有几种好处，比如：1. Byte可以将对象的引用传递，使得多个function共同操作一个byte类型的数据，而byte基本数据类型是赋值之后要在stack(栈区域)进行存储的；2. 定义了和String之间互相转化的方法。Byte的大小是8个字节。因为Byte是需要通过关键字new来申请对象，而此部分申请出来的对象放在内存的heap(堆区域)。

public class ByteTest {
    public static void main(String args[])
    {
        Byte by1 = new Byte("123");
        Byte by2 = new Byte("123");
        int length = by1.SIZE;
         
        int max = by2.MAX_VALUE;
        int min = by2.MIN_VALUE;
         
        if(by1 == by2)
        {
            System.out.println("Operation '=' compares the reference of Byte objects and equal");
        }else System.out.println("Operation '=' compares the objects of Byte objects and not equal");
         
        if(by1.equals(by2))
        {
            System.out.println("Function 'equals()' compares the value of Byte objects and equal");
        }else System.out.println("Function 'equals()' compares the value of Byte objects and not equal");
         
        Byte by3 = by1;
        if(by3 == by1)
        {
            System.out.println("Operation '=' compares the reference of Byte objects and equal");
        }else System.out.println("Operation '=' compares the reference of Byte objects and not equal");
         
        System.out.println(by1);
        System.out.println(by2);
        System.out.println("The length is "+length);
        System.out.println("MAX:"+max+" MIN"+min);
        byte temp = (byte)241; // 241的二进制表示为11110001（补码），其中第一位为符号位，那么剩余的计算结果为15，最终结果为-15
        System.out.println(temp);
    }
 
}

运行结果：
Operation '=' compares the objects of Byte objects and not equal
Function 'equals()' compares the value of Byte objects and equal
Operation '=' compares the reference of Byte objects and equal
123
123
The length is 8
MAX:127 MIN-128
-15

Java byte[] 字节数组转二进制八进制十进制十六进制字符串（来自http://blog.csdn.net/uikoo9/article/details/27980869）

【前言】
java中很多时候需要将byte[]转为各种进制的字符串显示，从2，8，10，16到比较高级的base64（编码），
至于什么时候需要这样，当你遇到这样的问题就知道了。

import java.math.BigInteger;  

public class QEncodeUtil {  
    public static void main(String[] args) {  
        String s = "woaini";  
        byte[] bytes = s.getBytes();  
          
        System.out.println("将woaini转为不同进制的字符串：");  
        System.out.println("可以转换的进制范围：" + Character.MIN_RADIX + "-" + Character.MAX_RADIX);  
        System.out.println("2进制："   + binary(bytes, 2));  
        System.out.println("5进制："   + binary(bytes, 5));  
        System.out.println("8进制："   + binary(bytes, 8));  
        System.out.println("16进制："  + binary(bytes, 16));  
        System.out.println("32进制："  + binary(bytes, 32));  
        System.out.println("64进制："  + binary(bytes, 64));// 这个已经超出范围，超出范围后变为10进制显示  
          
        System.exit(0);  
    }  
      
    /** 
     * 将byte[]转为各种进制的字符串 
     * @param bytes byte[] 
     * @param radix 基数可以转换进制的范围，从Character.MIN_RADIX到Character.MAX_RADIX，超出范围后变为10进制 
     * @return 转换后的字符串 
     */  
    public static String binary(byte[] bytes, int radix){  
        return new BigInteger(1, bytes).toString(radix);// 这里的1代表正数  
    }  
}

【输出】
将woaini转为不同进制的字符串：
可以转换的进制范围：2-36
2进制：11101110110111101100001011010010110111001101001
5进制：114203022342344442242
8进制：3566754132267151
16进制：776f61696e69
32进制：3ndtgmirj9
64进制：131320259374697

java怎么把一个byte变量按二进制输出（参考自https://zhidao.baidu.com/question/1115031702245345779.html和http://blog.csdn.net/qiantudou/article/details/49928423）

import java.util.Arrays;

public class hehe {
	/** 
     * 将byte转换为一个长度为8的byte数组，数组每个值代表bit 
     */  
    public static byte[] getBooleanArray(byte b) {  
        byte[] array = new byte[8];  
        for (int i = 7; i >= 0; i--) {  
            array[i] = (byte)(b & 1);  
            b = (byte) (b >> 1);  
        }  
        return array;  
    }  
    /** 
     * 把byte转为字符串的bit 
     */  
    public static String byteToBit(byte b) {  
        return ""  
                + (byte) ((b >> 7) & 0x1) + (byte) ((b >> 6) & 0x1)  
                + (byte) ((b >> 5) & 0x1) + (byte) ((b >> 4) & 0x1)  
                + (byte) ((b >> 3) & 0x1) + (byte) ((b >> 2) & 0x1)  
                + (byte) ((b >> 1) & 0x1) + (byte) ((b >> 0) & 0x1);  
    }
    
    public static void main(String args[]){
    	byte b = 0x35; // 0011 0101
    	// 输出 [0, 0, 1, 1, 0, 1, 0, 1]
    	System.out.println(Arrays.toString(getBooleanArray(b)));
    	// 输出 00110101
    	System.out.println(byteToBit(b));
    	// JDK自带的方法，会忽略前面的 0
    	System.out.println(Integer.toBinaryString(0x35));
    }
}

public class qie {
	public static void main(String args[]){
		byte tByte = -2;
		String tString = Integer.toBinaryString((tByte & 0xFF) + 0x100).substring(1);
		System.out.println("tString:" + tString);
		System.out.println(Integer.toBinaryString(tByte & 0xFF));
		System.out.println("---------------------");
		byte tByte2 = 2;
		System.out.println(Integer.toBinaryString((tByte2 & 0xFF) + 0x100).substring(1));
		System.out.println(Integer.toBinaryString(tByte2 & 0xFF));
	}
}

代码说明:
1、主要用到了Integer.toBinaryString方法转化为二进制的。但这个方法的参数是int型，所以需要先转换为int型。
2、转换为int型的方式：tByte & 0xFF
tByte: -2 如果自动转换为int型依旧为-2，但是 -2的int型转化为二进制是11111111111111111111111111111110。
因为java中是以补码的方式显示内容的，-2的二进制原码是 10000000000000000000000000000010，转化为反码+1为补码，就是上述数据了。
但是我们想要的是10000010的原码，补码为111111110。所以对上述数据进行 & 0xFF的操作。
这一步看不懂的请看https://wenku.baidu.com/view/e454c202ed630b1c59eeb5ea.html
还可以参考：
http://blog.csdn.net/xiekuntarena/article/details/53521656
http://blog.csdn.net/lvgaoyanh/article/details/53486933
https://www.cnblogs.com/think-in-java/p/5527389.html

Java中二进制和字符串之间的相互转换

案例一（参考自http://blog.csdn.net/lhjlhj123123/article/details/6384300）

public class hui {
    public static String byte2hex(byte[] b) { // 二进制转字符串  
        String hs = "";  
        String stmp = "";  
        for (int n = 0; n < b.length; n++) {  
         stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));  
         if (stmp.length() == 1)  
          hs = hs + "0" + stmp;  
         else  
          hs = hs + stmp;  
        }  
        return hs;  
     }  
   
     public static byte[] hex2byte(String str) { // 字符串转二进制  
        if (str == null)  
         return null;  
        str = str.trim();  
        int len = str.length();  
        if (len == 0 || len % 2 == 1)  
         return null;  
       
        byte[] b = new byte[len / 2];  
        try {  
         for (int i = 0; i < str.length(); i += 2) {  
          b[i / 2] = (byte) Integer  
            .decode("0x" + str.substring(i, i + 2)).intValue();  
         }  
         return b;  
        } catch (Exception e) {  
         return null;  
        }  
     }  
   
     public static void main(String[] args) {  
        String str = "abc";  
        String result = "";
        result = byte2hex(str.getBytes());  
        System.out.println(str.getBytes());  
        System.out.println(result);  
        System.out.println(new String(hex2byte(result)));  
        System.out.println(hex2byte(result).toString());  
     }  
}

运行结果：
[B@28154ec5
616263
abc
[B@1818a0a8

案例二（参考自http://blog.csdn.net/tangxufeng/article/details/4288106）

public class StrBinaryTurn {
    public static void main(String args[]){
    	BoolToStr(StrToBool("love"));
    }
	
    //将Unicode字符串转换成bool型数组
    public static boolean[] StrToBool(String input){
        boolean[] output=Binstr16ToBool(BinstrToBinstr16(StrToBinstr(input)));
        System.out.println(output);
        return output;
    }
    //将bool型数组转换成Unicode字符串
    public static String BoolToStr(boolean[] input){
        String output=BinstrToStr(Binstr16ToBinstr(BoolToBinstr16(input)));
        System.out.println(output);
        return output;
    }
    //将字符串转换成二进制字符串，以空格相隔
    private static String StrToBinstr(String str) {
        char[] strChar=str.toCharArray();
        String result="";
        for(int i=0;i<strChar.length;i++){
            result +=Integer.toBinaryString(strChar[i])+ " ";
        }
        return result;
    }
    //将二进制字符串转换成Unicode字符串
    private static String BinstrToStr(String binStr) {
        String[] tempStr=StrToStrArray(binStr);
        char[] tempChar=new char[tempStr.length];
        for(int i=0;i<tempStr.length;i++) {
            tempChar[i]=BinstrToChar(tempStr[i]);
        }
        return String.valueOf(tempChar);
    }
    //将二进制字符串格式化成全16位带空格的Binstr
    private static String BinstrToBinstr16(String input){
        StringBuffer output=new StringBuffer();
        String[] tempStr=StrToStrArray(input);
        for(int i=0;i<tempStr.length;i++){
            for(int j=16-tempStr[i].length();j>0;j--)
                output.append('0');
            output.append(tempStr[i]+" ");
        }
        return output.toString();
    }
    //将全16位带空格的Binstr转化成去0前缀的带空格Binstr
    private static String Binstr16ToBinstr(String input){
        StringBuffer output=new StringBuffer();
        String[] tempStr=StrToStrArray(input);
        for(int i=0;i<tempStr.length;i++){
            for(int j=0;j<16;j++){
                if(tempStr[i].charAt(j)=='1'){
                    output.append(tempStr[i].substring(j)+" ");
                    break;
                }
                if(j==15&&tempStr[i].charAt(j)=='0')
                    output.append("0"+" ");
            }
        }
        return output.toString();
    }   
    //二进制字串转化为boolean型数组  输入16位有空格的Binstr
    private static boolean[] Binstr16ToBool(String input){
        String[] tempStr=StrToStrArray(input);
        boolean[] output=new boolean[tempStr.length*16];
        for(int i=0,j=0;i<input.length();i++,j++)
            if(input.charAt(i)=='1')
                output[j]=true;
            else if(input.charAt(i)=='0')
                output[j]=false;
            else
                j--;
        return output;
    }
    //boolean型数组转化为二进制字串  返回带0前缀16位有空格的Binstr
    private static String BoolToBinstr16(boolean[] input){ 
        StringBuffer output=new StringBuffer();
        for(int i=0;i<input.length;i++){
            if(input[i])
                output.append('1');
            else
                output.append('0');
            if((i+1)%16==0)
                output.append(' ');           
        }
        output.append(' ');
        return output.toString();
    }
    //将二进制字符串转换为char
    private static char BinstrToChar(String binStr){
        int[] temp=BinstrToIntArray(binStr);
        int sum=0;   
        for(int i=0; i<temp.length;i++){
            sum +=temp[temp.length-1-i]<<i;
        }   
        return (char)sum;
    }
    //将初始二进制字符串转换成字符串数组，以空格相隔
    private static String[] StrToStrArray(String str) {
        return str.split(" ");
    }
    //将二进制字符串转换成int数组
    private static int[] BinstrToIntArray(String binStr) {       
        char[] temp=binStr.toCharArray();
        int[] result=new int[temp.length];   
        for(int i=0;i<temp.length;i++) {
            result[i]=temp[i]-48;
        }
        return result;
    }
}

运行结果：
[Z@7377711
love

小强签名设计

关注

4
点赞
踩
23

收藏

觉得还不错? 一键收藏
2
评论
Java中的byte和二进制梳理

java byte 和Byte（来自https://www.cnblogs.com/SevenwindMa/p/3671057.html）java的基本数据类型中有byte这种，byte存储整型数据，占据1个字节(8 bits)，能够存储的数据范围是-128～+127。Byte是java.lang中的一个类，目的是为基本数据类型byte进行封装。封装有几种好处，比如：1. Byte可以将对
复制链接

扫一扫