二进制 转换 .java_Java 基本数据类型二进制转换

概述

本文主要介绍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。ascll编码是美国标准信息交换码的英文缩写，包含了常用的字符，如阿拉伯数字，英文字母和一些打印符号，请注意字符和数字的区别，比如'0'字符对应的十进制数字是48。

unicode编码包含很多种格式，utf-8是其中最常用的一种，utf-8名称的来自于该编码使用8位一个字节表示一个字符。对于一个汉字而言，它需要3个字节表示一个汉字，但大中华地区人民表示不服，搞一套gbk编码格式，用两个字节表示一个汉字。

二进制与其它类型直接的转换

工具类ByteUtils.java(为方便了解进制转换，各个方法参数都不包含index，如果要作为工具使用，请自行修改)

package org.wit.ff.common;

/**

*

*

* 基本数据类型转换(主要是byte和其它类型之间的互转).

*

*

* @author F.Fang

* @version $Id: ByteUtils.java, v 0.1 2014年11月9日 下午11:23:21 F.Fang Exp $

*/

public class ByteUtils {

/**

*

*

* 将4个byte数字组成的数组合并为一个float数.

*

*

* @param arr

* @return

*/

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

* @return

*/

public static byte[] floatToByte4(float f) {

int i = Float.floatToIntBits(f);

return intToByte4(i);

}

/**

*

*

* 将八个byte数字组成的数组转换为一个double数字.

*

*

* @param arr

* @return

*/

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

* @return

*/

public static byte[] doubleToByte8(double i) {

long j = Double.doubleToLongBits(i);

return longToByte8(j);

}

/**

*

*

* 将一个char字符转换为两个byte数字转换为的数组.

*

*

* @param c

* @return

*/

public static byte[] charToByte2(char c) {

byte[] arr = new byte[2];

arr[0] = (byte) (c >> 8);

arr[1] = (byte) (c & 0xff);

return arr;

}

/**

*

*

* 将2个byte数字组成的数组转换为一个char字符.

*

*

* @param arr

* @return

*/

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

* @return

*/

public static byte[] shortToByte2(Short s) {

byte[] arr = new byte[2];

arr[0] = (byte) (s >> 8);

arr[1] = (byte) (s & 0xff);

return arr;

}

/**

*

*

* 长度为2的8位byte数组转换为一个16位short数字.

*

*

* @param arr

* @return

*/

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

* @return

*/

public static byte[] shortToByte16(short s) {

byte[] arr = new byte[16];

for (int i = 15; i >= 0; i--) {

arr[i] = (byte) (s & 1);

s >>= 1;

}

return arr;

}

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));

}

return sum;

}

/**

*

*

* 将32位int转换为由四个8位byte数字.

*

*

* @param sum

* @return

*/

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);

return arr;

}

/**

*

* 将长度为4的8位byte数组转换为32位int.

*

*

* @param arr

* @return

*/

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

* @return

*/

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);

return arr;

}

/**

*

*

* 将int转换为32位byte.

* 实际上每个8位byte只存储了一个0或1的数字

* 比较浪费.

*

*

* @param num

* @return

*/

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;

}

return arr;

}

/**

*

*

* 将长度为32的byte数组转换为一个int类型值.

* 每一个8位byte都只存储了0或1的数字.

*

*

* @param arr

* @return

*/

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));

}

return sum;

}

/**

*

*

* 将长度为64的byte数组转换为一个long类型值.

* 每一个8位byte都只存储了0或1的数字.

*

*

* @param arr

* @return

*/

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));

}

return sum;

}

/**

*

*

* 将一个long值转换为长度为64的8位byte数组.

* 每一个8位byte都只存储了0或1的数字.

*

*

* @param sum

* @return

*/

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;

}

return arr;

}

}

一段旅程，远去所有昨天的昨天，如记事本翻开新的一页，永远的不漏痕迹的把记忆藏在一片洁白中。然后绚烂的开始新的故事。(转至Java基础数据类型二进制转换)