大数据运算BigInteger、基本数据类型包装类Integer

大数据运算

当数字，超过long的取值范围，这样的数据是真实存在的，Java认为，超过long的取值范围不称为数字，称为超级大数对象，对象是由类产生：
java.math.BigInteger超级大整数
java.math.BigDecimal超级大的浮点数(精确的浮点运算)

BigInteger

构造方法: new BigInteger(String yal)参数是字符串类型,可以写任意的长度,但是必须是数字
创建BigInteger对象,封装超级大数
方法：+ - * /

返回值	方法名	方法解释
BigInteger	add(BigInteger big)	两个大数求和
BigInteger	substract(BigInteger big)	两个大数减法
BigInteger	multiply(BigInteger big)	两个大数乘法
BigInteger	divide(BigInteger big)	两个大数除法

public static void main(String[] args) {
	//创建BigInteger大数对象,构造方法中,传递字符串
	BigInteger big1 = new BigInteger("1234567890987654321234567890");
	BigInteger big2 = new BigInteger( "23245678908765432456786543");
	//求和big1 + big计算结果,是BigInteger对象
	BigInteger bigAdd = big1 . add(big2);
	System . out . print1n(bigAdd) ;
	//减法big1 - big2
	BigInteger bigSub = big1 . subtract(big2);
	System. out. println(bigSub);
	//乘法big1*big2
	BigInteger bigMul = big1 . multiply(big2);
	System. out. print1n(bigMu1) ;
	//除法big1 / big2
	BigInteger bigDiv = big1. divide(big2);
	System . out . println(bigDiv) ;
}

BigDecimal

精确的浮点数运算.计算财务问题
构造方法：BigDecimal(String val)传递字符串，保证精度，可以任意长度
四则运算和BigInteger几乎一样的
区别在除法运算，出现无限小数

方法返回值	方法名	解释
BigDecimal	divide(BigDecimal big)	两个大数的除法运算高精度
BigDecimal	divide(BigDecimal big,int scale，int round)	参数含义:自定义的精度计算,(取舍)
static int	ROUND_DOWN	舍入模式，直接舍去
static int	ROUND_UP	舍入模式，向上+1
static int	ROUND_HALF_UP	舍入模式，四舍五入

public static void main(String[] args) {
	BigDecimal big1 = new BigDecimal("5.55");
	BigDecimal big2 = new BigDecimal("1 .0005");
	BigDecimal bigMul = big1 . multiply(big2);
	System. out . print1n(bigMul);
	BigDecimal big4 = new BigDecimal("3.55" );
	BigDecimal big5 = new BigDecimal("1.35");
	//除法计算big4 / big5
	BigDecimal bigDiv = big4. divide(big5);
	System. out . print1n(bigDiv);
	//2.62962962962963
	/*
	*
	BigDecimal divisor, int scale, int roundingMode)
	*
	divisor被除数big5
	* scale要保留的位数
	* roundingMode 舍入模式ROUND_ DOWN直接舍去
	* roundingMode舍入模式ROUND_UP向.上+1
	* roundingMode舍入模式 ROUND_ _HALF_ _UP 四舍五入向上+1
	*/
	BigDecimal bigDiv = big4. divide(big5,2, BigDecimal . ROUND_ DOWN) ;
	System. out . println(bigDiv);//2.62
	BigDecimal bigDiv = big4.divide(big5, 4, BigDecimal . ROUND_ UP) ;
	System . out . println(bigDiv);//2.6297
	BigDecimal bigDiv = big4. divide ( big5, 3, BigDec imal . ROUND_ HALF_ UP
);
	System . out . println(bigDiv);//2.630
}

基本数据类型包装类

基本数据类型，提供的功能基本都是运算为主.实际工作中这些功能是不够的，因此提供了一套包装类，作用将基本数据类型变成对象，对象具有的功能就会更多
基本类型包装类：主要实现了一个非常关键的功能：基本类型和字符串之间的互相转换"1"
包装类都在java.lang

基本数据类型	对应的包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

int类型的包装类Integer类，其他的包装类的用法基本都一样的

Integer类的使用

内部包装了一个int数据类型，变成了对象

• 字符串String转成基本数据类型int
  。Integer类静态方法：static int parseInt(String s)字符串转成基本类型int，字符串必须是数字格式

public static void main(String[ ] args) {
	//传递的参数是100,返回值基本类型int
	System . out. println( Integer .parseInt("100" ));//100
}

。Integer对象转换：static Integer valueOf(String val)字符串必须数字格式
。Integer对象的方法: int intValue()字符串转成基本类型int
。Integer转String

public static void main(String[] args) {
	//传递的参数是100,返回值基本类型int
	int i = . Integer . parseInt( "100");
	System . out . println(i+1);
	//创建Integer对象
	Integer integer = new Integer("10");
	//对象的方法intValue(),构造方法中的字符串,转成基本类型
	int j = integer . intValue();
	System. out . print1n(j+1);//11
	//Integer类的静态方法valueOf创建出Integer的对象
	Integer integer2 = Integer . value0f("20");
	int k = integer2. intValue();
	System . out . print1n(k+1);//2
}

//方法一:
Integer类的静态方法toString()
Integer a = 2;
String str = Integer.toString(a) 
//方法二:
Integer类的成员方法toString()
Integer a = 2;
String str = a.toString(); 
//方法三:
String类的静态方法valueOf()
Integer a = 2;
String str = String.valueOf(a);

自动装箱和自动拆箱

自动的装箱和拆箱,无需程序人员参与这个过程但是原理要学习.
是JDK1.5出现
自动装箱：基本数据类型.自动变成对象
自动拆箱：对象，自动变成基本数据类型

//自动装箱和自动拆箱
//好处:实现了基本类型和引用类型的直接计算
public static void main(String[] args) {
	//自动装箱， 基本类型自动变成对象
	/* Integer是类名,引用数据类型
	*引用数据类型变量i指向一个对象
	* 1是基本类型，自动装箱成为对象I
	*/
	Integer i= 1;
	/*
	*i变量是引用类型,保存是内存地址
	*能和1相加吗
	*引用类型变量i自动拆箱,对象变成基本类型1了
	*1+1=2，2赋值变量i
	*i=2计算，进行自动装箱
	*/
	i=i+1;
	System . out . println(i);
}

自动装箱和自动拆箱面试

public static void main(String[] args) {
	Integer i = new Integer(100);
	Integer j = new Integer(100);
	System . out . print1n( i == j); // ==引用类型,比较内存地址false
	System . out . println(i. equals(j)); // equals方法继承父类重写true
	Integer ii = 200; // value0f() = new Integer()
	Integer jj = 200;
	System. out . println(ii == jj); // ==引用类型,比较内存地址false
	System . out . println(ii.equals(jj)); // equals方法继承父类重写true
	Integer iii = 100;
	Integer jjj =100 ;
	System. out . println(iii == jjj); //== 引用类型,比较内存地址true
	System . out. println(iii. equals(jjj)); // true
	//装箱，范围是byte之间，不new对象
	//Integer a = Integer. valueof(1); //源码中value0f方法 里面new Integer对象
}