17_常用API_第17天（包装类、System、Math、Arrays、大数据运算）_讲义

一时失言乱红尘 2022-04-17 06:05 149阅读 0赞

今日内容介绍  
 基本类型包装类  
 System  
 Math  
 Arrays  
 BigInteger  
 BigDecimal  
第1章 基本类型包装类  
大家回想下，在第二天我们学习Java中的基本数据类型时，说Java中有8种基本的数据类型，可是这些数据是基本数据，想对其进行复杂操作，变的很难。怎么办呢？  
1.1 基本类型包装类概述  
在实际程序使用中，程序界面上用户输入的数据都是以字符串类型进行存储的。而程序开发中，我们需要把字符串数据，根据需求转换成指定的基本数据类型，如年龄需要转换成int类型，考试成绩需要转换成double类型等。那么，想实现字符串与基本数据之间转换怎么办呢？  
Java中提供了相应的对象来解决该问题，基本数据类型对象包装类：java将基本数据类型值封装成了对象。封装成对象有什么好处？可以提供更多的操作基本数值的功能。  
\*A:基本数据类型对象包装类概述  
\*a.基本类型包装类的产生  
在实际程序使用中，程序界面上用户输入的数据都是以字符串类型进行存储的。  
而程序开发中，我们需要把字符串数据，根据需求转换成指定的基本数据类型，  
如年龄需要转换成int类型，考试成绩需要转换成double类型等  
\*b.八种基本类型对应的包装类  
char Character  
int Integer  
byte Byte  
short Short  
long Long  
float Float  
double Double  
boolean Boolean  
**其中需要注意int对应的是Integer，char对应的Character，其他6个都是基本类型首字母大写即可。**  
基本数据类型对象包装类特点：用于在基本数据和字符串之间进行转换。  
 将字符串转成基本类型： ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]  
parseXXX(String s);其中XXX表示基本类型，参数为可以转成基本类型的字符串，如果字符串无法转成基本类型，将会发生数字转换的问题 NumberFormatException

package cn.incast.demo01;
    /*
     * Integer 类在对象中包装了一个基本类型 int 的值。
     * Integer 类型的对象包含一个 int 类型的字段。 
     * static int parseInt(String s) 
     * 将字符串参数作为有符号的十进制整数进行解析 
     */
    public class IntegerDemo {
    	public static void main(String[] args) {
    		System.out.println("function()");
    		function();
    		System.out.println("function_1()");
    		function_1();
    		System.out.println("function_2()");
    		function_2();
    		System.out.println("function_3()");
    		function_3();
    	}
    	/*
    	 * Integer类构造方法
    	 * 	  Integer(String s)
    	 * 	    将数字格式的字符串,传递到Integer类的构造方法中
    	 *    创建Integer对象,包装的是一个字符串
    	 *    int intValue() 以 int 类型返回该 Integer的值 
    	 * 	   将构造方法中的字符串,转成基本数据类型,调用方法,非静态的,intValue
    	 */
    	public static void function_3(){
    		Integer in = new Integer("100");
    		int i = in.intValue();
    		System.out.println(i--);
    	}
    	/*
    	 * 如何将基本类型int,变成字符串
    	 * int => String
    	 * Integer类中的静态方法toString()
    	 * 0-9 A-Z java最大进制36位
    	 */
    	public static void function_2(){
    		int i = 3;
    		String s = i + "";
    		System.out.println(s+1);
    		//static String toString(int i) 
            //返回一个表示指定整数的 String 对象 
    		String s1 = Integer.toString(5);
    		System.out.println(s1 + 1);
    		//static String toString(int i, int radix) 
    		//返回用第二个参数指定基数表示的第一个参数的字符串表示形式 
    		String s2 = Integer.toString(5,2);
    		System.out.println(s2);
    	}
    	/*
    	 * Integer类中静态方法static int parseInt(String s, int radix) 
    	 * radix-基数,其实就是进制
    	 * Integer.parseInt("110", 2) ==> 前面的数字是二进制,但是方法parseInt运行结果是十进制
    	 * 使用第二个参数指定的基数，将字符串参数解析为有符号的整数 
    	 */
    	public static void function_1(){
    		int i = Integer.parseInt("A", 16);
    		System.out.println(i);
    	}
    	/*
    	 * Integer类中静态方法parseInt(String s)返回基本数据类型
    	 * 要求：字符串必须是数字格式的
    	 */
    	public static void function(){
    		int it = Integer.parseInt("12");
    		System.out.println(it/2);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]

System.out.println(Integer.parseInt("123") + 2);
    //打印结果为 125

 将基本数值转成字符串有3种方式：  
 基本类型直接与””相连接即可；34+""  
 调用String的valueOf方法；String.valueOf(34) ；  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]  
 调用包装类中的toString方法；Integer.toString(34) ；  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]  
1.2 基本类型和对象转换  
使用int类型与Integer对象转换进行演示，其他基本类型转换方式相同。  
 基本数值---->包装对象  
![在这里插入图片描述][20181113223703191.jpg]

Integer i = new Integer(4);//使用构造函数函数
    Integer ii = new Integer("4");//构造函数中可以传递一个数字字符串

![在这里插入图片描述][20181113223838644.jpg]

Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法
    Integer iiii = Integer.valueOf("4");//使用包装类中的valueOf方法

 包装对象---->基本数值  
![在这里插入图片描述][20181113224259827.jpg]

int num = i.intValue();

package cn.incast.demo01;
    /*
     * Integer类中的其他方法
     * 包括三个方法,和2个静态成员变量
     */
    public class IntegerDemo01 {
    	public static void main(String[] args) {
    		function();
    		System.out.println("function_1()");
    		function_1();
    	}
    	/*
    	 * Integer类的3个静态方法
    	 * 做进制的转换
    	 * 十进制转成二进制 static String toBinaryString(int i)  
    	 * 十进制转成八进制static String toOctalString(int i) 
    	 * 以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式
    	 * static String toHexString(int i)  
    	 */
    	public static void function_1(){
    		System.out.println(Integer.toBinaryString(99));
    		System.out.println(Integer.toOctalString(99));
    		System.out.println(Integer.toHexString(99));
    	}
    	/*
    	 * Integer类的静态成员变量
    	 * static int MAX_VALUE  值为 231－1 的常量，它表示 int 类型能够表示的最大值
    	 * static int MIN_VALUE  值为 －231 的常量，它表示 int 类型能够表示的最小值
    	 * MAX_VALUE
    	 * MIN_VALUE
    	 */
    	public static void function(){
    		System.out.println(Integer.MAX_VALUE);
    		System.out.println(Integer.MIN_VALUE);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]  
1.3 自动装箱拆箱  
在需要的情况下，基本类型与包装类型可以通用。有些时候我们必须使用引用数据类型时，可以传入基本数据类型。  
比如：  
基本类型可以使用运算符直接进行计算，但是引用类型不可以。而基本类型包装类作为引用类型的一种却可以计算，原因在于，Java”偷偷地”自动地进行了对象向基本数据类型的转换。  
相对应的，引用数据类型变量的值必须是new出来的内存空间地址值，而我们可以将一个基本类型的值赋值给一个基本类型包装类的引用。原因同样在于Java又”偷偷地”自动地进行了基本数据类型向对象的转换。  
 自动拆箱：对象转成基本数值  
 自动装箱：基本数值转成对象

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
    i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5; 加法运算完成后，再次装箱，把基本数值转成对象。

 自动装箱(byte常量池)细节的演示  
当数值在byte范围之内时，进行自动装箱，不会新创建对象空间而是使用医来已有的空间。

Integer a = new Integer(3);
    Integer b = new Integer(3);
    System.out.println(a==b);//false
    System.out.println(a.equals(b));//true
    System.out.println("---------------------");
    Integer x = 127;
    Integer y = 127;
    //在jdk1.5自动装箱时，如果数值在byte范围之内，不会新创建对象空间而是使用原来已有的空间。
    System.out.println(x==y); //true
    System.out.println(x.equals(y)); //true

第2章 System类  
2.1 概念  
在API中System类介绍的比较简单，我们给出定义，System中代表程序所在系统，提供了对应的一些系统属性信息，和系统操作。  
System类不能手动创建对象，因为构造方法被private修饰，阻止外界创建对象。System类中的都是static方法，类名访问即可。在JDK中，有许多这样的类。  
2.2 常用方法  
![在这里插入图片描述][20181114090853251.jpg]  
 currentTimeMillis() 获取当前系统时间与1970年01月01日00:00点之间的毫秒差值  
 exit(int status) 用来结束正在运行的Java程序。参数传入一个数字即可。通常传入0记为正常状态，其他为异常状态  
 gc() 用来运行JVM中的垃圾回收器，完成内存中垃圾的清除。  
 getProperty(String key) 用来获取指定键(字符串名称)中所记录的系统属性信息  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]  
 arraycopy方法，用来实现将源数组部分元素复制到目标数组的指定位置  
2.3 System类的方法练习  
 练习一：验证for循环打印数字1-9999所需要使用的时间（毫秒）

public static void main(String[] args) {
         long start = System.currentTimeMillis();
    	for (int i=0; i<10000; i++) {
             System.out.println(i);
    }
    long end = System.currentTimeMillis();
    System.out.println("共耗时毫秒：" + (end-start) );
    }

 练习二：将src数组中前3个元素，复制到dest数组的前3个位置上  
复制元素前：src数组元素\[1,2,3,4,5\]，dest数组元素\[6,7,8,9,10\]  
复制元素后：src数组元素\[1,2,3,4,5\]，dest数组元素\[1,2,3,9,10\]

public static void main(String[] args) {
    int[] src = new int[]{1,2,3,4,5};
    int[] dest = new int[]{6,7,8,9,10};
    System.arraycopy( src, 0, dest, 0, 3);
    代码运行后：两个数组中的元素发生了变化
    src数组元素[1,2,3,4,5]
    dest数组元素[1,2,3,9,10]
    }

 练习三：循环生成100-999之间的的三位数并进行打印该数，当该数能被10整除时，结束运行的程序

public static void main(String[] args){
         Random random = new Random();
    	while(true){
        int number = random.nextInt(900)+100; //0-899 + 100
        if (nmumber % 10 == 0) {
            System.exit(0);
    }
    }
    }

package cn.incast.demo02;
    
    public class Person {
    	public void finalize(){
    		System.out.println("垃圾收取了");
    	}
    }

package cn.incast.demo02;
    
    public class SystemDemo {
    	public static void main(String[] args) {
    		System.out.println("function()");
    		function();
    		System.out.println("function_1()");
    		//function_1();
    		System.out.println("function_2()");
    		function_2();
    		System.out.println("function_3()");
    		function_3();
    		System.out.println("function_4()");
    		function_4();
    	}
    	/*
    	 * 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束
    	 * static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
    	 * src - 要复制的源数组
    	 * srcPos - 源数组中的起始位置。
    	 * dest - 复制后的目标数组。
    	 * destPos - 目标数据中的起始位置。
    	 * length - 要复制的数组元素的数量 
    	 */
    	public static void function_4(){
    		int[] src = {11,22,33,44,55,66};
    		int[] desc = {77,88,99,0};
    		//native调用的本地方法栈
    		System.arraycopy(src, 1, desc, 1, 2);
    		for (int i = 0; i < desc.length; i++) {
    			//System.out.print输出的字是黑色的，System.err.print输出的字是红色的
    			System.out.println(desc[i]);
    		}
    	}
    	/* 
    	 * 获取当前操作系统的属性
    	 * static Properties getProperties() 
    	 */
    	public static void function_3(){
    		System.out.println(System.getProperties());
    	}
    	/*
    	 * JVM在内存中,收取对象的垃圾
    	 * static void gc()
    	 */
    	public static void function_2(){
    		new Person();
    		new Person();
    		new Person();
    		new Person();
    		new Person();
    		new Person();
    		new Person();
    		new Person();
    		new Person();	
    		System.gc();
    	}
    	/*
    	 * 退出虚拟机,所有程序全停止
    	 * static void exit(int status) 
    	 * static void exit(0)
    	 */
    	public static void function_1(){
    		System.exit(0);
    		while(true){
    			System.out.println("hello");
    		}
    	}
    	/*
    	 * 获取系统当前毫秒值
    	 * static long currentTimeMillis()
    	 * 对程序执行时间进行测试
    	 * 嵌套循环效率很低
    	 */
    	public static void function(){
    		long start = System.currentTimeMillis();
    		for (int i = 0; i < 10000; i++) {
    //			for (int j = 0; j < 10000; j++) {
    //				System.out.println(i);
    //			}
    		}
    		long end = System.currentTimeMillis();
    		System.out.println(end - start);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]  
第3章 Math类  
3.1 概念  
Math 类是包含用于执行基本数学运算的方法的数学工具类，如初等指数、对数、平方根和三角函数。  
类似这样的工具类 ，其所有方法均为静态方法，并且一般不会创建对象。如System类  
工具类，代表能够完成一系列功能的类，在使用它们时，不用创建对象，该类中方法为静态方法  
3.2 常用方法  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]  
 abs方法,结果都为正数

double d1 = Math.abs(-5); // d1的值为5
    double d2 = Math.abs(5); // d2的值为5

 ceil方法，结果为比参数值大的最小整数的double值

double d1 = Math.ceil(3.3); //d1的值为 4.0
    double d2 = Math.ceil(-3.3); //d2的值为 -3.0
    double d3 = Math.ceil(5.1); // d3的值为 6.0

 floor方法，结果为比参数值小的最大整数的double值

double d1 = Math.floor(3.3); //d1的值为3.0
    double d2 = Math.floor(-3.3); //d2的值为-4.0
    double d3 = Math.floor(5.1); //d3的值为 5.0

 max方法，返回两个参数值中较大的值

double d1 = Math.max(3.3, 5.5); //d1的值为5.5
    double d2 = Math.max(-3.3, -5.5); //d2的值为-3.3

 min方法，返回两个参数值中较小的值

double d1 = Math.min(3.3, 5.5); //d1的值为3.3
    double d2 = Math.max(-3.3, -5.5); //d2的值为-5.5

 pow方法，返回第一个参数的第二个参数次幂的值

double d1 = Math.pow(2.0, 3.0); //d1的值为 8.0
    double d2 = Math.pow(3.0, 3.0); //d2的值为27.0

 round方法，返回参数值四舍五入的结果

double d1 = Math.round(5.5); //d1的值为6.0
    double d2 = Math.round(5.4); //d2的值为5.0

 random方法，产生一个大于等于0.0且小于1.0的double小数

double d1 = Math.random();

package cn.incast.demo03;
    /*
     * 数学计算的工具类
     * java.lang.Math静态方法组成
     */
    public class MathDemo {
    	public static void main(String[] args) {
    		function();
    		function_1();
    		function_2();
    		function_3();
    		function_4();
    		function_5();
    		function_6();
    	}
    	/*
    	 * static int round(float a)  
    	 * 获取参数的四舍五入值,取整数
    	 * 返回最接近参数的 int
    	 * 结果将舍入为整数：加上 1/2
    	 * 对结果调用 floor 并将所得结果强制转换为 int 类型
    	 */
    	public static void function_6(){
    		double d = Math.round(12.43);
    		System.out.println(d);
    	}
    	/*
    	 * static double random() 返回随机数0.0-1.0
    	 * 来源,也是Random类
    	 */
    	public static void function_5(){
    		for (int i = 0; i < 10; i++) {
    			double d = Math.random();
    			System.out.println(d);
    		}
    	}
    	/*
    	 * static double sqrt(double a)  
    	 * 返回a的平方根
    	 */
    	public static void function_4(){
    		double d = Math.sqrt(2);
    		//double d = Math.sqrt(-2);//NaN
    		System.out.println(d);
    	}
    	/*
    	 * static double pow(double a, double b) 
    	 * 返回a的b次方
    	 */
    	public static void function_3(){
    		double d = Math.pow(2, 3);
    		System.out.println(d);
    	}
    	/*
    	 * static double floor(double a)  
    	 * 返回小于或者等于参数d的最大整数
    	 */
    	public static void function_2(){
    		double d = Math.floor(1.5);
    		System.out.println(d);
    	}
    	/*
    	 * static double ceil(double a)  
    	 * 返回大于或者等于参数d的最小整数
    	 * 6 7 8 9  Math.ceil(5.1) = 6
    	 *  Math.ceil(-5.1) = -5.0
    	 */
    	public static void function_1(){
    		double d = Math.ceil(-5.1);
    		System.out.println(d);
    	}
    	/*
    	 * static int abs(int a)  返回 int 值的绝对值
    	 */
    	public static void function(){
    		int i = Math.abs(-3);
    		//int i = abs(-3);
    		System.out.println(i);
    	}
    	public static int abs(int i){
    		if(i >= 0){
    			return i;
    		}else{
    			return -i;
    		}
    	}
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]  
第4章 Arrays类  
4.1 概念  
此类包含用来操作数组（比如排序和搜索）的各种方法。需要注意，如果指定数组引用为 null，则访问此类中的方法都会抛出空指针异常NullPointerException。  
4.2 常用方法  
![在这里插入图片描述][20181114092631498.jpg]  
 sort方法，用来对指定数组中的元素进行排序（元素值从小到大进行排序）

//源arr数组元素{1,5,9,3,7}, 进行排序后arr数组元素为{1,3,5,7,9}
    int[] arr = {1,5,9,3,7};
    Arrays.sort( arr );

 toString方法，用来返回指定数组元素内容的字符串形式

int[] arr = {1,5,9,3,7};
    String str = Arrays.toString(arr); // str的值为[1, 3, 5, 7, 9]

 binarySearch方法，在指定数组中，查找给定元素值出现的位置。若没有查询到，返回位置为-1。要求该数组必须是个有序的数组。

int[] arr = {1,3,4,5,6};
    int index = Arrays.binarySearch(arr, 4); //index的值为2
    int index2= Arrasy.binarySearch(arr, 2); //index2的值为-1

4.3 Arrays类的方法练习  
 练习一：定义一个方法，接收一个数组，数组中存储10个学生考试分数，该方法要求返回考试分数最低的后三名考试分数。

public static int[] method(double[] arr){
        Arrays.sort(arr); //进行数组元素排序（元素值从小到大进行排序）
        int[] result = new int[3]; //存储后三名考试分数
        System.arraycopy(arr, 0, result, 0, 3);//把arr数组前3个元素复制到result数组中
    return result;
    }

package cn.incast.demo04;
    
    import java.util.Arrays;
    
    /*
     * 数组的工具类,包含数组的操作
     * java.util.Arrays
     */
    public class ArraysDemo {
    	public static void main(String[] args) {
    		function();
    		System.out.println("funtion_1");
    		funtion_1();
    		System.out.println("funtion_2");
    		funtion_2();
    	}
    	/*
    	 * static String toString(int[] a)  
    	 * 将数组转换成字符串
    	 */
    //	public static String toString(int[] a) {
    //        if (a == null)
    //            return "null";
    //        int iMax = a.length - 1;
    //        if (iMax == -1)
    //            return "[]";
    //
    //        StringBuilder b = new StringBuilder();
    //        b.append('[');
    //        for (int i = 0; ; i++) {
    //            b.append(a[i]);
    //            if (i == iMax)
    //                return b.append(']').toString();
    //            b.append(", ");
    //        }
    //    }
    	public static void funtion_2(){
    		int[] arr = {1,4,7,9,11,15,18};
    		String s = Arrays.toString(arr);
    		System.out.println(s);
    	}
    	/*
    	 * static int binarySearch(int[] a, int key) 
    	 * 使用二分搜索法来搜索指定的 int 型数组，以获得指定的值
    	 * 返回元素在数组中出现的索引
    	 * 元素不存在,返回的是(-插入点-1)
    	 * 如果它包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
    	 * 插入点 被定义为将键插入数组的那一点：
    	 * 即第一个大于此键的元素索引，如果数组中的所有元素都小于指定的键，则为 a.length。
    	 * 注意，这保证了当且仅当此键被找到时，返回的值将 >= 0
    	 */
    	public static void funtion_1(){
    		int[] arr = {1,4,7,9,11,15,18};
    		int index = Arrays.binarySearch(arr, 7);
    		System.out.println(index);
    	}
    	/*
    	 * public static void sort(int[] a)
    	 * 对指定的 int 型数组按数字升序进行排序
    	 * 该排序算法是一个经过调优的快速排序法
    	 */
    	public static void function(){
    		int[] arr = {5,1,4,7,8,0};
    		Arrays.sort(arr);
    		for (int i = 0; i < arr.length; i++) {
    			System.out.println(arr[i]);
    		}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]  
第5章 大数据运算  
5.1 BigInteger  
java中long型为最大整数类型,对于超过long型的数据如何去表示呢.在Java的世界中,超过long型的整数已经不能被称为整数了,它们被封装成BigInteger对象.在BigInteger类中,实现四则运算都是方法来实现,并不是采用运算符.  
BigInteger类的构造方法:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 10]

package cn.incast.demo05;
    
    import java.math.BigInteger;
    /*
     * 超级大的整数运算
     * 		超过long取值范围整数,封装成BigInteger类型的对象
     */
    public class BigIntegerDemo {
    	public static void main(String[] args) {
    		function();
    		function_1();
    	}
    	/*
    	 * BigInteger对象的四则运算
    	 * 调用方法计算,计算结果也只能是BigInteger对象
    	 */
    	public static void function_1(){
    		BigInteger b1 = new BigInteger("341234254646576572456476842654363473456252653457");
    		System.out.println(b1);
    		BigInteger b2 = new BigInteger("341234254646576572456476842654363473456252653400");
    		System.out.println(b2);
    		//计算b1+b2对象的和,调用方法add
    		BigInteger bigAdd = b1.add(b2);
    		System.out.println(bigAdd);
    		//计算b1-b2对象的差,调用方法subtract
    		BigInteger bigSub = b1.subtract(b2);
    		System.out.println(bigSub);
    		//计算b1*b2对象的乘,调用方法 BigInteger multiply(BigInteger val)  
    		System.out.println(b1.multiply(b2));
    		//计算b1/b2对象商,调用方法BigInteger divide(BigInteger val)  
    		System.out.println(b1.divide(b2));
    	}
    	/*
    	 * BigInteger类的构造方法
    	 * 传递字符串,要求数字格式,没有长度限制
    	 */
    	public static void function(){
    		BigInteger b = new BigInteger("341234254646576572456476842654363473456252653457");
    		System.out.println(b);
    		BigInteger b1 = new BigInteger("341234254646576572456476842654363473456252653457");
    		System.out.println(b1);
    		//The literal 341234254646576572456476842654363473456252653457 of type int is out of range
    		//long l = 341234254646576572456476842654363473456252653457;
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 11]  
构造方法中,采用字符串的形式给出整数  
四则运算代码：

/ 
    public static void main(String[] args) {
    		//大数据封装为BigInteger对象
              BigInteger big1 = new BigInteger("12345678909876543210");
              BigInteger big2 = new BigInteger("98765432101234567890");
              //add实现加法运算
              BigInteger bigAdd = big1.add(big2);
              //subtract实现减法运算
              BigInteger bigSub = big1.subtract(big2);
              //multiply实现乘法运算
              BigInteger bigMul = big1.multiply(big2);
              //divide实现除法运算
              BigInteger bigDiv = big2.divide(big1);
    }

5.2 BigDecimal  
在程序中执行下列代码,会出现什么问题?  
System.out.println(0.09 + 0.01);  
System.out.println(1.0 - 0.32);  
System.out.println(1.015 \* 100);  
System.out.println(1.301 / 100);  
double和float类型在运算中很容易丢失精度,造成数据的不准确性,Java提供我们BigDecimal类可以实现浮点数据的高精度运算  
构造方法如下:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 12]  
![在这里插入图片描述][20181114093014414.jpg]

package cn.incast.demo05;
    
    import java.math.BigDecimal;
    
    /*
     * 5.2	BigDecimal
     */
    public class BigDecimalDemo {
    	public static void main(String[] args) {
    		function();
    		function_1();
    	}
    	/*
    	 * BigDecimal实现除法运算
    	 * System.out.println(1.301 / 100);//0.013009999999999999
    	 * BigDecimal divide(BigDecimal divisor)  
    	 * BigDecimal divide(BigDecimal divisor, int roundingMode)  
    	 * BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)  
    	 * int scale：保留几位小数
    	 * int roundingMode：保留模式
    	 * 		static int ROUND_UP  向上加1
    	 * 		static int ROUND_DOWN 在丢弃某部分之前始终不增加数字（即截短）
    	 * 		static int ROUND_HALF_UP  >= 0.5 向上+1
    	 * 			如果舍弃部分 >= 0.5，则舍入行为与 ROUND_UP 相同；
    	 * 			否则舍入行为与 ROUND_DOWN 相同
    	 * 		static int ROUND_HALF_DOWN > 0.5 向上+1
    	 * 			如果舍弃部分 > 0.5，则舍入行为与 ROUND_UP 相同；否则舍入行为与 ROUND_DOWN 相同
    	 */
    	public static void function_1(){
    		BigDecimal b1 = new BigDecimal("1.301");
    		BigDecimal b2 = new BigDecimal("100");
    		//计算b1/b2的商,调用方法
    		//BigDecimal bigDiv = b1.divide(b2,2,BigDecimal.ROUND_UP);
    		BigDecimal bigDiv = b1.divide(b2);
    		System.out.println(bigDiv);
    		
    	}
    	/*
    	 * BigDecimal实现三则运算
    	 * + - *
    	 * 浮点数做除法会出现循环小数(一会单独研究) 保证浮点型数据运算的精确性
    	 */ 
    	public static void function(){
    		BigDecimal b1 = new BigDecimal("0.09");
    		BigDecimal b2 = new BigDecimal("0.01");
    		//计算b1+b2的和,调用方法add
    		BigDecimal bigAdd = b1.add(b2);
    		System.out.println(bigAdd);
    		
    		BigDecimal b3 = new BigDecimal("1");
    		BigDecimal b4 = new BigDecimal("0.32");
    		//计算b3-b4的差,调用方法subtract
    		BigDecimal bigSub = b3.subtract(b4);
    		System.out.println(bigSub);
    		
    		BigDecimal b5 = new BigDecimal("1.015"); 
    		BigDecimal b6 = new BigDecimal("100"); 
    		//计算b5*b6的乘
    		BigDecimal bigMul = b5.multiply(b6);
    		System.out.println(bigMul);		
    	}
    }
    /*
     * 计算结果,未知
     * 原因：计算机二进制中,表示浮点数不精确导致的
     * 超级大型的
     * public BigDecimal(double val)
     * 此构造方法的结果有一定的不可预知性。
     * 有人可能认为在 Java 中写入 new BigDecimal(0.1) 所创建的 BigDecimal 正好等于 0.1（非标度值 1，其标度为 1），
     * 但是它实际上等于 0.1000000000000000055511151231257827021181583404541015625。
     * 这是因为 0.1 无法准确地表示为 double
     * （或者说对于该情况，不能表示为任何有限长度的二进制小数）
     * 这样，传入 到构造方法的值不会正好等于 0.1（虽然表面上等于该值）。 
    
     * 故采用BigDecimal(String val) 
     */
    //System.out.println(0.09 + 0.01);//0.09999999999999999
    //System.out.println(1.0 - 0.32);//0.6799999999999999
    //System.out.println(1.015 * 100);//101.49999999999999
    //System.out.println(1.301 / 100);//0.013009999999999999

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 13]  
建议浮点数据以字符串形式给出,因为参数结果是可以预知的  
实现加法减法乘法代码如下:

public static void main(String[] args) {
    		  //大数据封装为BigDecimal对象
              BigDecimal big1 = new BigDecimal("0.09");
              BigDecimal big2 = new BigDecimal("0.01");
              //add实现加法运算
              BigDecimal bigAdd = big1.add(big2);
              
              BigDecimal big3 = new BigDecimal("1.0");
              BigDecimal big4 = new BigDecimal("0.32");
              //subtract实现减法运算
              BigDecimal bigSub = big3.subtract(big4);
              
              BigDecimal big5 = new BigDecimal("1.105");
              BigDecimal big6 = new BigDecimal("100");
              //multiply实现乘法运算
              BigDecimal bigMul = big5.multiply(big6);

对于浮点数据的除法运算,和整数不同,可能出现无限不循环小数,因此需要对所需要的位数进行保留和选择舍入模式  
![在这里插入图片描述][20181114093057689.jpg]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 14]

第6章 总结  
6.1 知识点总结  
 基本类型包装类  
 8种基本类型对应的包装类  
基本类型 包装类  
byte Byte  
short Short  
int Integer  
log Long  
float Float  
double Double  
char Character  
boolean Boolean  
 自动装箱、自动拆箱  
 自动装箱：基本数值转成对象（int  Integer）  
 自动拆箱：对象转成基本数值（Integer  int）  
 常用方法  
public int parseInt(String str):把字符串转成基本类型int  
public static String toString(int x):把基本类型int转成字符串  
public static Integer valueOf(int x):把基本类型i字符串转成Integer对象  
public int intValue():以 int类型返回该包装类对象的值

 System类: 系统属性信息工具类  
 public static long currentTimeMillis()：获取当前系统时间与1970年01月01日00:00点之间的毫秒差值  
 public static void exit(int status)：用来结束正在运行的Java程序。参数传入一个数字即可。通常传入0记为正常状态，其他为异常状态  
 public static void gc()：用来运行JVM中的垃圾回收器，完成内存中垃圾的清除。  
 public static String getProperties()：用来获取指系统属性信息

 Arrays类：数组操作工具类  
 public static void sort方法，用来对指定数组中的元素进行排序（元素值从小到大进行排序）  
 public static String toString方法，用来返回指定数组元素内容的字符串形式  
 public static void binarySearch方法，在指定数组中，查找给定元素值出现的位置。若没有查询到，返回位置为-插入点-1。要求该数组必须是个有序的数组

 Math类：数学运算工具类  
 abs方法,结果都为正数  
 ceil方法，结果为比参数值大的最小整数的double值  
 floor方法，结果为比参数值小的最大整数的double值  
 max方法，返回两个参数值中较大的值  
 min方法，返回两个参数值中较小的值  
 pow方法，返回第一个参数的第二个参数次幂的值  
 round方法，返回参数值四舍五入的结果  
 random方法，产生一个大于等于0.0且小于1.0的double小数

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]: /images/20220417/4ed6e888493045879e9854034ed65f0b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]: /images/20220417/32889a0592ad461a8543b151df9af553.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]: /images/20220417/4414497901d54a5ca4606022b50a4837.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]: /images/20220417/3fc06116174e44308ec61836bbfaf6a8.png
[20181113223703191.jpg]: /images/20220417/30db4ddf8aec4393a5cd5fe0cbb7242d.png
[20181113223838644.jpg]: /images/20220417/7a5955e661ee43c19af9133069ba0831.png
[20181113224259827.jpg]: /images/20220417/4357bf7173434f879ad288cd99ba7b6a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]: /images/20220417/6b965b2b9fec4cc8a454085464950395.png
[20181114090853251.jpg]: /images/20220417/7f34a374a54c45ae91316ac22c68014e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]: /images/20220417/43b63a08aa1545bf877157898aa3501a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]: /images/20220417/549c6efc06b442c28d0b64c2b33e6f6a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]: /images/20220417/2fef500229e7455ba9d291c350621d1f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]: /images/20220417/84e76ee36b154402b4bdb22e7904a150.png
[20181114092631498.jpg]: /images/20220417/f3d7542cdd7d45d5b674456db420cc5c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]: /images/20220417/0c2d2a34c2ef40a4ac9aedc49b10b301.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 10]: /images/20220417/9b3369f3197e420288656b9bdedd76c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 11]: /images/20220417/23e713981f5d4a62a8b5f4e409500b41.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 12]: /images/20220417/1b5b9accca2e4706910d615baf6d8871.png
[20181114093014414.jpg]: /images/20220417/173f0b64117e420f8755203c94031269.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 13]: /images/20220417/9ef6f6d0981c46f8bfec2df7605f8ad8.png
[20181114093057689.jpg]: /images/20220417/44933d370671441e89a6cfd6d1f195d7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 14]: /images/20220417/c49aeca25cca4ebcacc9534d890d494c.png