java学习笔记——基础15(包装类,System类,Math类,Arrays类)

1、基本类型包装类
2、System类
3、Math类
4、Arrays类
5、大数据运算

01基本数据类型对象包装类概述

*A:基本数据类型对象包装类概述
  *a.基本类型包装类的产生
         在实际程序使用中，程序界面上用户输入的数据都是以字符串类型进行存储的。而程序开发中，我们需要把字符串数据，根据需求转换成指定的基本数据类型，如年龄需要转换成int类型，考试成绩需要转换成double类型等
     *b.八种基本类型对应的包装类
         char    Character
         int     Integer
         byte    Byte
         short   Short
         long    Long
         float   Float
         double  Double
         boolean Boolean

02Integer类parseInt方法

  *A:Integer类parseInt方法:
   *a:parseInt()
    int i = Integer.parseInt("12");
    System.out.println(i/2);//6
 
*b:parseInt(String s, int radix)
    /*
 	 * 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);
		int a = Integer.parseInt("f",16);
      		System.out.println(a);
 	}

03Integer类int转成字符串

*A:Integer类int转成字符串:
     *a:使用+与字符串拼接
          int i = 3;
        	String s = i+"";
        	System.out.println(s+1);//"31"
    
     *b:toString(int ,int 进制),任意进制整数转成任意进制的字符串 (了解)
        	String s1 = Integer.toString(5,2);
        	System.out.println(s1);

04Integer类构造方法

*A:Integer类构造方法
   "/*
    *  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);//99
   }

05Integer类其他方法

*A:Integer类其他方法
   "/*
* Integer类的3个静态方法
* 做进制的转换
* 十进制转成二进制  toBinarString(int)
* 十进制转成八进制  toOctalString(int)
* 十进制转成十六进制 toHexString(int)
* 三个方法,返回值都是以String形式出现
*/"
    a:十进制转二,八,十六进制
        public static void function_1(){
      		System.out.println(Integer.toBinaryString(99));
      		System.out.println(Integer.toOctalString(99));
      		System.out.println(Integer.toHexString(999));
        }
    b:获取int的最大值和最小值
    /*
     *   Integer类的静态成员变量
     *   MAX_VALUE
     *   MIN_VALUE
     */
    public static void function(){
    	System.out.println(Integer.MAX_VALUE);
    	System.out.println(Integer.MIN_VALUE);
    }

06自动装箱和自动拆箱,valueOf

 *A:自动装箱与自动拆箱:
   "//JDK1.5新特性
//自动装箱,拆箱的 好处: 基本类型和引用类直接运算
   //自动装箱:使用Integer.valueOf(整数值)返回一个封装了该整数值的Integer对象
   //自动拆箱:使用Integer对象.intValue()返回Integer对象中封装的整数值"
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);
	
}

valueOf() 方法

继承自Java Number类

valueOf() 方法用于返回给定参数的原生 Number 对象值，参数可以是原生数据类型, String等。

该方法是静态方法。该方法可以接收两个参数一个是字符串，一个是基数。

语法
该方法有以下几种语法格式：

1
2
3

static Integer valueOf(int i)
static Integer valueOf(String s)
static Integer valueOf(String s, int radix)

参数
i – Integer 对象的整数。

s – Integer 对象的字符串。

radix –在解析字符串 s 时使用的基数，用于指定使用的进制数。

返回值
Integer valueOf(int i)：返回一个表示指定的 int 值的 Integer 实例。

Integer valueOf(String s):返回保存指定的 String 的值的 Integer 对象。

Integer valueOf(String s, int radix): 返回一个 Integer 对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值。

实例

public class Test{ 
public static void main(String args[]){
        Integer x =Integer.valueOf(9);
        Double c = Double.valueOf(5);
        Float a = Float.valueOf("80");               

        Integer b = Integer.valueOf("789",16);   // 使用 16 进制

        System.out.println(x); 
        System.out.println(c);
        System.out.println(a);
        System.out.println(b);
    }
}

编译以上程序，输出结果为：

9
5.0
80.0
1929

前言
今天在做题时，碰到了一道选择题，就是关于Integer.valueOf()的知识，题目如下：
Integer i01=59
int i02=59
Integer i03 =Integer.valueOf(59)
Integer i04 = new Integer(59)

判断对错：
A.System.out.println(i01== i02);
B.System.out.println(i01== i03);
C.System.out.println(i03== i04);
D.System.out.println(i02== i04);

分析

选项A

选项A中比较的是i01和i02，Integer i01=59这里涉及到自动装箱过程，59是整型常量，经包装使其产生一个引用并存在栈中指向这个整型常量所占的内存，这时i01就是Integer 的引用。
而int i02=59由于int是基本类型，所以不存在引用问题，直接由编译器将其存放在栈中，换一句话说，i02本身就是59。那么System.out.println(i01== i02)结果任何呢？这里涉及到了拆箱的过程，因为等号一边存在基本类型所以编译器后会把另一边的Integer对象拆箱成int型，这时等号两边比较的就是数值大小，所以是true。

好了，到了这里，你有没有想到这样一个问题：如果是Integer i01=59；Integer i02=59；然后System.out.println(i01== i02)的结果是？可能你会说比较数值大小所以相等啊，也有可能说等号两边对象引用，所以比较的是引用，又因为开辟了不同的内存空间，所以引用不同所以返回false。可是正确答案是：true.
再来看这个问题：：
如果是Integer i01=300；Integer i02=300；然后System.out.println(i01== i02)的结果是？这次的答案是false。
解析：当靠想象无法解决问题的时候，这是就要看源代码了！！很重要！我们可以在Integer类中找到这样的嵌套内部类IntegerCache：

private static class IntegerCache {//静态缓存类
        static final int low = -128;
        static final int high;
        static final Integer cache[];
        static {  //静态代码块
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }

        private IntegerCache() {}
    }

这个类就是在Integer类装入内存中时，会执行其内部类中静态代码块进行其初始化工作，做的主要工作就是把一字节的整型数据（-128-127）包装成Integer类并把其对应的引用存入到cache数组中，这样在方法区中开辟空间存放这些静态Integer变量，同时静态cache数组也存放在这里，供线程享用，这也称静态缓存。
所以当用Integer 声明初始化变量时，会先判断所赋值的大小是否在-128到127之间，若在，则利用静态缓存中的空间并且返回对应cache数组中对应引用，存放到运行栈中，而不再重新开辟内存。
所以对于Integer i01=59；Integer i02=59；i01 和 i02是引用并且相等都指向缓存中的数据，所以返回true。而对于Integer i01=300；Integer i02=300；因为其数据大于127，所以虚拟机会在堆中重新new （开辟新空间）一个 Integer 对象存放300，创建2个对象就会产生2个这样的空间，空间的地址肯定不同导致返回到栈中的引用的只不同。所以System.out.println打印出false。

补充：为什么1个字节的数据范围是-128到127呢，因为Java中数据的表示都是带符号数，所以最高位是用来表示数据的正负，0表示正数，1表示负数，所以正数最大的情况对应的二进制数为：01111111，负数最小对应的二进制数为：10000000.

B选项

从上面的分析，我们已经知道Integer i01=59返回的是指向缓存数据的引用。那么Integer.valueOf(59)返回的是什么或者操作是什么呢？
这个函数的功能就是把int 型转换成Integer，简单说就是装包，那他是新创建一个对象吗？还是像之前利用缓存的呢？有了之前的经验，肯定想到的是利用缓存，这样做既提高程序速度，又节约内存，何乐而不为？
来看一下源代码：

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

很明显跟之前的思想一致，若在-128到127范围，直接返回该对象的引用，否则在堆中重新new 一个。
到这，System.out.println(i01== i03)的结果毋庸置疑就是true.

选项C

Integer.valueOf(59)返回的是已缓存的对象的引用，而Integer i04 = new Integer(59)是在堆中新开辟的空间，所以二者的引用的值必然不同，返回false,这道题呢就选C

选项D

System.out.println(i02== i04) i02是整型变量，i04是引用，这里又用到了解包，虚拟机会把i04指向的数据拆箱为整型变量再与之比较，所以比较的是数值，59==59，返回true.

思考
不得不服，Java这的设计真是巧妙，以后应多注意看看源码，其思想使我受益匪浅。
出一道题：

System.out.println(Integer.valueOf("127")==Integer.valueOf("127"));//true
System.out.println(Integer.valueOf("128")==Integer.valueOf("128"));//false
System.out.println(Integer.parseInt("128")==Integer.valueOf("128"));//true
"//parseInt返回的是10进制整数，Integer.valueOf("128")的Integer对象拆箱成int型，
 这时等号两边比较的就是数值大小，所以是true"

07自动装箱和自动拆箱练习题

*A:自动装箱与自动拆箱:
  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 integer=Integer.valueOf(500)
                //integer=new Integer(500);
Integer b = 500;
System.out.println(a==b);//false
System.out.println(a.equals(b));//true

System.out.println("===================");


"数据在byte(-128~127)范围内,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

08System类方法currentTimeMillis

在API中System类介绍的比较简单，我们给出定义，System中代表程序所在系统，
提供了对应的一些系统属性信息，和系统操作。
System类"不能手动创建对象"，因为"构造方法"被private修饰，
"阻止外界创建对象"。
System类中的"都是"static方法，"类名访问即可"。
在JDK中，有许多这样的类。

*A:System类方法currentTimeMillis():用于计算程序的执行时间
    /*
  	 *  获取系统当前毫秒值
  	 *  static long currentTimeMillis()
  	 *  对程序执行时间测试
  	 */
  	public static void function(){
  		long start = System.currentTimeMillis();//当前时间x-1970年1月1日零时零分零秒
  		for(int i = 0 ; i < 10000; i++){
  			System.out.println(i);
  		}
  		long end = System.currentTimeMillis();//当前时间y-1970年1月1日零时零分零秒
  		System.out.println(end - start);//当前时间y-当前时间x 
  	}

09System类方法exit

 *A:System类方法exit()方法
   /*
 *  退出虚拟机,所有程序全停止
 *  static void exit(0)
 */
public static void function_1(){
	while(true){
		System.out.println("hello");
		System.exit(0);//该方法会在以后的finally代码块中使用(讲到再说)
	}
}

10System类方法gc

A:System类方法gc
     public class Person {
     	public void finalize(){
     		System.out.println("垃圾收取了");
     	}
     }

      "*
  	 *  JVM在内存中,收取对象的垃圾
  	 *  当没有更多引用指向该对象时,会自动调用垃圾回收机制回收堆中的对象
  	 *  同时调用回收对象所属类的 【finalize方法()
  	 *  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();
  	}

11System类方法getProperties

A:System类方法getProperties(了解)
 /*
  *  获取当前操作系统的属性:例如操作系统名称,
  *  static Properties getProperties() 
  */
 public static void function_3(){
 	System.out.println( System.getProperties() );
 }

12System类方法arraycopy

 " /*
   * System类方法,复制数组,这是一个本地方法
   * arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
   * Object src, 要复制的源数组
   * int srcPos, 数组源的起始索引
   * Object dest,复制后的目标数组
   * int destPos,目标数组起始索引 
   * int length, 复制几个
   */"

"从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
从 src 引用的【源数组】到 dest 引用的【目标数组】，数组组件的一个【子序列】被复制下来。
被复制的组件的编号等于 length 参数。
【源数组】中位置在【 srcPos 】到【 srcPos+length-1 】之间的组件
被分别复制到【目标数组】中的【 destPos 】到【 destPos+length-1 】位置。"

 A:System类方法arraycopy：
  /*
   * 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);//将src数组的1位置开始(包含1位置)的两个元素,拷贝到desc的1,2位置上
  	for(int i = 0 ;  i < desc.length ; i++){
  		System.out.println(desc[i]);
  	}
  }

13Math类的方法_1

A:Math类中的方法
/*
	 * static double sqrt(double d)
	 * 返回参数的平方根
	 */
	public static void function_4(){
		double d = Math.sqrt(-2);
		System.out.println(d);
	}
	
	/*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);
	}
	
	/*
	 * static double floor(double d)
	 * 返回小于或者等于参数d的最大整数
	 */
	public static void function_2(){
		double d = Math.floor(1.5);
		System.out.println(d);
	}
	
	/*
	 *  static double ceil(double d)
	 *  返回大于或者等于参数d的最小整数
	 */
	public static void function_1(){
		double d = Math.ceil(5.1);
		System.out.println(d);
	}
	
	/*
	 *  static int abs(int i)
	 *  获取参数的绝对值
	 */
	 public static void function(){
		int i = Math.abs(0);
		System.out.println(i);
	 }

14Math类的方法_2

A:Math类的方法_2
 /*
  *  static double round(doubl d)
  *  获取参数的四舍五入,取整数
  */
 public static void function_6(){
 	double d = Math.round(5.4195);
 	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);
 	}
 }

15Arrays工具类

A:Arrays工具类:
  public class ArraysDemo {
  	public static void main(String[] args) {
  		function_2();
  		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);
  	}
  	
  	"/*
  	 *  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]);
  		}
  	}
  }

16数组复制练习

*A:数组复制练习:
  public static void main(String[] args) {
  		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;
  	}

17BigInteger类概述和构造方法

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

18BigInteger类四则运算

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

19员工案例的子类的编写

A: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 
   */"

20BigDecimal类实现加法减法乘法

A:BigDecimal类实现加法减法乘法
 /*
 	 *  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);
 	}

21BigDecimal类实现除法

A: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);
}

22小结

 基本类型包装类
 8种基本类型对应的包装类
基本类型		包装类
byte		Byte
short		Short
int	 "	Integer  "
long		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):返回一个表示指定的 int 值的 Integer 实例。如果不需要新的 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小数