1.图片
2.默认值和大小
| 数据类型 | 默认值 | 大小 |
|---|---|---|
| boolean | false | 1比特 |
| char | ‘\u0000’ | 2字节 |
| byte | 0 | 1字节 |
| short | 0 | 2字节 |
| int | 0 | 4字节 |
| long | 0L | 8字节 |
| float | 0.0f | 4字节 |
| double | 0.0 | 8字节 |
Tips：
1）bit（比特）
比特作为信息技术的最基本存储单位，非常小，但大名鼎鼎的比特币就是以此命名的，它的简写为小写字母“b”。
同学们都知道，计算机是以二进制存储数据的，二进制的一位，就叫做 1 比特，也就是说，比特要么为 0 要么为 1。
2）Byte（字节）
通常来说，一个英文字符是一个字节，一个中文字符是两个字节。字节与比特的换算关系是：1 字节 = 8 比特。
注意：对于boolean类型来说，不同的Java虚拟机对应的大小也不同，具体请查看官方文档
3.为什么byte类型取值范围是127~（-128）
要想了解为什么，我们需要知道计算机是怎么存储数据的
1.计算机中对数据的二进制存储形式-------补码（下面讨讨论的皆为byte类型）
原码：45:00101101 -45:10101101
在最高位代表符号位区分正数还是负数，0代表正数，1代表负数
反码：45:00101101 -45:11010010
正数的原码和反码相同，负数的反码等于原码的符号位不变，其余各位按位取反
补码：45:00101101 -45:11010011
正数的原码反码和补码都形同，负数的补码等于在其反码基础上末尾+1
2.为什么计算机设计反码？
因为计算机只有加法没有，减法，在做减法运算的时候，可以认为是加上一个负数，这样可以减少计算机电路的复杂度。使用原码进行减法运算会出现问题，例如计算1-1，因为计算机没有加法只有减法，所以计算机自动换算成1+(-1)
1-1=1+(-1)=[00000001]原+[10000001]原=[10000010]原=-2
（符号位也参与运算）
与实际结构不符
1-1=1+(-1)=[00000001]原+[10000001]原=[00000001]反+[11111110]反=[11111111]反=[10000000]原=-0
通过反码计算的结果是11111111在计算一次反就成原码了，得出的结果是正确的，但是有一个问题是 00000000可以代表+0 10000000可以代表-0，其实是一样的，用2个编码实在是浪费。于是出现了补码解决0的符号以及两个编码的问题
这样0用[0000 0000]表示, 而以前出现问题的-0则不存在了
1-1=1+(-1)=[00000001]原+[10000001]原=[00000001]补+[11111111]补=[00000000]补=[00000000]原
这样0用[0000 0000]表示, 而以前出现问题的-0则不存在了.
总结：反码是为了解决减法运算，补码是为了解决反码产生的+-0的问题
3.为什么byte类型是127~（-128）
首先我们用原码表示这么几个我们常见的数
+127：0111 1111、
+1：0000 0001、
+0：0000 0000、
-0：1000 0000、
-1：1000 0001、
-127：1111 1111
那么计算机为什么要表示一个-0呢？总不能把这两个都对应0吧，这显然是资源浪费。
到这里我们都认为最高位是不参与计算数值的，仅仅是一个符号位，按这种思路byte的八位是无论如何也表示不出-128。而“可怜的-0”又不知道自己代表谁，不得而知“可怜的-0”就是-128。
于是我们的计算机当中规定-0的补码就是-128在计算机当中的存储方式。这样也可好可以满足计算机当中的计算。
例如：-128 + 127 = 10000000（-1）
4.浮点类型
1.浮点类型在计算机当中的存储
首先我们来看一下浮点类型在我们的计算机当中是如何存储的
float存储需求是4字节（32位）, 其中1位最高位是符号位，中间8位表示阶位，后32位表示值
double存储需求是8字节（64为）,其中1位最高位是符号位，中间8位表示阶位，后52位表示值
2.浮点类型的精度丢失
①：产生精度丢失的原因
public class SimpleTest {
public static void main(String[] args) {
System.out.println(1.2 - 1);
}
}
输出：0.19999999999999996，这和我们预期的情况完全不符。
因为将10进制的0.2转化为2进制进行存储，算法是乘以2直到没有了小数为止。
0.2的2进制从上到下可以表示为 00110…
注意：上面的计算过程循环了，也就是说*2永远不可能消灭小数部分，这样算法将无限下去。很显然，小数的二进制表示有时是不可能精确的 。其实道理很简单，十进制系统中能不能准确表示出1/3呢？同样二进制系统也无法准确表示1/10。这也就解释了为什么浮点型减法出现了"减不尽"的精度丢失问题。
精度丢失就是我们的位数不够表示我们整个数值了
②：如何解决精度丢失 使用BigDecimal类
5.char类型
1.字符类型实际上是一个16位无符号整数，这个数对应字符的编码
2.java字符类型采用Unicode字符集编码。Unicode是世界通用的定字长字符集，所用字符都是16位
转义字符
对于不方便输出的字符可以采用转义字符表示：
‘\n’ 表示回车
’\r‘ 表示换行符
’\‘ 表示反斜杠( \ )
’’‘ 表示单引号( ’ )
‘"’ 表示双引号( " )
6.boolean类型
boolean（布尔）类型有两个值：flase和true，用来判断逻辑条件。数值型和boolean之间不能直接转化。
7.数据类型转换(自动类型转换和强转)
1.自动类型转换
1.什么时候发生自动类型转换 取值范围大的数据类型 变量名 = 取值范围小的数据类型 -> 小类型自动提升为大类型 2.注意: 当取值范围小的类型和取值范围大的类型做运算,也会发生自动类型转换,小转大
public class Test01{
public static void main(String[] args){
/*
等号右边:100->默认类型是int
等号左边:long型的变量
将取值范围小的int型数据赋值给了取值范围大的long型,发生自动类型转换
*/
//long num1 = 100;
long num2 = 100L;
System.out.println(num2);
/*
等号右边:10->默认类型是int
等号左边:double类型的变量
将取值范围小的int型数据赋值给了取值范围大的double型,发生自动类型转换
int型的值转成double型的
*/
double num3 = 10;
System.out.println(num3);//10.0
double a = 2.5;
/*
当取值范围小的类型和取值范围大的类型做运算,也会发生自动类型转换,小转大
double = double+int
double = double+double
*/
double result = a+10;
System.out.println(result);
}
}
2.强制类型转换
1.什么时候需要强制类型转换 取值范围小的数据类型 变量名 = 取值范围大的数据类型 -> 报错,需要强转 2.怎么强转? 取值范围小的数据类型 变量名 = (取值范围小的数据类型)取值范围大的数据类型
public class Test02{
public static void main(String[] args){
/*
等号右边:2.5 默认类型为double型
等号左边:int型的变量
将取值范围大的类型取值给取值范围小的类型->报错->需要强转
*/
//int num1 = 2.5;
int num1 = (int)2.9;
System.out.println(num1);
int num2 = (int)100L;
System.out.println(num2);
/*
等号右边:2.5 默认类型double
等号左边:float
将取值范围大的类型取值给取值范围小的类型->报错->需要强转
*/
//float num3 = (float)2.5;
float num3 = 2.5F;
System.out.println(num3);
}
}
3.强转的注意事项
1.不要随意强转,强转容易导致数据精度损失,以及数据溢出 2.byte,short如果等号右边是常量,只要不超出byte和short的取值范围,不用强转,因为jvm自动强转了 byte,short如果等号右边有变量参与,结果再赋值给byte,short的变量,byte,short会自动提升为int,需要自己手动强转 3.char类型的数据一旦参与运算,也会被自动提升为int型 char类型一旦被变成int型,字符会自动去编码表中查询此字符对应的int值-> ASCII码表 如果字符在ASCII码表中找不到对应的int值,会去unicode码表(万国码)中查询
public class Test03{
public static void main(String[] args){
//精度损失
int num1 = (int)2.9;
System.out.println(num1);//2
/*
数据溢出现象
int型占4个字节 1个字节是8个二进制位
int型数据最多能用32位二进制表示
100亿换成二进制:36位二进制
比int多出来 4位 二进制,会把最前面的4位二进制干掉,这4位是溢出的
剩下的二进制算回十进制就是1410065408
*/
int num2 = (int)10000000000L;
System.out.println(num2);// 1410065408
}
}
public class Test04{
public static void main(String[] args){
byte num1 = 10;
System.out.println(num1);
/*
byte = byte+int
byte = int+int
*/
//byte result1 = num1+10;
byte result1 = (byte)(num1+10);
System.out.println(result1);
char num2 = 'a';
int result02 = num2+0;
System.out.println(result02);
System.out.println('a'+0);//97
System.out.println('A'+0);//65
System.out.println('0'+0);//48
System.out.println(' '+0);//32
System.out.println('中'+0);//20013
//自动类型转换 char类型的数据会自动提升为int型,去查码表了
int num3 = 'a';
}
}
装箱与拆箱
装箱：把基本类型的数据，包装到包装类中（基本类型的数据->包装类）
构造方法：
Integer(int value) 构造一个新分配的Integer对象，他表示指定的int值。 Integer(String s) 构造一个新分配的Integer对象，他表示String参数所指示的int值。传递的字符串必须是基本类型的字符串，否则会出现抛出异常 例：“100”正确，“a"抛出异常
静态方法：
static Integer valueOf(int i）返回一个表示指定的int值得Integer实例
static Integer valueOf(String s）返回保存指定的String的值得Integer对象
拆箱：在包装类中取出基本数据类型的数据(包装类->基本数据类型）
成员方法： int intValue() 以int类型返回该 Integer的值
/*
* 装箱：把基本类型的数据，包装到包装类中（基本类型的数据->包装类）
* 构造方法：
* Integer(int value) 构造一个新分配的Integer对象，他表示指定的int值。
* Integer(String s) 构造一个新分配的Integer对象，他表示String参数所指示的int值。
* 传递的字符串必须是基本类型的字符串，否则会出现抛出异常 例：“100”正确，“a"抛出异常
*
* 静态方法：
* static Integer valueOf(int i）返回一个表示指定的int值得Integer实例
* static Integer valueOf(String s）返回保存指定的String的值得Integer对象
* 拆箱：在包装类中取出基本数据类型的数据(包装类->基本数据类型）
* 成员方法：
* int intValue() 以int类型返回该 Integer的值
* */
public class Demo01Integer {
public static void main(String[] args) {
//装箱：把基本类型的数据，包装到包装类中（基本类型的数据->包装类）
//构造方法
Integer in1 = new Integer(1);
System.out.println(in1);//重写了toString()方法
Integer in2 = new Integer("2");
System.out.println(in2);
//静态方法：
Integer in3 = Integer.valueOf(1);
System.out.println(in3);
// Integer in4 = Integer.valueOf("a");//NumberFormatException数字格式化错误
Integer in4 = Integer.valueOf("2");
System.out.println(in4);
//拆箱：在包装类中取出基本数据类型的数据(包装类->基本数据类型）
int i = in1.intValue();
System.out.println(i);
}
}
自动拆箱与装箱
自动拆箱与自动装箱：基本类型的数据和包装类之间可以互相转换，jdk1.5之后出现的新特性
import java.util.ArrayList;
/*
* 自动拆箱与自动装箱：基本类型的数据和包装类之间可以互相转换
* jdk1.5之后出现的新特性
* */
public class Demo02Integer {
public static void main(String[] args) {
/*
* 自动装箱：直接把int类型的整数赋值给包装类
* Integer in = 1; 就相当于Integer in = new Integer(1);
* */
Integer in = 1;
/*
* 自动拆箱：in 是包装类，无法直接参与运算，可以自动转换为基本数据雷兴国，在进行计算
* in+2；相当于in.intValue()+2
* in = in.inValue()+2 = 3;又是一个自动装箱
* */
in = in+2;
ArrayList<Integer> list = new ArrayList<>();
/*
* ArrayList集合无法直接存储整数，可以存储Integer包装类
* */
list.add(1);//-->隐含了一个自动装箱，list.add(new Integer(1));
Integer a = list.get(0);//-->隐含了一个自动拆箱，list.get(o).intValue();
}
}
