JAVA的Number 和 Math 类

1.Number

一般地，当需要使用数字的时候，我们通常使用内置数据类型，如：byte、int、long、double 等。
然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。

这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。相似的，编译器也可以把一个对象拆箱为内置类型。Number 类属于 java.lang 包。

public class Test{
    public static void main(String args[]){
        Integer x = 5;
        x = x + 10;
        System.out.println(x); //15
    }
}

当 x 被赋为整型值时，由于x是一个对象，所以编译器要对x进行装箱。然后，为了使x能进行加运算，所以要对x进行拆箱。

2.Math 类

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

public class Test {
    public static void main (String []args) {
        System.out.println("90 度的正弦值：" + Math.sin(Math.PI/2));
        System.out.println("0度的余弦值：" + Math.cos(0));
        System.out.println("60度的正切值：" + Math.tan(Math.PI/3));
        System.out.println("1的反正切值： " + Math.atan(1));
        System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI/2));
        System.out.println("π的值是：" +Math.PI);
    }
}

运行结果

90 度的正弦值：1.0
0度的余弦值：1.0
60度的正切值：1.7320508075688767
1的反正切值： 0.7853981633974483
π/2的角度值：90.0
π的值是：3.141592653589793

3.Number 和 Math 类方法

3.1 xxxValue()

xxxValue() 方法用于将 Number 对象转换为 xxx 数据类型的值并返回。其中xxx可以是：byte、double、float、int、long、short

public class Test{ 
 
   public static void main(String args[]){
      Integer x = 5;
      // 返回 byte 原生数据类型
      System.out.println( x.byteValue() ); //5
 
      // 返回 double 原生数据类型
      System.out.println(x.doubleValue()); //5.0
 
      // 返回 long 原生数据类型
      System.out.println( x.longValue() );  //5    
   }
}

3.4 valueOf()

valueOf() 方法用于返回给定参数的原生 Number 对象值，参数可以是原生数据类型, String等。
该方法是静态方法。该方法可以接收两个参数一个是字符串，一个是基数。

语法：

static Integer valueOf(int i)   // i -- Integer 对象的整数。
static Integer valueOf(String s) //  s -- Integer 对象的字符串。
static Integer valueOf(String s, int radix) //radix --在解析字符串 s 时使用的基数，用于指定使用的进制数。

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("444",16);   // 使用 16 进制
        
        System.out.println(x);   //9
        System.out.println(c);   //5.0
        System.out.println(a);   //80.0
        System.out.println(b);   1092
    }
}

3.3 compareTo()

compareTo() 方法用于将 Number 对象与方法的参数进行比较。可用于比较Byte, Double, Integer, Float, Long 或 Short 类型。该方法用于两个相同数据类型的比较，两个不同类型的数据不能用此方法来比较。
语法：a.compareTo(b)
返回值：相等为0、b小为1、b大为-1

public class Test{ 
   public static void main(String args[]){
      Integer x = 5;
      System.out.println(x.compareTo(3)); //1
      System.out.println(x.compareTo(5)); //0
      System.out.println(x.compareTo(8)); //-1           
     }
}

3.4 equals()

equals() 方法用于判断 Number 对象与方法的参数进是否相等。
如 Number 对象不为 Null，且与方法的参数类型与数值都相等返回 True，否则返回 False。

public class Test{
    public static void main(String args[]){
        Integer x = 5;
        Integer y = 10;
        Integer z =5;
        Short a = 5;

        System.out.println(x.equals(y));  //false
        System.out.println(x.equals(z));  //true
        System.out.println(x.equals(a));  //false  类型不同
    }
}

3.5 toString()

toString() 方法用于返回以一个字符串表示的 Number 对象值。
如果方法使用了原生的数据类型作为参数，返回原生数据类型的 String 对象值。
如果方法有两个参数，返回用第二个参数指定基数表示的第一个参数的字符串表示形式。

语法：
String toString()
static String toString(int i)

public class Test{
    public static void main(String args[]){
        Integer x = 5;

        System.out.println(x.toString());                //5
        System.out.println(Integer.toString(12));        //12
        System.out.println(Float.toString(12));      //12.0
    }
}

3.6 parseInt()

parseInt() 方法用于将字符串参数作为有符号的十进制整数进行解析。
如果方法有两个参数， 使用第二个参数指定的基数，将字符串参数解析为有符号的整数。

语法：
static int parseInt(String s)
static int parseInt(String s, int radix) //radix是2、8、10、16进制

public class Test{
    public static void main(String args[]){
        int x = Integer.parseInt("9");
        double c = Double.parseDouble("5");
        int b = Integer.parseInt("444",16);

        System.out.println(x);  //9
        System.out.println(c);  //5.0
        System.out.println(b);  //1092   为16进制
    }
}

3.7 abs()

abs()返回参数的绝对值。参数可以是 int, float, long, double, short, byte类型。

public class Test{ 
    public static void main(String args[]){
        Integer a = -8;
        double d = -100;
        float f = -90;    
                        
        System.out.println(Math.abs(a));  //8
        System.out.println(Math.abs(d));  //100.0     
        System.out.println(Math.abs(f));  //90.0    
    }
}

3.8 ceil()、floor()、rint() 和 round()

ceil()方法可对一个数进行向上舍入，返回值大于或等于给定的参数。
floor()方法可对一个数进行向下舍入，返回值小于或等于给定的参数。
rint() 方法返回最接近参数的整数值，但类型还是浮点型。
round() 方法返回一个最接近的int、long型值。（四舍五入取整：Math.floor(x+0.5) x为参数）

public class Test{
    public static void main(String args[]){
        double d = 100.675;
        float f = -90;    
 
        System.out.println(Math.ceil(d));  //101.0
        System.out.println(Math.ceil(f));  //-90.0
                     
        System.out.println(Math.floor(d)); //100.0
        System.out.println(Math.floor(f)); //-90.0
        
        double x = 100.675;
        double y = 100.500;
        double z = 100.200;
        double z = -100.5;
        
        System.out.println(Math.rint(x)); //101.0
        System.out.println(Math.rint(y)); //100.0
        System.out.println(Math.rint(z)); //100.0
        
        System.out.println(Math.round(x)); //101
        System.out.println(Math.round(y)); //100
        System.out.println(Math.round(z)); //100
        System.out.println(Math.round(z)); //-100
    }
}

3.9 main() 和 max()

min() 方法用于返回两个参数中的最小值。
max() 方法用于返回两个参数中的最大值。

public class Test{
    public static void main(String args[]){
        System.out.println(Math.min(12.123, 12.456));  //12.123
        System.out.println(Math.min(23.12, 23.0));     //23.0
        
        System.out.println(Math.min(12.123, 12.456));  //12.456
        System.out.println(Math.min(23.12, 23.0));     //23.12
    }
}

3.10 exp()、pow() 、sqrt() 和 log()

exp() 方法用于返回自然数底数e的参数次方。
log() 方法用于返回参数的自然数底数的对数值。
pow() 方法用于返回第一个参数的第二个参数次方。
sqrt() 方法用于返回参数的算术平方根。

public class Test{ 
    public static void main(String args[]){
        double x = 11.635;
        double y = 2.76;

        System.out.printf("e 的值为 %.4f%n", Math.E); //e 的值为 2.7183
        System.out.printf("exp(%.3f) 为 %.3f%n", x, Math.exp(x));  //exp(11.635) 为 112983.831
        System.out.printf("log(%.3f) 为 %.3f%n", x, Math.log(x)); //log(11.635) 为 2.454
        System.out.printf("pow(%.3f, %.3f) 为 %.3f%n", x, y, Math.pow(x, y)); //pow(11.635, 2.760) 为 874.008
        System.out.printf("sqrt(%.3f) 为 %.3f%n", x, Math.sqrt(x)); //sqrt(11.635) 为 3.411
    }
}

3.11 toDegrees() 和

toDegrees() 方法用于将参数转化为角度。
toRadians() 方法用于将角度转换为弧度。

public class Test{
    public static void main(String args[]){
        double x = 45.0;
        double y = 30.0;

        System.out.println( Math.toDegrees(x) ); //2578.3100780887044
        System.out.println( Math.toDegrees(y) ); //1718.8733853924698
        
        System.out.println( Math.toRadians(x) ); //0.7853981633974483
        System.out.println( Math.toRadians(y) ); //0.5235987755982988
    }
}

3.12 sin()、cos()、tan()、asin()、acos()、atan()、atan2()

sin() 方法用于返回指定double类型参数的正弦值。
cos() 方法用于返回指定double类型参数的余弦值。
tan() 方法用于返回指定double类型参数的正切值。
asin() 方法用于返回指定double类型参数的反正弦值。
acos() 方法用于返回指定double类型参数的反余弦值。
atan() 方法用于返回指定double类型参数的反正切值。
atan2() 方法用于将矩形坐标 (x, y) 转换成极坐标 (r, theta)，返回所得角 theta。该方法通过计算 y/x 的反正切值来计算相角 theta，范围为从 -pi 到 pi。

public class Test{
    public static void main(String args[]){
    
        double degrees = 45.0;
        double radians = Math.toRadians(degrees);

        System.out.format("pi 的值为 %.4f%n", Math.PI); //pi 的值为 3.1416
        System.out.format("%.1f 度的正弦值为 %.4f%n", degrees, Math.sin(radians)); //45.0 度的正弦值为 0.7071
        System.out.format("%.1f 度的余弦值为 %.4f%n", degrees, Math.cos(radians)); //45.0 度的余弦值为 0.7071
        System.out.format("%.1f 度的正切值是 %.4f%n", degrees, Math.tan(radians)); //45.0 度的正切值是 1.0000
        System.out.format("%.4f 的反正弦值为 %.4f 度 %n", Math.sin(radians), Math.toDegrees(Math.asin(Math.sin(radians)))); //0.7071 的反正弦值为 45.0000 度 
        System.out.format("%.4f 的反余弦值为 %.4f 度 %n", Math.cos(radians), Math.toDegrees(Math.acos(Math.sin(radians)))); //0.7071 的反余弦值为 45.0000 度 
        System.out.format("%.4f 的反正切值 %.4f 度 %n", Math.cos(radians), Math.toDegrees(Math.atan(Math.sin(radians)))); //0.7071 的反正切值 35.2644 度 
        
        double x = 45.0;
        double y = 30.0;
 
        System.out.println( Math.atan2(x, y) );  //0.982793723247329
 
    }
}

3.13 random()

random() 方法用于返回一个随机数，随机数范围为 0.0 =< Math.random < 1.0。

public class Test{
    public static void main(String args[]){
        System.out.println( Math.random() );
        System.out.println( Math.random() );
    }
}

生成一个 0-100 的随机数

import java.util.Random;

public class RandomTest{
    public static void main(String[] args){
        Random rand=new Random();
        int i=(int)(Math.random()*100);       //  生成0-100的随机数
        int j=rand.nextInt(100);              // 这里是一个方法的重载，参数的内容是指定范围
        System.out.println("i:"+i+"\nj:"+j); // 分别输出两个随机数
    }
}

附：Java 会对 -128 ~ 127 的整数进行缓存，所以当定义两个变量初始化值位于 -128 ~ 127 之间时，两个变量使用了同一地址；当两个 Integer 变量的数值超出 -128 ~ 127 范围时, 变量使用了不同地址。

Integer a=123;
Integer b=123;
System.out.println(a==b);        // true
System.out.println(a.equals(b);  // true

Integer x=1230;
Integer y=1230;
System.out.println(x==y);        // false
System.out.println(x.equals(y));  // true