本文链接： https://blog.csdn.net/jiangguangchao/article/details/101520017

基本数据类型

Java语言提供了八种基本类型（byte、short、int、long 、float、double、char、boolean），其中六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型，下面我们一一来介绍。

整数型

在Java中整数型数据包括byte、short、int、long四个。

整数型的最值和默认值

四大整数型数据的最值和默认值如下：
byte：
byte 数据类型是8位、有符号的，以二进制补码表示的整数；

最小值是 -128（-2^7）；
最大值是 127（2^7-1）；
默认值是 0；
包装类：java.lang.Byte；

byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
例子：byte a = 100，byte b = -50。

short：
short 数据类型是 16 位、有符号的以二进制补码表示的整数

最小值是 -32768（-2^15）；
最大值是 32767（2^15 - 1）；
默认值是 0；
包装类：java.lang.Short；

Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
例子：short s = 1000，short r = -20000。

int：
int 数据类型是32位、有符号的以二进制补码表示的整数；

最小值是 -2,147,483,648（-2^31）；
最大值是 2,147,483,647（2^31 - 1）；
默认值是 0 ；
包装类：java.lang.Integer；

一般地整型变量默认为 int 类型；
例子：int a = 100000, int b = -200000。

long：
long 数据类型是 64 位、有符号的以二进制补码表示的整数；

最小值是 -9,223,372,036,854,775,808（-2^63）；
最大值是 9,223,372,036,854,775,807（2^63 -1）；
默认值是 0L；
包装类：java.lang.Long；

这种类型主要使用在需要比较大整数的系统上；
例子： long a = 100000L，Long b = -200000L。
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩，所以最好大写。

整数型的存储

数据在计算机中存储时，不同类型的数据会占据不同位数的存储空间。

在现在大部分计算机中数据存储采用补码的形式，第一位为符号位，0表示正数，1表示负数。正数补码是其本身，负数的补码是负数的原码取反加一。

1、正数的原码、反码、补码都相等
　　　　例:0000 1010（在十进制中表示+10，左数第一位为符号位）
　　　　它的原码、反码、补码都是0000 1010
　　　　
2、负数的原码是其本身，负数的反码是将符号不变，把符号后边的数取反，对于负数的补码是把原码取反后加1
　　　　例：1000 1010（在十进制中表示-10）
　　　　它的原码是 1000 1010
　　　　它的反码是 1111 0101
　　　　它的补码是 1111 0110

我们拿Java的short类型举例：

最小的负整数 -32768 在计算机中二进制标示：10000000 00000000
最大的负整数-1 在计算机中二进制标示：11111111 11111111
0 在计算机中二进制标示：00000000 0000000
最小的正整数 1 在计算机中二进制标示： 00000000 00000001
最大的正整数：32767 在计算机中二进制标示： 01111111 11111111

浮点型

小数的二进制表示

数据中除了整数还有小数，计算机为了表示和存储小数，首先要对小数进行二进制转换。

具体过程如下（以78.375为例）：

78.375 的整数部分：
在这里插入图片描述
小数部分：

所以，78.375 的二进制形式就是 1001110.011
然后，使用二进制科学记数法，有

转换后用二进制科学记数法表示的这个数，有底有指数有小数部分，这个就叫做浮点数

浮点数的存储

在计算机中，保存这个数使用的是浮点表示法，分为三大部分：

第一部分用来存储符号位（sign），用来区分正负， 0表示正数；
第二部分用来存储指数（exponent），指数也有正负之分；
第三部分用来存储小数（fraction）；
如下图：

浮点型的最值和默认值

在Java中浮点型数据类型包括float和double，两大浮点型数据类型在计算机中的存储格式如下：
1、float类型是32位，是单精度浮点表示法：

符号位（sign）占用1位，用来表示正负数；
指数位（exponent）占用 8 位，用来表示指数；
小数位（fraction）占用 23 位，用来表示小数，不足位数补 0；

2、double 类型是 64 位，是双精度浮点表示法：

符号位占用 1 位；
指数位占用 11 位；
小数位占用 52 位；

在浮点数中指数位决定了大小范围，因为指数位能表示的数越大则能表示的数越大；而小数位决定了计算精度，因为小数位能表示的数越大，则能计算的精度越大。

float 的小数位只有 23 位，即二进制的 23 位，能表示的最大的十进制数为 2 的 23 次方，即 8388608，即十进制的 7 位，严格点，精度只能百分百保证十进制的 6 位运算。

double 的小数位有 52 位，对应十进制最大值为 4 503 599 627 370 496，这个数有 16 位，所以计算精度只能百分百保证十进制的 15 位运算。

float和double的最值和默认值如下：
float：
float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；

默认值是 0.0f；
最小值：Float.MIN_VALUE=1.4E-45；
最大值：Float.MAX_VALUE=3.4028235E38；
包装类：java.lang.Float；

float 在储存大型浮点数组的时候可节省内存空间；
例子：float f1 = 234.5f。

double：
double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；

默认值是 0.0d；
最小值：Double.MIN_VALUE=4.9E-324；
最大值：Double.MAX_VALUE=1.7976931348623157E308；
包装类：java.lang.Double；

浮点数的默认类型为double类型；
例子：double d1 = 123.4。

字符型和布尔型

在Java中使用char表示字符型数据，使用boolean表示布尔型数据。
boolean：
boolean数据类型表示一位的信息；

只有两个取值：true 和 false；
默认值是 false；
- 包装类：java.lang.Boolean；

这种类型只作为一种标志来记录 true/false 情况；
例子：boolean one = true。

char：
char类型是一个单一的 16 位 Unicode 字符；

最小值是 \u0000（即为0）；
最大值是 \uffff（即为65,535）；
包装类：java.lang.Character；

char 数据类型可以储存任何字符；
例子：char letter = ‘A’;。

数据转换

简单类型数据间的转换，有两种方式：自动转换和强制转换，通常发生在表达式中或方法的参数传递时。

自动转换

当一个较"小"数据与一个较"大"的数据一起运算时，系统将自动将"小"数据转换成"大"数据再进行运算。

而在方法调用时，实际参数较"小"，而被调用的方法的形式参数数据又较"大"时(若有匹配的当然会直接调用匹配的方法)，系统也将自动将"小"数据转换成"大"数据再进行方法的调用。对于多个同名的重载方法，会转换成最"接近"的"大"数据并进行调用。

这些类型由"小"到"大"分别为 (byte，short，char)–int–long–float—double；
这里我们所说的"大"与"小"，并不是指占用字节的多少，而是指表示值的范围的大小；

1、下面的语句可以在Java中直接通过：

byte b;int i=b; long l=b; float f=b; double d=b;

2、如果低级类型为char型，向高级类型（int）转换时，会转换为对应ASCII码值（byte，short，char型均可自动向上转化为int），例如

char c='c'; 
int i=c;
System.out.println("output:"+i);   //输出：output:99;

3、对于byte，short，char三种类型而言，他们是平级的，因此不能相互自动转换，可以使用下述的强制类型转换。

short i=99 ; 
char c=(char)i; 
System.out.println("output:"+c);
//输出：output:c;

强制转换

将"大"数据转换为"小"数据时，你可以使用强制类型转换，即你必须采用下面这种语句格式：

 int n=(int)3.14159/2;
 //用圆括号括起来目标类型，置于变量前

强制转换可能会导致溢出或精度的下降；

总结

对于Java基础数据的总结，我们用一张图来表示，如下：
在这里插入图片描述
6个实心箭头箭头表示无信息丢失的转换；
3个虚箭头表示可能有精度损失的转换；

大数处理

通过第一部分的学习，我们知道一个基本事实：所有的Java基本数据类型均是有上下限的，即有最大值和最小值。

那么，如果如果这些数据的有效区间满足不了我们的需求怎么办？比如，我要处理一个100位的整数数据。

在Java中有两个类BigInteger和BigDecimal分别表示大整数类和大浮点数类，这两个类理论上能够表示无限大的数，只要计算机内存足够大。

BigIntegr

java.math.BigInteger用来表示任意大小的整数，关于BigIntegr我们需要知道如下事情：

1、BigInteger内部用一个int[]数组来模拟一个非常大的整数；

2、BigInteger和Integer、Long一样，也是不可变类，并且也继承自Number类。Number定义了转换为基本类型的几个方法：

转换为byte：byteValue()
转换为short：shortValue()
转换为int：intValue()
转换为long：longValue()
转换为float：floatValue()
转换为double：doubleValue()

因此，通过上述方法，可以把BigInteger转换成基本类型。

3、BigInteger类常用方法如下：

BigInteger abs() 返回大整数的绝对值；
BigInteger add(BigInteger val) 返回两个大整数的和；
BigInteger and(BigInteger val) 返回两个大整数的按位与的结果；
BigInteger andNot(BigInteger val) 返回两个大整数与非的结果；
BigInteger divide(BigInteger val) 返回两个大整数的商；
double doubleValue() 返回大整数的double类型的值；
float floatValue() 返回大整数的float类型的值；
BigInteger gcd(BigInteger val) 返回大整数的最大公约数；
int intValue() 返回大整数的整型值；
long longValue() 返回大整数的long型值；
BigInteger max(BigInteger val) 返回两个大整数的最大者；
BigInteger min(BigInteger val) 返回两个大整数的最小者；
BigInteger mod(BigInteger val) 用当前大整数对val求模；
BigInteger multiply(BigInteger val) 返回两个大整数的积；
BigInteger negate() 返回当前大整数的相反数；
BigInteger not() 返回当前大整数的非；
BigInteger or(BigInteger val) 返回两个大整数的按位或；
BigInteger pow(int exponent) 返回当前大整数的exponent次方；
BigInteger remainder(BigInteger val) 返回当前大整数除以val的余数；
BigInteger leftShift(int n) 将当前大整数左移n位后返回；
BigInteger rightShift(int n) 将当前大整数右移n位后返回；
BigInteger subtract(BigInteger val)返回两个大整数相减的结果；
byte[] toByteArray(BigInteger val)将大整数转换成二进制反码保存在byte数组中；
String toString() 将当前大整数转换成十进制的字符串形式；
BigInteger xor(BigInteger val) 返回两个大整数的异或；

BigDecimal

java.math.BigDecimal用来表示任意大小的小数，关于BigDecimal我们需要知道如下事情：
1、BigDecimal可以表示一个任意大小且精度完全准确的浮点数，常用于财务计算；

2、BigDecimal用scale()表示小数位数，例如：

BigDecimal d1 = new BigDecimal("123.45");
BigDecimal d2 = new BigDecimal("123.4500");
BigDecimal d3 = new BigDecimal("1234500");
System.out.println(d1.scale()); // 2,两位小数
System.out.println(d2.scale()); // 4
System.out.println(d3.scale()); // 0

3、对BigDecimal做加、减、乘时，精度不会丢失，但是做除法时，存在无法除尽的情况，这时，就必须指定精度以及如何进行截断：

BigDecimal d1 = new BigDecimal("123.456");
BigDecimal d2 = new BigDecimal("23.456789");
BigDecimal d3 = d1.divide(d2, 10, RoundingMode.HALF_UP); // 保留10位小数并四舍五入

4、在比较两个BigDecimal的值是否相等时，要特别注意，使用equals()方法不但要求两个BigDecimal的值相等，还要求它们的scale()相等：

BigDecimal d1 = new BigDecimal("123.456");
BigDecimal d2 = new BigDecimal("123.45600");
System.out.println(d1.equals(d2)); // false,因为scale不同
System.out.println(d1.equals(d2.stripTrailingZeros())); // true,因为d2去除尾部0后scale变为2
System.out.println(d1.compareTo(d2)); // 0