Java常用API（十七）——基本类型包装类（相互转换、自动装箱拆箱）、System类、Math类、Arrays类、大数据运算

最新推荐文章于 2023-06-19 18:49:17 发布

kww_

最新推荐文章于 2023-06-19 18:49:17 发布

阅读量218

点赞数 1

分类专栏： java

本文链接：https://blog.csdn.net/qq_40243295/article/details/112390417

版权

java 专栏收录该内容

44 篇文章 7 订阅

订阅专栏

1.3.2 自动装箱(byte常量池)细节的演示

第二章 System类

2.1 概念

2.2.1 currentTimeMillis()

2.2.2 exit(int status)

2.2.3 gc()

2.2.4 getProperties()

第一章基本类型包装类

1.1 基本类型包装类概述

在实际程序使用中，程序界面上用户输入的数据都是以字符串类型进行存储的。而程序开发中，我们需要把字符串数据，根据需求转换成指定的基本数据类型，如年龄需要转换成int类型，考试成绩需要转换成double类型等。

那么，想实现字符串与基本数据之间转换怎么办呢？

Java中提供了相应的对象来解决该问题，基本数据类型对象包装类：java将基本数据类型值封装成了对象。封装成对象有什么好处？可以提供更多的操作基本数值的功能。

1.1.1 8种基本类型对应的包装类

其中需要注意int对应的是Integer，char对应的Character，其他6个都是基本类型首字母大写即可。

基本数据类型对象包装类特点：用于在基本数据和字符串之间进行转换。

Integer类构造方法：

Integer (String s)：将数字格式的字符串,传递到Integer类的构造方法中，创建Integer对象,包装的是一个字符串

调用方法：

intValue()：非静态的,将构造方法中的字符串,转成基本数据类型。

public static void function_3(){
		Integer in = new Integer("100");
		int i = in.intValue();
		System.out.println(i++);    //100
		System.out.println(--i);    //99	
	}

1.1.2 将字符串转成基本类型

parseXXX(String s);其中XXX表示基本类型，参数为可以转成基本类型的字符串。

如果字符串无法转成基本类型，将会发生数字转换的问题 NumberFormatException

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

1.1.3 将基本数值转成字符串

将基本数值转成字符串有3种方式：

基本类型直接与””相连接即可；34+""
调用String的valueOf方法；String.valueOf(34) ；
调用包装类中的toString方法；Integer.toString(34) ；

package day17.demo1;

/*
 * Integer类,封装基本数据类型int,提高大量方法
 * 将字符串转成基本数据类型int
 * 
 * 
 * Integer i = Integer.valueOf("1");
 * i.intValue()
 */
public class IntegerDemo {
	public static void main(String[] args) {
		function();
	}
	/*
	 *  Integer类构造方法
	 *   Integer (String s)
	 *   将数字格式的字符串,传递到Integer类的构造方法中
	 *   创建Integer对象,包装的是一个字符串
	 *   将构造方法中的字符串,转成基本数据类型,调用方法,非静态的, intValue()
	 */
	public static void function_3(){
		Integer in = new Integer("100");
		int i = in.intValue();
		System.out.println(i++);//100
		System.out.println(--i);//99
		
		
	}
	
	/*
	 *  如何将基本类型int,变成字符串
	 *  
	 *  int => String  任何类型+"" 变成String类型
	 *  Integer类中的静态方法toString()
	 *  
	 *  toString(int ,int 进制), 将int整数,转成指定进制数
	 *  0-9A-Z
	 */
	public static void function_2(){
		int i = 3;
		String s = i+"";
		System.out.println(s+1);//31,推荐使用
		
		String s1 = Integer.toString(5,2);
		System.out.println(s1);//101
	}
	
	
	/*
	 * Integer类静态方法parseInt(String s, int radix)
	 * radix基数,进制
	 * "110",2 含义 前面的数字是二进制的,但是方法parseInt运行结果都是十进制
	 */
	public static void function_1(){
		int i = Integer.parseInt("110", 2);
		System.out.println(i);//6
	}
	
	/*
	 * Integer类中静态方法 parseInt(String s) 返回基本数据类型
	 * 要求: 字符串必须是数字格式的
	 */
	public static void function(){
		int i = Integer.parseInt("12");
		System.out.println(i/2);//6
	}
}

1.2 基本类型和对象转换

使用int类型与Integer对象转换进行演示，其他基本类型转换方式相同。

1.2.1 基本数值---->包装对象

Integer i = new Integer(4);//使用构造函数

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

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

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

1.2.2 包装对象---->基本数值

int num = i.intValue();

1.2.3 Integer类的其他方法

Integer类的3个静态方法：

做进制的转换。三个方法,返回值都是以String形式出现。

十进制转成二进制 toBinarString(int)
十进制转成八进制 toOctalString(int)
十进制转成十六进制 toHexString(int)

Integer类的静态成员变量

MAX_VALUE
MIN_VALUE

package day17.demo1;

/*
 *  Integer类中的其他方法
 *  包括三个方法,和2个静态成员变量
 */
public class IntegerDemo1 {
	public static void main(String[] args) {
		function();
	}
	/*
	 * Integer类的3个静态方法
	 * 做进制的转换
	 * 十进制转成二进制  toBinarString(int)
	 * 十进制转成八进制  toOctalString(int)
	 * 十进制转成十六进制  toHexString(int)
	 * 三个方法,返回值都是以String形式出现
	 */
	public static void function_1(){
		System.out.println(Integer.toBinaryString(99));//1100011
		System.out.println(Integer.toOctalString(99));//143
		System.out.println(Integer.toHexString(999));//3e7
	}
	
	/*
	 *   Integer类的静态成员变量
	 *   MAX_VALUE
	 *   MIN_VALUE
	 */
	public static void function(){
		System.out.println(Integer.MAX_VALUE);//2147483647
		System.out.println(Integer.MIN_VALUE);//-2147483648

        System.out.println(Long.MAX_VALUE);//9223372036854775807
		System.out.println(Long.MIN_VALUE);//-9223372036854775808
	}
}

1.3 自动装箱拆箱

1.3.1 自动装箱拆箱概念

在需要的情况下，基本类型与包装类型可以通用。有些时候我们必须使用引用数据类型时，可以传入基本数据类型。

比如：

基本类型可以使用运算符直接进行计算，但是引用类型不可以。而基本类型包装类作为引用类型的一种却可以计算，原因在于，Java”偷偷地”自动地进行了对象向基本数据类型的转换。

相对应的，引用数据类型变量的值必须是new出来的内存空间地址值，而我们可以将一个基本类型的值赋值给一个基本类型包装类的引用。原因同样在于Java又”偷偷地”自动地进行了基本数据类型向对象的转换。

自动拆箱：对象转成基本数值

自动装箱：基本数值转成对象

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

1.3.2 自动装箱(byte常量池)细节的演示

当数值在byte范围之内（-128-127）时，进行自动装箱，不会新创建对象空间而是使用已有的空间。

==的左右两边都为引用类型时，比较的是引用类型的地址。

Integer a = new Integer(3);
Integer b = new Integer(3);
System.out.println(a==b);//false
System.out.println(a.equals(b));//true



Integer a = 500;
Integer b = 500;
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

Integer aa = -128; 
Integer bb = -128; 
System.out.println(aa==bb); //true
System.out.println(aa.equals(bb));//true

第二章 System类

2.1 概念

System中代表程序所在系统，提供了对应的一些系统属性信息，和系统操作。

System类不能手动创建对象，因为构造方法被private修饰，阻止外界创建对象。System类中的都是static方法，类名访问即可。

2.2常用方法

currentTimeMillis() 获取当前系统时间与1970年01月01日00:00点之间的毫秒差值
exit(int status) 用来结束正在运行的Java程序。参数传入一个数字即可。通常传入0记为正常状态，其他为异常状态
gc() 用来运行JVM中的垃圾回收器，完成内存中垃圾的清除。//调用回收类的finalize()方法
getProperties() 确定当前的系统属性

2.2.1 currentTimeMillis()

获取当前系统时间与1970年01月01日00:00点之间的毫秒差值.

/*
	 *  获取系统当前毫秒值
	 *  static long currentTimeMillis()
	 *  对程序执行时间测试
	 */
	public static void function(){
		long start = System.currentTimeMillis();
		for(int i = 0 ; i < 10000; i++){
			System.out.println(i);
		}
		long end = System.currentTimeMillis();
		System.out.println(end - start);
	}

2.2.2 exit(int status)

用来结束正在运行的Java程序。参数传入一个数字即可。通常传入0记为正常状态，其他为异常状态.

/*
	 *  退出虚拟机,所有程序全停止
	 *  static void exit(0)
	 */
	public static void function_1(){
		while(true){
			System.out.println("hello");
			System.exit(0);
		}
	}

2.2.3 gc()

用来运行JVM中的垃圾回收器，完成内存中垃圾的清除。//调用回收类的finalize()方法.

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();
		System.gc();
	}

2.2.4 getProperties()

确定当前的系统属性

/*
	 *  获取当前操作系统的属性
	 *  static Properties getProperties() 
	 */
public static void function_3(){
		System.out.println( System.getProperties() );
	}


/*
{java.runtime.name=Java(TM) SE Runtime Environment, sun.boot.library.path=D:\java\bin, java.vm.version=25.131-b11, java.vm.vendor=Oracle Corporation, java.vendor.url=http://java.oracle.com/, path.separator=;, java.vm.name=Java HotSpot(TM) 64-Bit Server VM, file.encoding.pkg=sun.io, user.country=CN, user.script=, sun.java.launcher=SUN_STANDARD, sun.os.patch.level=, java.vm.specification.name=Java Virtual Machine Specification, user.dir=D:\Users\Administrator\eclipse-workspace\practice, java.runtime.version=1.8.0_131-b11, java.awt.graphicsenv=sun.awt.Win32GraphicsEnvironment, java.endorsed.dirs=D:\java\lib\endorsed, os.arch=amd64, java.io.tmpdir=C:\Users\lenovo\AppData\Local\Temp\, line.separator=
, java.vm.specification.vendor=Oracle Corporation, user.variant=, os.name=Windows 10, sun.jnu.encoding=GBK, java.library.path=D:\java\bin;C:\WINDOWS\Sun\Java\bin;C:\WINDOWS\system32;C:\WINDOWS;D:/java/bin/server;D:/java/bin;D:/java/lib/amd64;C:\ProgramData\Oracle\Java\javapath;C:\Program Files (x86)\Lenovo\FusionEngine;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\WINDOWS\System32\WindowsPowerShell\v1.0\;C:\Program Files (x86)\Common Files\lenovo\easyplussdk\bin;C:\Program Files (x86)\ATI Technologies\ATI.ACE\Core-Static;C:\WINDOWS\System32\OpenSSH\;d:\Program Files\Git\cmd;D:\Program Files\xampp\mysql\bin;C:\Program Files\Intel\WiFi\bin\;C:\Program Files\Common Files\Intel\WirelessCommon\;D:\Python3\Scripts\;D:\Python3\;d:\Program Files\JetBrains\PyCharm Community Edition 2019.3.1\bin;;C:\Users\lenovo\AppData\Local\Microsoft\WindowsApps;D:\Program Files\Maven\bin\;D:\Program Files\xampp\mysql\bin;;d:\Program Files\JetBrains\IntelliJ IDEA 2020.2.3\bin;;D:\Program Files (x86)\eclipse\eclipse-jee-oxygen-R-win32-x86_64\eclipse;;., java.specification.name=Java Platform API Specification, java.class.version=52.0, sun.management.compiler=HotSpot 64-Bit Tiered Compilers, os.version=10.0, user.home=C:\Users\lenovo, user.timezone=, java.awt.printerjob=sun.awt.windows.WPrinterJob, file.encoding=GBK, java.specification.version=1.8, java.class.path=D:\Users\Administrator\eclipse-workspace\practice\bin;D:\Users\Administrator\eclipse-workspace\practice\src\day14\demo2\lib\lalla.jar, user.name=lenovo, java.vm.specification.version=1.8, sun.java.command=day17.demo1.SystemDemo, java.home=D:\java, sun.arch.data.model=64, user.language=zh, java.specification.vendor=Oracle Corporation, awt.toolkit=sun.awt.windows.WToolkit, java.vm.info=mixed mode, java.version=1.8.0_131, java.ext.dirs=D:\java\lib\ext;C:\WINDOWS\Sun\Java\lib\ext, sun.boot.class.path=D:\java\lib\resources.jar;D:\java\lib\rt.jar;D:\java\lib\sunrsasign.jar;D:\java\lib\jsse.jar;D:\java\lib\jce.jar;D:\java\lib\charsets.jar;D:\java\lib\jfr.jar;D:\java\classes, java.vendor=Oracle Corporation, file.separator=\, java.vendor.url.bug=http://bugreport.sun.com/bugreport/, sun.io.unicode.encoding=UnicodeLittle, sun.cpu.endian=little, sun.desktop=windows, sun.cpu.isalist=amd64}
 
*/

getProperties() 查询结果所对应的相关值的描述：

2.2.5 arraycopy()方法

用来实现将源数组部分元素复制到目标数组的指定位置。

package day17.demo1;

public class SystemDemo {
	public static void main(String[] args) {
		function_4();
	}
	/*
	 * System类方法,复制数组
	 * arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
	 * Object src, 要复制的源数组
	 * int srcPos, 数组源的起始索引
	 * Object dest,复制后的目标数组
	 * int destPos,目标数组起始索引 
	 * int length, 复制几个
	 */
	public static void function_4(){
		int[] src = {11,22,33,44,55,66};
		int[] desc = {77,88,99,0};
		
		System.arraycopy(src, 1, desc, 1, 2);	// 77 22 33 
		
		for(int i = 0 ;  i < desc.length ; i++){
			System.out.println(desc[i]);//0
		}
	}
	
	/*
	 *  获取当前操作系统的属性
	 *  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();
		System.gc();
	}
	
	/*
	 *  退出虚拟机,所有程序全停止
	 *  static void exit(0)
	 */
	public static void function_1(){
		while(true){
			System.out.println("hello");
			System.exit(0);
		}
	}
	/*
	 *  获取系统当前毫秒值
	 *  static long currentTimeMillis()
	 *  对程序执行时间测试
	 */
	public static void function(){
		long start = System.currentTimeMillis();
		for(int i = 0 ; i < 10000; i++){
			System.out.println(i);
		}
		long end = System.currentTimeMillis();
		System.out.println(end - start);
	}
}

package day17.demo1;


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

第三章 Math类

3.1概念

Math 类是包含用于执行基本数学运算的方法的数学工具类，如初等指数、对数、平方根和三角函数。

类似这样的工具类，其所有方法均为静态方法，并且一般不会创建对象。如System类

3.2 常用方法

3.2.1 abs方法

结果都为正数

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

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


//java源码
public static int abs(int a) {
        return (a < 0) ? -a : a;
    }

3.2.2 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

3.2.3 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

3.2.4 max方法

返回两个参数值中较大的值

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

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

3.2.5 min方法

返回两个参数值中较小的值

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

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

3.2.6 pow方法

返回第一个参数的第二个参数次幂的值

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

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

3.2.7 round方法

返回参数值四舍五入的结果

思想：给原值加0.5，取整数位

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

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

3.2.8 random方法

产生一个大于等于0.0且小于1.0的double小数(左闭右开区间)

double d1 = Math.random();

package day17.demo1;

/*
 *  数学计算的工具类
 *  java.lang.Math 静态方法组成
 */
public class MathDemo {
	public static void main(String[] args) {
		function_6();
	}
	/*
	 *  static double round(double d)
	 *  获取参数的四舍五入,取整数
	 */
	public static void function_6(){
		double d = Math.round(5.4195);
		System.out.println(d);	//5.0
	}
	
	/*
	 *  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 d)
	 * 返回参数的平方根
	 */
	public static void function_4(){
		double d = Math.sqrt(-2);
		System.out.println(d);	//NaN
	}
	
	/*0
	 * static double pow(double a, double b)
	 * a的b次方
	 */
	public static void function_3(){
		double d = Math.pow(2, 3);
		System.out.println(d);	//8
	}
	
	/*
	 * static double floor(double d)
	 * 返回小于或者等于参数d的最大整数
	 */
	public static void function_2(){
		double d = Math.floor(1.5);
		System.out.println(d);	//1.0
	}
	
	/*
	 *  static double ceil(double d)
	 *  返回大于或者等于参数d的最小整数
	 */
	public static void function_1(){
		double d = Math.ceil(5.1);
		System.out.println(d);	//6
	}
	
	/*
	 *  static int abs(int i)
	 *  获取参数的绝对值
	 */
	 public static void function(){
		int i = Math.abs(0);
		System.out.println(i);
	 }
	 
}

第四章 Arrays类

4.1 概念

此类包含用来操作数组（比如排序和搜索）的各种方法。需要注意，如果指定数组引用为 null，则访问此类中的方法都会抛出空指针异常NullPointerException。

4.2 常用方法

4.2.1 sort方法

用来对指定数组中的元素进行排序（元素值从小到大进行排序），使用的是改编的快速排序。

//源arr数组元素{1,5,9,3,7}, 进行排序后arr数组元素为{1,3,5,7,9}

int[] arr = {1,5,9,3,7};

Arrays.sort( arr );

4.2.2 toString方法

用来返回指定数组元素内容的字符串形式。

int[] arr = {1,5,9,3,7};

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

4.2.3 binarySearch方法

在指定数组中，查找给定元素值出现的位置。

数组的二分搜索法，返回元素在数组中出现的索引。

元素不存在, 返回的是 (-插入点-1)，插入点是要求该数组为有序的数组的情况下，此元素在数组中的下标。

int[] arr = {1,3,4,5,6};

int index = Arrays.binarySearch(arr, 4); //index的值为2

int index2= Arrasy.binarySearch(arr, 2); //index2的值为-2
//若2存在，为保持数组顺序排列，其插入点应为1，-1-1=-2

package day17.demo1;

import java.util.Arrays;

/*
 *  数组的工具类,包含数组的操作
 *  java.util.Arrays
 */
public class ArraysDemo {
	public static void main(String[] args) {
		function_1();
		int[] arr = {56,65,11,98,57,43,16,18,100,200};
		int[] newArray = test(arr);
		System.out.println(Arrays.toString(newArray));
	}
	/*
	 *  定义方法,接收输入,存储的是10个人考试成绩
	 *  将最后三个人的成绩,存储到新的数组中,返回新的数组
	 */
	public static int[] test(int[] arr){
		//对数组排序
		Arrays.sort(arr);
		//将最后三个成绩存储到新的数组中
		int[] result = new int[3];
		//成绩数组的最后三个元素,复制到新数组中
	//	System.arraycopy(arr, 0, result, 0, 3);
		for(int i = 0 ;  i < 3 ;i++){
			result[i] = arr[i];
		}
		return result;
	}
	
	/*
	 *  static String toString(数组)
	 *  将数组变成字符串
	 */
	public static void function_2(){
		int[] arr = {5,1,4,6,8,9,0};
		String s = Arrays.toString(arr);
		System.out.println(s);
	}
	
	/*
	 *  static int binarySearch(数组, 被查找的元素)
	 *  数组的二分搜索法
	 *  返回元素在数组中出现的索引
	 *  元素不存在, 返回的是  (-插入点-1)
	 */
	public static void function_1(){
		int[] arr = {1,4,7,9,11,15,18};
	    int index =  Arrays.binarySearch(arr, 10);
	    System.out.println(index);-5,若10存在，插入点应为4，-4—1=-5
	    
	}
	
	/*
	 *  static void sort(数组)
	 *  对数组升序排列
	 */
	public static void function(){
		int[] arr = {5,1,4,6,8,9,0};
		Arrays.sort(arr);
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
}

第五章大数据运算

5.1 BigInteger

java中long型为最大整数类型,对于超过long型的数据如何去表示呢.在Java的世界中,超过long型的整数已经不能被称为整数了,它们被封装成BigInteger对象.在BigInteger类中,实现四则运算都是方法来实现,并不是采用运算符.

BigInteger类最常用的构造方法:

package day17.demo1;

import java.math.BigInteger;

/*
 *  超级大的整数运算
 *    超过long取值范围整数,封装成BigInteger类型的对象
 */
public class BigIntegerDemo {
	public static void main(String[] args) {
		function_1();
	}
	/*
	 * BigInteger对象的四则运算
	 * 调用方法计算,计算结果也只能是BigInteger对象
	 */
	 public static void function_1(){
		 BigInteger b1 = new BigInteger("5665464516451051581613661405146");
		 BigInteger b2 = new BigInteger("965855861461465516451051581613661405146");
		 
		 //计算 b1+b2对象的和,调用方法 add
		 BigInteger bigAdd = b1.add(b2);//965855867126930032902103163227322810292
		 System.out.println(bigAdd);
		 
		 //计算b1-b2对象的差,调用方法subtract
		 BigInteger bigSub = b1.subtract(b2);
		 System.out.println(bigSub);//-965855855796001000000000000000000000000
		 
		 //计算b1*b2对象的乘积,调用方法multiply
		 BigInteger bigMul = b1.multiply(b2);
		 System.out.println(bigMul);//5472022111116195598734066443403048274650532200028149991817763155281316
		 
		 //计算b2/b1对象商,调用方法divied
		 BigInteger bigDiv = b2.divide(b1);
		 System.out.println(bigDiv);//170481318
	 }
	
	/*
	 * BigInteger类的构造方法
	 * 传递字符串,要求数字格式,没有长度限制
	 */
	public static void function(){
		BigInteger b = new BigInteger("8465846668464684562385634168451684568645684564564");
		System.out.println(b);
		BigInteger b1 = new BigInteger("5861694569514568465846668464684562385634168451684568645684564564");
		System.out.println(b1);
	}
}

5.2 BigDecimal

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

计算结果错误原因: 计算机二进制中,表示浮点数不精确
解决方法：超级大型的浮点数据,提供高精度的浮点运算, BigDecimaldouble和float类型在运算中很容易丢失精度,造成数据的不准确性,Java提供我们BigDecimal类可以实现浮点数据的高精度运算。

常用构造方法：

BigDecimal实现除法运算：
divide(BigDecimal divisor, int scale, int roundingMode)

int scale : 保留几位小数
int roundingMode : 保留模式

保留模式阅读API文档

static int ROUND_UP 向上+1
static int ROUND_DOWN 直接舍去
static int ROUND_HALF_UP >= 0.5 向上+1
static int ROUND_HALF_DOWN > 0.5 向上+1 ,否则直接舍去

package day17.demo1;

import java.math.BigDecimal;

public class BigDecimalDemo {
	public static void main(String[] args) {
		function_1();
	}
	/*
	 * BigDecimal实现除法运算
	 * divide(BigDecimal divisor, int scale, int roundingMode) 
	 * int scale : 保留几位小数
	 * int roundingMode : 保留模式
	 * 保留模式 阅读API文档
	 *   static int ROUND_UP  向上+1
	 *   static int ROUND_DOWN 直接舍去
	 *   static int ROUND_HALF_UP  >= 0.5 向上+1
	 *   static int ROUND_HALF_DOWN   > 0.5 向上+1 ,否则直接舍去
	 */
	public static void function_1(){
		BigDecimal b1 = new BigDecimal("1.0301");
		BigDecimal b2 = new BigDecimal("100");
		//计算b1/b2的商,调用方法divied
		BigDecimal bigDiv = b1.divide(b2,2,BigDecimal.ROUND_HALF_UP);//0.01301
		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-b2的差,调用方法subtract
		BigDecimal bigSub = b3.subtract(b4);
		System.out.println(bigSub);
		
		BigDecimal b5 = new BigDecimal("1.015");
		BigDecimal b6 = new BigDecimal("100");
		//计算b5*b6的成绩,调用方法 multiply
		BigDecimal bigMul = b5.multiply(b6);
		System.out.println(bigMul);
	}
}


/*
 * 计算结果,未知
 * 原因: 计算机二进制中,表示浮点数不精确造成
 * 超级大型的浮点数据,提供高精度的浮点运算, BigDecimal
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 
*/

第六章总结

基本类型包装类

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小数

kww_

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java常用API（十七）——基本类型包装类（相互转换、自动装箱拆箱）、System类、Math类、Arrays类、大数据运算

目录第一章基本类型包装类1.1基本类型包装类概述1.1.1 8种基本类型对应的包装类1.1.2将字符串转成基本类型1.1.3将基本数值转成字符串1.2基本类型和对象转换1.2.1基本数值---->包装对象1.2.2包装对象---->基本数值1.2.3Integer类的其他方法1.3自动装箱拆箱1.3.1 自动装箱拆箱概念1.3.2 自动装箱(byte常量池)细节的演示第二章System类2.1 概念2.2.1 c...
复制链接

扫一扫