Java基本数据类型及源码简析

1.Java的基本数据类型总共有八种,按照不同的类型分为整数型:byte,short,int,long;浮点数型:float,double;字符型:char;布尔型:Boolean.

每种基本类型所占的储存空间的大小是固定不变的,这相对于其他大多数语言来说Java更具有移植性,其实基本类型是一种特殊的"引用"类型,详细解析可以参考Java编程思想PDF版下载地址 提取码:i6n4

类型	大小	最小值	最大值	默认值
byte	1byte=8bit	-128	127	0
short	2byte=16bit	-32768	32767	0
int	4byte=32bit	-2147483648	2147483647	0
long	8byte=64bit	-2^63	2^63-1	0L
float	4byte=32bit	1.4E-45	3.4028235E38	0.0f
double	8byte=64bit	4.9E-324	1.7976931348623157E308	0.0d
char	2byte=16bit	Unicode 0	Unicode 65535	\u000
boolean	–	–	–	false
void	–	–	–	–

		byte bmax = Byte.MAX_VALUE;
		byte bmin = Byte.MIN_VALUE;
		System.out.println("最大值:"+bmax+"最小值:"+bmin);//最大值:127最小值:-128
		short smax = Short.MAX_VALUE;
		short smin = Short.MIN_VALUE;
		System.out.println("最大值:"+smax+"最小值:"+smin);//最大值:32767最小值:-32768
		int imax = Integer.MAX_VALUE;
		int imin = Integer.MIN_VALUE;
		System.out.println("最大值:"+imax+"最小值:"+imin);//最大值:2147483647最小值:-2147483648
		long lmax = Long.MAX_VALUE;
		long lmin = Long.MIN_VALUE;
		System.out.println("最大值:"+lmax+"最小值:"+lmin);//最大值:9223372036854775807最小值:-9223372036854775808
		float fmax = Float.MAX_VALUE;
		float fmin = Float.MIN_VALUE;
		System.out.println("最大值:"+fmax+"最小值:"+fmin);//最大值:3.4028235E38最小值:1.4E-45
		double dmax = Double.MAX_VALUE;
		double dmin = Double.MIN_VALUE;
		System.out.println("最大值:"+dmax+"最小值:"+dmin);//最大值:1.7976931348623157E308最小值:4.9E-324

注解:
1.基本类型都有与之对应的包装类,使其可以在堆中创建一个非基本对象,用来表示对应的基本类型,来使用一系列方法.
2.boolean类型所占存储空间的大小没有明确指定,仅定义能够取字面值true或false
3.char只能保存单个字符,用单引号括起来,char也可以存储一个数字,比如

char a = 97;//在使用时会把数字对照ASCII码表转换成字符
System.out.println(a);//打印结果为a(ascii表中97对应字符a)

值得注意的是ASCII表中只规定了数字0-127对应的字符,128-65535默认对应的字符通通都是?,其中常用的对应比如大小写字母,0-9数字如下:

ASCII码数字	对应字符
48~57	0~9
65~90	A~Z
97~122	a~z

4.float浮点数类型属于单精度,对小数位运算不精确;double属于双精度对小数运算更精确(两者的运算都不精确),一般通过BigInteger和BigDecimal类来实现高精度计算.
5.char类型可以储存一个中文汉字,因为 Java 中使用的编码是 Unicode（不选择任何特定的编码，直接使用字符在字符集中的编号，这是统一的唯一方法），一个 char 类型占 2 个字节（16 比特），所以放一个中文是没问题的。

1.基本类型的赋值运算

	public static void main(String[] args) {
/*----------------why???-------------*/
		byte a = 12;
		byte a1= a+1;//报错
		short b = 12;
		short b1 = b+1;//报错
		int c = 12;
		int c1 = c+1;
		long d = 12;
		long d1 = d+1;
		float e = 12.0;//错，右面是double类型，解决方案加F
		double f = 12.0;
		int x = a/5;
		System.out.println(x);//结果为2 int类型
		System.out.println(a/5.0); //结果为2.4(真实值),double类型
		/*说明计算结果的数据类型与最大类型一致*/
	}

1.byte，short，char三种比int小的整数可以用范围内的值直接赋值
2.整数字面值是int类型;浮点数的字面值是double类型
3.计算结果的数据类型，与最大类型一致
4.byte,short,char三种比int小的整数，运算时会先自动转换成int

1.2基本类型的类型转换

小类型到大类型自动转换(隐式)byte a =120;Int b=a;//直接转

大到小需要强制转换(显示)int x = 356;byte y=(byte) x;//强制转换可能造成数据损失

2.包装类 b

基本类型是创建一个并非"引用"的变量,直接储存"值"并置于堆栈中,更加高效.
但是基础数据类型好像只能用来赋值?
基于这个问题Java引用了将byte转为对象调用方法进行数据的操作–包装类

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
float	Float
double	Double
char	Character
boolean	Boolean
void	Void

1.1常用方法

所有包装类都是继承于java.lang.Number类(Viod直接继承Object类)

各子类的特有方法可以查看API了解

1.2自动装箱和自动拆箱

自动装箱:基本类型–>包装类;目的是使用包装类中的功能

int a = 5;
Integer b = a;//底层自动执行了valueOf(),返回一个对应int值的Integer实例

自动拆箱:包装类–>基本类型;目的是拿到包装类的值做运算

Integer a = 5;
int b = a+1;//在进行运算时,底层对a自动执行了intValue()方法,转为int类型再运算

有一个需要注意的小细节:在自动装箱时对于值从–128到127之间的值，它们被装箱为Integer对象后，会存在内存中被重用，始终只存在一个对象 。而如果超过了从–128到127之间的值，被装箱后的Integer对象并不会被重用，即相当于每次装箱时都新建一个 Integer对象。

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
        //IntegerCache.low为-128,IntegerCache.high默认为127
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
    }

Integer自动装箱池的范围是-128~127
Byte,Short,Long范围是-128~127
Character范围是0~127
Float和Double没有自动装箱池

2.BigInteger和BigDecimal

BigDecimal工具类：常用来解决精确的浮点数运算。
BigInteger工具类：常用来解决超大的整数运算。

2.1.创建对象

BigDecimal.valueOf(2);

2.2.常用方法

add(BigDecimal bd)： 做加法运算
substract(BigDecimal bd) ： 做减法运算
multiply(BigDecimal bd) ： 做乘法运算
divide(BigDecimal bd) ： 做除法运算
divide(BigDecimal bd,保留位数,舍入方式)：除不尽时使用
setScale(保留位数，舍入方式)：同上
pow(int n)：求数据的几次幂

实例:接收用户输入的两个数字,做运算

 public static void main(String[] args) {
              double a = new Scanner(System.in).nextDouble();
              double b = new Scanner(System.in).nextDouble();
              System.out.println(a+b);
              System.out.println(a-b);
              System.out.println(a*b);
              System.out.println(a/b);//不精确             
              System.out.println(“===上面的除法不精确===”);
              
              BigDecimal bd1 = BigDecimal.valueOf(a);
              BigDecimal bd2 = BigDecimal.valueOf(b);
              BigDecimal bd3;
              bd3=bd1.add(bd2);
              System.out.println(bd3.doubleValue());           
              bd3=bd1.subtract(bd2);
              System.out.println(bd3.doubleValue());
       		  bd3=bd1.multiply(bd2);
              System.out.println(bd3.doubleValue());
              //bd3=bd1.divide(bd2);//报错除不尽

              //保留位数和舍入方式
              bd3=bd1.divide(bd2,5,BigDecimal.ROUND_HALF_UP);
              bd3=bd3.setScale(2, BigDecimal.ROUND_HALF_UP);//保留两位
              System.out.println(bd3.doubleValue());        
       }