& & & 本文主要介绍java基础类型的二进制转换和二进制的基本概念。
& & & 1，二进制是以0和1为码，逢2进1，比如3=11=1*2+1。
& & & 2，在计算机当中其它进制的算法基本基于2进制，因为计算机只认识0和1，比如16进制数则意味着一位16进制码由4位2进制码数表示。
& & & 3，在Java语言中byte代表最小计量单位，byte由8位2进制数组成。
Java基本数据类型与表示范围(boolean忽略)
& & & 1，byte(整型)：8位，short(整型)：16位，char(字符型)：16位，int(整型)：32位，float(浮点型单精度)：32位，long(整型)：64位，double(浮点型双精度)：64位。
& & & 2，直接按位做比例运算，一个short数字或char字符可有两个byte数字表示，一个float或int数字可由4个byte数字表示，一个long或double数字可由8个byte数字表示。
& & & 3，以2进制数表示范围计算得到各整型数值表示范围，每种数值类型的最大表示范围可以通过包装类的静态属性取到，比如Integer.MAX_VALUE。
& & & 4，char类型是最具话题性的数据类型，它承担着整个语言世界的符号统统转换称为计算机所认识的编码格式的重任，关于字符集和编码包含了很多概念也带来了很多问题。
二进制与编码
& & &&一般对英文字符而言，一个字节表示一个字符，但是对汉字而言，由于低位的编码已经被使用(早期计算机并不支持中文，因此为了扩展支持，唯一的办法就是采用更多的字节数)只好向高位扩展。
& & & 一般字符集编码的范围 utf-8&gbk&iso-8859-1(latin1)&ascll。是美国标准信息交换码的英文缩写，包含了常用的字符，如阿拉伯数字，英文字母和一些打印符号，请注意字符和数字的区别，比如'0'字符对应的十进制数字是48。
& & & unicode编码包含很多种格式，utf-8是其中最常用的一种，utf-8名称的来自于该编码使用8位一个字节表示一个字符。对于一个汉字而言，它需要3个字节表示一个汉字，但大中华地区人民表示不服，搞一套gbk编码格式，用两个字节表示一个汉字。
乱码问题：
& & & 乱码问题的根源在于信息解码和编码时使用的格式不统一，参考IBM社区的一篇文章《》。
示例1--简单&运算示例
public void demo(){
assertEquals(4,4&4);
assertEquals(0,4&8);
// 字符'0'用十进制数48表示
char c = '0';
assertEquals(48,i);
// 认识 0xf, 0xff, 0xffff. f对应16进制数字15, 二进制1111
byte b = Byte.MAX_VALUE;
assertEquals(127,b);
assertEquals(127,b & 0xff);
assertEquals(15,b & 0xf);
// 说明-1是按照默认的(byte)b1=0xff与0xff计算后转换为int值 = 255
assertEquals(255, (byte)b1&0xff);
assertEquals(255, b1&0xff);
// 255转换为byte 结果为-1
assertEquals(-1, (byte)(b1&0xff));
// b1不强制转换编译器会报错. 0xff超过byte表示范围转为byte值得到-1
byte bf = (byte) 0xff;
assertEquals(bf, -1);
// 符号位不变取反+1 = 00001 =
assertEquals(-14, (byte)0xf2);
& & &上面的代码包含了几个基本的运算和转换的示例。
二进制与其它类型直接的转换
& & &工具类ByteUtils.java(为方便了解进制转换，各个方法参数都不包含index，如果要作为工具使用，请自行修改)
package org.wit.ff.
* 基本数据类型转换(主要是byte和其它类型之间的互转).
* @author F.Fang
* @version $Id: ByteUtils.java, v 0.1 日 下午11:23:21 F.Fang Exp $
public class ByteUtils {
* 将4个byte数字组成的数组合并为一个float数.
* @param arr
public static float byte4ToFloat(byte[] arr) {
if (arr == null || arr.length != 4) {
throw new IllegalArgumentException("byte数组必须不为空,并且是4位!");
int i = byte4ToInt(arr);
return Float.intBitsToFloat(i);
* 将一个float数字转换为4个byte数字组成的数组.
* @param f
public static byte[] floatToByte4(float f) {
int i = Float.floatToIntBits(f);
return intToByte4(i);
* 将八个byte数字组成的数组转换为一个double数字.
* @param arr
public static double byte8ToDouble(byte[] arr) {
if (arr == null || arr.length != 8) {
throw new IllegalArgumentException("byte数组必须不为空,并且是8位!");
long l = byte8ToLong(arr);
return Double.longBitsToDouble(l);
* 将一个double数字转换为8个byte数字组成的数组.
* @param i
public static byte[] doubleToByte8(double i) {
long j = Double.doubleToLongBits(i);
return longToByte8(j);
* 将一个char字符转换为两个byte数字转换为的数组.
* @param c
public static byte[] charToByte2(char c) {
byte[] arr = new byte[2];
arr[0] = (byte) (c && 8);
arr[1] = (byte) (c & 0xff);
* 将2个byte数字组成的数组转换为一个char字符.
* @param arr
public static char byte2ToChar(byte[] arr) {
if (arr == null || arr.length != 2) {
throw new IllegalArgumentException("byte数组必须不为空,并且是2位!");
return (char) (((char) (arr[0] && 8)) | ((char) arr[1]));
* 将一个16位的short转换为长度为2的8位byte数组.
* @param s
public static byte[] shortToByte2(Short s) {
byte[] arr = new byte[2];
arr[0] = (byte) (s && 8);
arr[1] = (byte) (s & 0xff);
* 长度为2的8位byte数组转换为一个16位short数字.
* @param arr
public static short byte2ToShort(byte[] arr) {
if (arr != null && arr.length != 2) {
throw new IllegalArgumentException("byte数组必须不为空,并且是2位!");
return (short) (((short) arr[0] && 8) | ((short) arr[1] & 0xff));
* 将short转换为长度为16的byte数组.
* 实际上每个8位byte只存储了一个0或1的数字
* 比较浪费.
* @param s
public static byte[] shortToByte16(short s) {
byte[] arr = new byte[16];
for (int i = 15; i &= 0; i--) {
arr[i] = (byte) (s & 1);
public static short byte16ToShort(byte[] arr) {
if (arr == null || arr.length != 16) {
throw new IllegalArgumentException("byte数组必须不为空,并且长度为16!");
short sum = 0;
for (int i = 0; i & 16; ++i) {
sum |= (arr[i] && (15 - i));
* 将32位int转换为由四个8位byte数字.
* @param sum
public static byte[] intToByte4(int sum) {
byte[] arr = new byte[4];
arr[0] = (byte) (sum && 24);
arr[1] = (byte) (sum && 16);
arr[2] = (byte) (sum && 8);
arr[3] = (byte) (sum & 0xff);
* 将长度为4的8位byte数组转换为32位int.
* @param arr
public static int byte4ToInt(byte[] arr) {
if (arr == null || arr.length != 4) {
throw new IllegalArgumentException("byte数组必须不为空,并且是4位!");
return (int) (((arr[0] & 0xff) && 24) | ((arr[1] & 0xff) && 16) | ((arr[2] & 0xff) && 8) | ((arr[3] & 0xff)));
* 将长度为8的8位byte数组转换为64位long.
* 0xff对应16进制,f代表1111,0xff刚好是8位 byte[]
* arr,byte[i]&0xff刚好满足一位byte计算,不会导致数据丢失. 如果是int计算. int[] arr,arr[i]&0xffff
* @param arr
public static long byte8ToLong(byte[] arr) {
if (arr == null || arr.length != 8) {
throw new IllegalArgumentException("byte数组必须不为空,并且是8位!");
return (long) (((long) (arr[0] & 0xff) && 56) | ((long) (arr[1] & 0xff) && 48) | ((long) (arr[2] & 0xff) && 40)
| ((long) (arr[3] & 0xff) && 32) | ((long) (arr[4] & 0xff) && 24)
| ((long) (arr[5] & 0xff) && 16) | ((long) (arr[6] & 0xff) && 8) | ((long) (arr[7] & 0xff)));
* 将一个long数字转换为8个byte数组组成的数组.
public static byte[] longToByte8(long sum) {
byte[] arr = new byte[8];
arr[0] = (byte) (sum && 56);
arr[1] = (byte) (sum && 48);
arr[2] = (byte) (sum && 40);
arr[3] = (byte) (sum && 32);
arr[4] = (byte) (sum && 24);
arr[5] = (byte) (sum && 16);
arr[6] = (byte) (sum && 8);
arr[7] = (byte) (sum & 0xff);
* 将int转换为32位byte.
* 实际上每个8位byte只存储了一个0或1的数字
* 比较浪费.
* @param num
public static byte[] intToByte32(int num) {
byte[] arr = new byte[32];
for (int i = 31; i &= 0; i--) {
// &1 也可以改为num&0x01,表示取最地位数字.
arr[i] = (byte) (num & 1);
// 右移一位.
num &&= 1;
* 将长度为32的byte数组转换为一个int类型值.
* 每一个8位byte都只存储了0或1的数字.
* @param arr
public static int byte32ToInt(byte[] arr) {
if (arr == null || arr.length != 32) {
throw new IllegalArgumentException("byte数组必须不为空,并且长度是32!");
int sum = 0;
for (int i = 0; i & 32; ++i) {
sum |= (arr[i] && (31 - i));
* 将长度为64的byte数组转换为一个long类型值.
* 每一个8位byte都只存储了0或1的数字.
* @param arr
public static long byte64ToLong(byte[] arr) {
if (arr == null || arr.length != 64) {
throw new IllegalArgumentException("byte数组必须不为空,并且长度是64!");
long sum = 0L;
for (int i = 0; i & 64; ++i) {
sum |= ((long) arr[i] && (63 - i));
* 将一个long值转换为长度为64的8位byte数组.
* 每一个8位byte都只存储了0或1的数字.
* @param sum
public static byte[] longToByte64(long sum) {
byte[] arr = new byte[64];
for (int i = 63; i &= 0; i--) {
arr[i] = (byte) (sum & 1);
sum &&= 1;
测试用例：
& & 1，测试基本的移位操作符号.
public void op(){
int i = -1;
System.out.println(Arrays.toString(ByteUtils.intToByte32(i)));
// 有符号右移,符号位依然存在,右移一位后最左边的最高位补1, -1
System.out.println(i && 1);
// 无符号右移,忽略符号位,右移一位后最左边的最高位补0, Integer.MAX_VALUE
System.out.println(i &&& 1);
// 有符号左移,符号位依然存在,左移一位最低位补0. -2
System.out.println(i && 1);
// &&&无此符号,因为左移符号位不会丢失,没有必要再增加此操作.
& & &2，查询最大值最小值.
public void showMaxValAndminVal() {
System.out.println(Byte.MAX_VALUE);
System.out.println(Byte.MIN_VALUE);
System.out.println(Short.MAX_VALUE);
System.out.println(Short.MIN_VALUE);
System.out.println((int) Character.MAX_VALUE);
System.out.println((int) Character.MIN_VALUE);
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
// 科学计数法.
System.out.println(Float.MAX_VALUE);
// 1.4E-45
System.out.println(Float.MIN_VALUE);
// 4775807
System.out.println(Long.MAX_VALUE);
// -4775808
System.out.println(Long.MIN_VALUE);
// 科学计数法.
System.out.println(Double.MAX_VALUE);
// 4.9E-324
System.out.println(Double.MIN_VALUE);
& & & 3，转换测试：
public void transByte() {
char c = 'z';
byte[] charToByte2Arr = ByteUtils.charToByte2(c);
assertEquals("[0, 122]", Arrays.toString(charToByte2Arr));
assertEquals('z', ByteUtils.byte2ToChar(charToByte2Arr));
short s = Short.MAX_VALUE;
// System.out.println("Short.MAX_VALUE:" + s);
byte[] shortToByte2Arr = ByteUtils.shortToByte2(s);
assertEquals("[127, -1]", Arrays.toString(shortToByte2Arr));
assertEquals(s, ByteUtils.byte2ToShort(shortToByte2Arr));
byte[] shortToByte16 = ByteUtils.shortToByte16(s);
System.out.println(Arrays.toString(shortToByte16));
System.out.println(ByteUtils.byte16ToShort(shortToByte16));
int i = Integer.MAX_VALUE;
// System.out.println("Integer.MAX_VALUE:" + i);
byte[] intToByte4Arr = ByteUtils.intToByte4(i);
assertEquals("[127, -1, -1, -1]", Arrays.toString(intToByte4Arr));
assertEquals(i, ByteUtils.byte4ToInt(intToByte4Arr));
byte[] intToByte32Arr = ByteUtils.intToByte32(i);
System.out.println(Arrays.toString(intToByte32Arr));
System.out.println(ByteUtils.byte32ToInt(intToByte32Arr));
long j = Long.MAX_VALUE;
// System.out.println("Long.MAX_VALUE:" + j);
byte[] longToByte8Arr = ByteUtils.longToByte8(j);
assertEquals("[127, -1, -1, -1, -1, -1, -1, -1]", Arrays.toString(longToByte8Arr));
assertEquals(j, ByteUtils.byte8ToLong(longToByte8Arr));
byte[] longToByte64Arr = ByteUtils.longToByte64(j);
System.out.println(Arrays.toString(longToByte64Arr));
System.out.println(ByteUtils.byte64ToLong(longToByte64Arr));
double d = 2.34;
byte[] doubleToByte8Arr = ByteUtils.doubleToByte8(d);
assertEquals("[64, 2, -72, 81, -21, -123, 30, -72]", Arrays.toString(doubleToByte8Arr));
// double类型不能直接做等值比较,只能在精度范围做差值比较.
assertEquals(d + "", ByteUtils.byte8ToDouble(doubleToByte8Arr) + "");
float f = 1.2f;
byte[] floatToByte4Arr = ByteUtils.floatToByte4(f);
assertEquals("[63, -103, -103, -102]", Arrays.toString(floatToByte4Arr));
assertEquals(f + "", ByteUtils.byte4ToFloat(floatToByte4Arr) + "");
阅读(...) 评论()没有更多推荐了，
不良信息举报
举报内容：
java二进制、八进制、十六进制间转换详细
举报原因：
原文地址：
原因补充：
最多只允许输入30个字
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！直接上代码：
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("十进制转换到其它进制：");
int x = 123 ;
String str1 = Integer.toHexString(x) ;
///10进制转换成16进制的字符串
System.out.println(str1);
String str2 = Integer.toOctalString(x) ;
///10进制转换成8进制的字符串
System.out.println(str2);
String str3 = Integer.toBinaryString(x) ;
///10进制转换成2进制的字符串
System.out.println(str3);
String str4 = Integer.toString() ;
///10进制转换成7进制的字符串
///String str4 = Integer.toString(i,x) ;
///10进制的数字i转换成x进制的字符串
System.out.println("其它制转换到十进制：");
int y1= Integer.valueOf("FFFF",16);
///16进制转换成10进制
System.out.println(y1);
int y2=Integer.valueOf("776",8);
///8进制转换成10进制
System.out.println(y2);
int y3=Integer.valueOf("0101",2);
//2进制转换成10进制
System.out.println(y3);
int y4=Integer.valueOf("101",7);
//7进制转换成10进制
System.out.println(y4);
///Integer.valueOf("str",x); ///可以为任意进制的字符串str转换成x进制的10进制数
System.out.println("其它的可能用到的函数：");
//static int parseInt(String s, int radix) //使用第二个参数指定的基数，将字符串参数解析为有符号的整数。
int n = Integer.parseInt("776", 8) ; ///8进制转换成10进制
System.out.println(n);
///Integer.valueOf()返回一个&integer对象&和Integer.parseInt()返回一个&int值&的区别在于，返回值不同
///基本常识，其他的非10进制的数的保存，基本都是以字符串的形式
///例子：7进制到8进制的转换
String q = "6523" ; ///7进制的字符串
String b = Integer.toString(Integer.valueOf(q,7),8) ;///这样7进制就变成8进制了
阅读(...) 评论()求java进制转换代码_百度知道
求java进制转换代码
是j2me的.. 2,8,10,16之间的转换2→8,2→10,2→168→2,8→10,8→1610→2,10→8,10→1616→2,16→8,16→10
我有更好的答案
下面是转换的方法
int n1 = 14;
//十进制转成十六进制：
Integer.toHexString(n1);
//十进制转成八进制
Integer.toOctalString(n1);
//十进制转成二进制
Integer.toBinaryString(12);
//十六进制转成十进制
Integer.valueOf(&FFFF&,16).toString();
//十六进制转成二进制
Integer.toBinaryString(Integer.valueOf(&FFFF&,16));
//十六进制转成八进制
Integer.toOctalString(Integer.valueOf(&FFFF&,16));
//八进制转成十进制
Integer.valueOf(&576&,8).toString();
//八进制转成二进制
Integer.toBinaryString(Integer.valueOf(&23&,8));
//八进制转成十六进制
Integer.toHexString(Integer.valueOf(&23&,8));//二进制转十进制
Integer.valueOf(&0101&,2).toString();
//二进制转八进制
Integer.toOctalString(Integer.parseInt(&0101&, 2));
//二进制转十六进制
Integer.toHexString(Integer.parseInt(&0101&, 2));
采纳率：6%
为您推荐：
其他类似问题
您可能关注的内容
进制转换的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。没有更多推荐了，
不良信息举报
举报内容：
java各种进制之间的相互转化
举报原因：
原文地址：
原因补充：
最多只允许输入30个字
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！