Java——基本类型包装类，System类，Math类，Arrays类，BigInteger类，BigDecimal类

一、基本类型包装类

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

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

8种基本类型对应的包装类如下：

1、将字符串转换成基本类型

/*
 * Integer类中静态方法 parseInt(String s) 返回基本数据类型
 * 要求: 字符串必须是数字格式的
 */
public static void function(){
	int i = Integer.parseInt("12");
	System.out.println(i/2);
}

/*
 * 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);
}

2、将基本类型转换成字符串

/*
 *  如何将基本类型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);
	
	String s1 = Integer.toString(5,2);
	System.out.println(s1);
}

3、初始化

/*
 *  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，先打印后--。如果是--i的话结果就是99
}

4、获取范围

/*
 *   Integer类的静态成员变量
 *   MAX_VALUE
 *   MIN_VALUE
 */
public static void function(){
	System.out.println(Integer.MAX_VALUE);
	System.out.println(Integer.MIN_VALUE);
}

5、进制转换

/*
 * Integer类的3个静态方法
 * 做进制的转换
 * 十进制转成二进制  toBinarString(int)
 * 十进制转成八进制  toOctalString(int)
 * 十进制转成十六进制  toHexString(int)
 * 三个方法,返回值都是以String形式出现
 */
public static void function_1(){
	System.out.println(Integer.toBinaryString(99));
	System.out.println(Integer.toOctalString(99));
	System.out.println(Integer.toHexString(999));
}

6、自动拆箱，装箱

public static void function_2(){
	Integer i = new Integer(1);
	Integer j = new Integer(1);
	System.out.println(i==j);// false 对象地址
	System.out.println(i.equals(j));// true  继承Object重写equals,比较的对象数据
	
	System.out.println("===================");
	
	Integer a = 500;
	Integer b = 500;
	System.out.println(a==b);//false
	System.out.println(a.equals(b));//true
	
	System.out.println("===================");
	
	
	//数据在byte范围内,JVM不会从新new对象
	Integer aa = 127; // Integer aa = new Integer(127)
	Integer bb = 127; // Integer bb = aa;
	System.out.println(aa==bb); //true
	System.out.println(aa.equals(bb));//true
}


//自动装箱和拆箱弊端,可能出现空指针异常
public static void function_1(){
    Integer in =null;	
    //in = null.intValue()+1
    in = in + 1;
    System.out.println(in);
}

//自动装箱,拆箱的 好处: 基本类型和引用类直接运算
public static void function(){
	//引用类型 , 引用变量一定指向对象
	//自动装箱, 基本数据类型1, 直接变成了对象
	
	Integer in = 1; // Integer in = new Integer(1)
	//in 是引用类型,不能和基本类型运算, 自动拆箱,引用类型in,转换基本类型
	
	//in+1  ==> in.inValue()+1 = 2    
	// in = 2    自动装箱
	in = in + 1;
	
	System.out.println(in);
	
}

二、System类

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

1、获取时间戳

/*
 *  获取当前时间戳
 *  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、退出JVM虚拟机

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

3、回收垃圾

/*
 *  JVM在内存中,收取对象的垃圾
 *  static void gc()，会执行finalize()方法
 */
public static void function_2(){
	new Person();
	new Person();
	new Person();
	new Person();
	new Person();
	new Person();
	new Person();
	new Person();
	System.gc();
}

4、获取当前操作系统的属性

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

结果：

{sun.desktop=gnome, awt.toolkit=sun.awt.X11.XToolkit, java.specification.version=9, file.encoding.pkg=sun.io, sun.cpu.isalist=, sun.jnu.encoding=UTF-8, java.class.path=/home/x54256/IdeaProjects/day06/out/production/day06, java.vm.vendor=Oracle Corporation, sun.arch.data.model=64, java.vendor.url=http://java.oracle.com/, user.timezone=, os.name=Linux, java.vm.specification.version=9, sun.java.launcher=SUN_STANDARD, user.country=CN, sun.boot.library.path=/usr/lib/jvm/java-9-oracle/lib, sun.java.command=cn.x5456.demo1.SysDemo, jdk.debug=release, sun.cpu.endian=little, user.home=/home/x54256, user.language=zh, java.specification.vendor=Oracle Corporation, java.home=/usr/lib/jvm/java-9-oracle, file.separator=/, java.vm.compressedOopsMode=32-bit, line.separator=
, java.specification.name=Java Platform API Specification, java.vm.specification.vendor=Oracle Corporation, java.awt.graphicsenv=sun.awt.X11GraphicsEnvironment, sun.management.compiler=HotSpot 64-Bit Tiered Compilers, java.runtime.version=9.0.4+11, user.name=x54256, path.separator=:, os.version=4.2.0-42-generic, java.runtime.name=Java(TM) SE Runtime Environment, file.encoding=UTF-8, java.vm.name=Java HotSpot(TM) 64-Bit Server VM, java.vendor.url.bug=http://bugreport.java.com/bugreport/, java.io.tmpdir=/tmp, java.version=9.0.4, user.dir=/home/x54256/IdeaProjects/day06, os.arch=amd64, java.vm.specification.name=Java Virtual Machine Specification, java.awt.printerjob=sun.print.PSPrinterJob, sun.os.patch.level=unknown, java.library.path=/usr/java/packages/lib:/usr/lib64:/lib64:/lib:/usr/lib, java.vm.info=mixed mode, java.vendor=Oracle Corporation, java.vm.version=9.0.4+11, sun.io.unicode.encoding=UnicodeLittle, java.class.version=53.0}

5、copy数组

/*
 * 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 = new int[4];

    System.arraycopy(src, 1, desc, 1, 2);

    System.out.println(Arrays.toString(desc));
}

三、Math类

1、求绝对值

/*
 *  static int abs(int i)
 *  获取参数的绝对值
 */
 public static void function(){
	int i = Math.abs(-10086);
	System.out.println(i);
 }

2、获取大于或者等于参数d的最小整数

/*
 *  static double ceil(double d)
 *  返回大于或者等于参数d的最小整数
 */
public static void function_1(){
	double d = Math.ceil(5.1);
	System.out.println(d);
}

3、返回a的b次方

/*
 * static double pow(double a, double b)
 * a的b次方
 */
public static void function_3(){
	double d = Math.pow(2, 3);
	System.out.println(d);
}

4、获取平方根

/*
 * static double sqrt(double d)
 * 返回参数的平方根
 */
public static void function_4(){
	double d = Math.sqrt(2);　　// 负数没有平方根，返回Nan
	System.out.println(d);
}

5、返回[0.0,1.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);
	}
}

6、浮点数四舍五入

/*
 *  static double round(doubl d)
 *  获取参数的四舍五入,取整数
 */
public static void function_6(){
	double d = Math.round(5.4195);
	System.out.println(d);
}

四、Arrays工具类

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

1、排序

/*
 *  static void sort(数组)
 *  对数组升序排列
 */
public static void function(){
    int[] arr = {5,1,4,6,8,9,0};
    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr));
}

2、数组的二分查找

/*
 *  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);
}

3、 数组格式化成字符串

/*
 *  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);
}

 示例：10个人考试成绩，最后三个人的成绩，存储到新的数组中，返回新的数组

/*
 *  定义方法,接收输入,存储的是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;
}

五、BigInteger类

作用：表示Long型表示不了的数据

1、构造方法

/*
 * BigInteger类的构造方法
 * 传递字符串,要求数字格式,没有长度限制
 */
public static void function(){
	BigInteger b = new BigInteger("8465846668464684562385634168451684568645684564564");
	System.out.println(b);
	BigInteger b1 = new BigInteger("5861694569514568465846668464684562385634168451684568645684564564");
	System.out.println(b1);
}

2、四则运算

/*
 * 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);
	 
	 //计算b1*b2对象的乘积,调用方法multiply
	 BigInteger bigMul = b1.multiply(b2);
	 System.out.println(bigMul);
	 
	 //计算b2/b1对象商,调用方法divied
	 BigInteger bigDiv = b2.divide(b1);
	 System.out.println(bigDiv);
 }

六、BigDecimal类

计算结果,未知

原因: 计算机二进制中,表示浮点数不精确造成

超级大型的浮点数据,提供高精度的浮点运算, 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

double和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 ,否则直接舍去
 */
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);
}

 

转载于:https://www.cnblogs.com/x54256/p/8426165.html