本文详细介绍了Java中的8种基本数据类型，包括整型（byte, short, int, long）、浮点型（float, double）、布尔型（boolean）和字符型（char）。讨论了它们的取值范围、内存占用以及在实际使用中的选择。此外，还阐述了不同类型间的转换规则，包括自动转换和强制转换，并提供了相关的代码示例来展示如何进行字节与各种类型间的转换操作。
一、基本介绍
在Java中一共有8种基本数据类型，其中有4种整型，2种浮点类型，1种用于表示Unicode编码的字符单元的字符类型和1种用于表示真值的boolean类型。
一个字节等于8个bit，java是跟平台无关的。
（1）整型：
其中byte、short、int、long都是表示整数的，只不过他们的取值范围不一样
-
byte的取值范围为-128~127，占用1个字节（-2的7次方到2的7次方-1）
-
short的取值范围为-32768~32767，占用2个字节（-2的15次方到2的15次方-1）
-
int的取值范围为（-2147483648~2147483647），占用4个字节（-2的31次方到2的31次方-1）
-
long的取值范围为（-9223372036854774808~9223372036854774807），占用8个字节（-2的63次方到2的63次方-1）。
可以看到byte和short的取值范围比较小，而long的取值范围太大，占用的空间多，基本上int可以满足我们的日常的计算了，而且int也是使用的最多的整型类型了。
在通常情况下，如果JAVA中出现了一个整数数字比如35，那么这个数字就是int型的，如果我们希望它是byte型的，可以在数据后加上大写的 B：35B，表示它是byte型的。
同样的35S表示short型，35L表示long型的，表示int我们可以什么都不用加，但是如果要表示long型的，就一定要在数据后面加“L”。
（2）浮点型：
-
float和double是表示浮点型的数据类型，他们之间的区别在于他们的精确度不同
-
float 3.402823e+38 ~ 1.401298e-45（e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方）占用4个字节
-
double 1.797693e+308~ 4.9000000e-324 占用8个字节
double型比float型存储范围更大，精度更高，所以通常的浮点型的数据在不声明的情况下都是double型的，如果要表示一个数据是float型的，可以在数据后面加上“F”。
浮点型的数据是不能完全精确的，所以有的时候在计算的时候可能会在小数点最后几位出现浮动，这是正常的。
（3）boolean型（布尔型）：
这个类型只有两个值，true和false（真和非真）
-
boolean t = true；
-
boolean f = false；
（4）char型（文本型） ：
用于存放字符的数据类型，占用2个字节，采用unicode编码，它的前128字节编码与ASCII兼容
字符的存储范围在\u0000~\uFFFF，在定义字符型的数据时候要注意加' '，比如 '1'表示字符'1'而不是数值1，
char c = ' 1 ';
我们试着输出c看看，System.out.println(c);结果就是1，而如果我们这样输出呢System.out.println(c+0); 结果却变成了49。
扩展资料
基本类型之间的转换
将一种类型的值赋值给另一种类型是很常见的。在Java中，boolean 类型与其他7中类型的数据都不能进行转换，这一点很明确。
但对于其他7种数据类型，它们之间都可以进行转换，只是可能会存在精度损失或其他一些变化。
转换分为自动转换和强制转换：
-
自动转换（隐式）：无需任何操作。
-
强制转换（显式）：需使用转换操作符（type）。
将6种数据类型按下面顺序排列一下：
double > float > long > int > short > byt
如果从小转换到大，那么可以直接转换，而从大到小，或char 和其他6种数据类型转换，则必须使用强制转换。
二、Java代码实现转换
public class Base {
public static float bytesToFloat(byte[] b, int index) {
int l;
l = b[index + 3] << 0;
l &= 0xff;
l |= ((long) b[index + 2] << 8);
l &= 0xffff;
l |= ((long) b[index + 1] << 16);
l &= 0xffffff;
l |= ((long) b[index + 0] << 24);
return Float.intBitsToFloat(l);
}
public static int bytesToInt(byte[] bytes, int index) {
return (0xff000000 & (bytes[index + 0] << 24)) |
(0x00ff0000 & (bytes[index + 1] << 16)) |
(0x0000ff00 & (bytes[index + 2] << 8)) |
(0x000000ff & bytes[index + 3]);
}
public static double bytesToDouble(byte[] arr, int index) {
long value = 0;
index = index + 7;
for (int i = 0; i < 8; i++) {
value |= ((long) (arr[index - i] & 0xff)) << (8 * i);
}
return Double.longBitsToDouble(value);
}
public static long bytesToLong(byte[] byteNum, int index) {
long num = 0;
for (int ix = 0; ix < 8; ++ix) {
num <<= 8;
num |= (byteNum[ix + index] & 0xff);
}
return num;
}
public static short bytesToShort(byte[] bytes, int index) {
return (short) ((bytes[index] & 0xff) |
(bytes[index+1] << 8 & 0xff00));
}
public static String bytesToString(byte[] content, int offset, int length) {
int effLength = checkEffectiveLength(content, offset, length);
//System.out.println("effLength==="+effLength);
return new String(content, offset, effLength);
}
public static int checkEffectiveLength(byte[] content, int offset, int length) {
try {
for (int i = 0; i < length; i++) {
int v = content[offset + i] & 0xFF;
//System.out.println(v);
if (v == 0) {
//代表结束标记
return i;
}
}
} catch (Exception e) {
e.printStackTrace();
}
return 0;
}
public static byte[] hexStringToByteArray(String hexString) {
try{
if (!StringUtils.isEmpty(hexString)) {
int len = hexString.length();
int index = 0;
byte[] bytes = new byte[len / 2];
while (index < len) {
String sub = hexString.substring(index, index + 2);
bytes[index / 2] = (byte) Integer.parseInt(sub, 16);
index += 2;
}
return bytes;
}
}catch (Exception e) {
e.printStackTrace();
return new byte[0];
}
return new byte[0];
}
public static byte[] shortToBytes(short value){
byte[] temp=new byte[2];
temp[0]=(byte) (value&0xff);
temp[1]=(byte)(value>>8&0xff00);
return temp;
}
public static byte[] longToBytes(long num) {
byte[] byteNum = new byte[8];
for (int ix = 0; ix < 8; ++ix) {
int offset = 64 - (ix + 1) * 8;
byteNum[ix] = (byte) ((num >> offset) & 0xff);
}
return byteNum;
}
public static byte[] doubleToBytes(double d) {
long value = Double.doubleToRawLongBits(d);
byte[] byteRet = new byte[8];
for (int i = 0; i < 8; i++) {
byteRet[i] = (byte) ((value >> 8 * i) & 0xff);
}
return byteRet;
}
public static double bytesToDouble1(byte[] arr, int index) {
long value = 0;
for (int i = 0; i < 8; i++) {
value |= ((long) (arr[index + i] & 0xff)) << (8 * i);
}
return Double.longBitsToDouble(value);
}
public static byte[] intToBytes(int value) {
byte[] b = new byte[4];
b[3] = (byte) ((value & 0xff000000) >> 24);
b[2] = (byte) ((value & 0x00ff0000) >> 16);
b[1] = (byte) ((value & 0x0000ff00) >> 8);
b[0] = (byte) (value & 0x000000ff);
return b;
}
public static int bytesToInt1(byte[] bytes, int index) {
return (0xff000000 & (bytes[index + 3] << 24)) |
(0x00ff0000 & (bytes[index + 2] << 16)) |
(0x0000ff00 & (bytes[index + 1] << 8)) |
(0x000000ff & bytes[index + 0]);
}
// float转换为byte[4]数组
public static byte[] getByteArray(float f) {
int intbits = Float.floatToIntBits(f);//将float里面的二进制串解释为int整数
return getByteArray(intbits);
}
public static byte[] floatToBytes(float f) {
// 把float转换为byte[]
int fbit = Float.floatToIntBits(f);
byte[] b = new byte[4];
for (int i = 0; i < 4; i++) {
b[i] = (byte) (fbit >> (24 - i * 8));
}
// 翻转数组
int len = b.length;
// 建立一个与源数组元素类型相同的数组
byte[] dest = new byte[len];
// 为了防止修改源数组，将源数组拷贝一份副本
System.arraycopy(b, 0, dest, 0, len);
byte temp;
// 将顺位第i个与倒数第i个交换
for (int i = 0; i < len / 2; ++i) {
temp = dest[i];
dest[i] = dest[len - i - 1];
dest[len - i - 1] = temp;
}
return dest;
}
public static float bytesToFloat1(byte[] b, int index) {
int l;
l = b[index + 0];
l &= 0xff;
l |= ((long) b[index + 1] << 8);
l &= 0xffff;
l |= ((long) b[index + 2] << 16);
l &= 0xffffff;
l |= ((long) b[index + 3] << 24);
return Float.intBitsToFloat(l);
}
}
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
