Math Number 数值类 包装类 数学计算 MD

Markdown版本笔记	我的GitHub首页	我的博客	我的微信	我的邮箱
MyAndroidBlogs	baiqiantao	baiqiantao	bqt20094	baiqiantao@sina.com

---

目录

目录
Math 类
简介
字段
近似值：round、ceil、floor、rint
普通函数
三角函数
角度弧度
指数、对数、平方根
1.8之后新增的方法
Math 常用 API 使用演示
数值类 API
Number
Integer
Float
Random
示例代码
自动装箱和拆箱
关于是否相等
基本类型和字符串相互装换
进制转换
包装类中封装的基本信息

Math 类

简介

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

其实，Math里面许多数学函数方法是直接调用的StrictMath类里面的方法，而这些函数方法在StrictMath里面的形式是调用本地native方法，比如：

public static double pow(double a, double b) {
    return StrictMath.pow(a, b); // default impl. delegates to StrictMath
}

public static native double pow(double a, double b);

这里的native方法其实是C代码来实现的，而这些源码在jdk中是没有公布的，根据注释可以获知这些

C的实现来自 fdlibm，但是却不能访问，于是百度 netlib 发现在 liblist 下的 fdlibm 中。使用C代码来实现这些基本的函数好处就是提高运行的效率。

各个方法的介绍及案例详见 java_lang_math

字段

• static double PI 比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值
  
  注意：Math 类中对 PI 赋的值为【3.1415_92653_58979_32384_6，精度为21位】，实际上double的精度只能精确到【3.1415_92653_58979_3，精度为15~16位】
  
  之所以这么设计，可能是考虑到以后可能会扩展double类型的精度

• static double E 比任何其他值都更接近 e（即自然对数的底数）的 double 值
  
  注意：Math 类中对 E 赋的值为【2.7182_81828_45904_52354，精度为20位】，实际上double的精度只能精确到【2.7182_81828_45904_5，精度为15~16位】
  
  之所以这么设计，可能是考虑到以后可能会扩展double类型的精度

System.out.println(Math.PI+"  "+Math.E);//3.141592653589793  2.718281828459045

近似值：round、ceil、floor、rint

• static double ceil(double a) 返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。Math.ceil(x) 的值与 -Math.floor(-x) 的值完全相同。
• static double floor(double a) 返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。
• static double rint(double a) 返回最接近参数并等于某一整数的 double 值。如果两个同为整数的 double 值都同样接近，那么结果取偶数。
• static long round(double a) 返回最接近参数的 long。
• static int round(float a) 返回最接近参数的 int。

速记

• round 附近，返回【四舍五入】后的整数
• ceil 天花板，返回【大于】参数的最小整数
• floor 地板 ，返回【小于】参数的最大整数
• rint 返回【最接近】参数的整数，如果刚好居中，则取偶数

round、ceil、floor、rint 方法经典示例

System.out.println(Math.round(1.5f) + "    " + Math.round(-1.5f));//2 【-1】
System.out.println(Math.round(1.3f) + "    " + Math.round(-1.3f));//1    -1
System.out.println(Math.round(1.6f) + "    " + Math.round(-1.6f) + "\n");//2    -2
//******************************************************************************************
System.out.println(Math.ceil(1.5f) + "    " + Math.ceil(-1.5f));//2.0    -1.0
System.out.println(Math.ceil(1.3f) + "    " + Math.ceil(-1.3f));//2.0    -1.0
System.out.println(Math.ceil(1.6f) + "    " + Math.ceil(-1.6f) + "\n");//2.0    -1.0
//******************************************************************************************
System.out.println(Math.floor(1.5f) + "    " + Math.floor(-1.5f));//1.0    -2.0
System.out.println(Math.floor(1.3f) + "    " + Math.floor(-1.3f));//1.0    -2.0
System.out.println(Math.floor(1.6f) + "    " + Math.floor(-1.6f)+ "\n");//1.0    -2.0
//******************************************************************************************
System.out.println(Math.rint(1.5f) + "    " + Math.rint(-1.5f));//2.0    -2.0
System.out.println(Math.rint(1.3f) + "    " + Math.rint(-1.3f));//1.0    -1.0
System.out.println(Math.rint(1.6f) + "    " + Math.rint(-1.6f));//2.0    -2.0

普通函数

• static double/float/int/long abs(double a) 返回 double 值的绝对值。

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

• static double/float copySign(double magnitude, double sign) 返回带有第二个浮点参数符号的第一个浮点参数。
  
  参数：magnitude - 提供结果数值的参数；sign - 提供结果符号的参数
  
  返回：一个值，带有 magnitude 的数值， sign 的符号。

• static double/float/int/long max/min(double a, double b) 返回两个 double 值中较大/小的一个。

public static int max(int a, int b) {
    return (a >= b) ? a : b;
}

• static double/float nextAfter(double start, double direction) 返回第一个参数和第二个参数之间与第一个参数相邻的浮点数。
• static double/float nextUp(double d) 返回 d 和正无穷大之间与 d 相邻的浮点值。
• static double/float signum(double d) 返回参数的符号函数；如果参数为 0，则返回 0；如果参数大于 0，则返回 1.0；如果参数小于 0，则返回 -1.0。
• static double random() 返回带正号的 double 值，该值大于等于 0.0 且小于 1.0，即 [0.0,1.0)

三角函数

• static double sin(double a) 返回角的三角正弦。
• static double cos(double a) 返回角的三角余弦。
• static double tan(double a) 返回角的三角正切。
• static double sinh(double x) 返回 double 值的双曲线正弦。
• static double cosh(double x) 返回 double 值的双曲线余弦。
• static double tanh(double x) 返回 double 值的双曲线余弦。
• static double asin(double a) 返回一个值的反正弦；返回的角度范围在 -pi/2 到 pi/2 之间。
• static double acos(double a) 返回一个值的反余弦；返回的角度范围在 0.0 到 pi 之间。
• static double atan(double a) 返回一个值的反正切；返回的角度范围在 -pi/2 到 pi/2 之间。
• static double atan2(double y, double x) 将矩形坐标 (x, y) 转换成极坐标 (r, theta)，返回所得角 theta。

角度弧度

• static double toDegrees(double angrad) 将用弧度表示的角转换为近似相等的用角度表示的角。

public static double toDegrees(double angrad) {
    return angrad * 180.0 / PI;
}

• static double toRadians(double angdeg) 将用角度表示的角转换为近似相等的用弧度表示的角。

public static double toRadians(double angdeg) {
    return angdeg / 180.0 * PI;
}

指数、对数、平方根

• static double cbrt(double a) 返回 double 值的立方根。
• static double exp(double a) 返回欧拉数 e 的 double 次幂的值。
• static double expm1(double x) 返回 e^x -1。
• static double hypot(double x, double y) 返回 sqrt(x^2 +y^2)，没有中间溢出或下溢。
• static double IEEEremainder(double f1, double f2) 按照 IEEE 754 标准的规定，对两个参数进行余数运算。
• static double log(double a) 返回 double 值的自然对数（底数是 e）。
• static double log10(double a) 返回 double 值的底数为 10 的对数。
• static double log1p(double x) 返回参数与 1 之和的自然对数，等同于log(x+1)。
• static double pow(double a, double b) 返回第一个参数的第二个参数次幂的值。
• static double sqrt(double a) 返回正确舍入的 double 值的正平方根。
• static double/float scalb(double d, int scaleFactor) 返回 d × 2^scaleFactor，其舍入方式如同将一个正确舍入的浮点值乘以 double 值集合中的一个值。
• 其他函数
• static int getExponent(double d) 返回 double 表示形式中使用的无偏指数。
• static int getExponent(float f) 返回 float 表示形式中使用的无偏指数。
• static double ulp(double d) 返回参数的 ulp 大小。
• static float ulp(float f) 返回参数的 ulp 大小。

1.8之后新增的方法

• static int addExact(int x, int y)：返回【x+y】的值，如果结果溢出int值的范围，则抛出异常。
• static long addExact(long x, long y)

//Returns the sum of its arguments, throwing an exception if the result overflows an int.
public static int addExact(int x, int y) {
    int r = x + y;
    // HD 2-12 Overflow iff both arguments have the opposite相反的 sign符号、标志 of the result
    if (((x ^ r) & (y ^ r)) < 0) throw new ArithmeticException("integer overflow");//注意^是异或运算
    return r;
}

• static int subtractExact(int x, int y)：返回【x-y】的值，如果结果溢出int值的范围，则抛出异常。
• static long subtractExact(long x, long y)

public static int subtractExact(int x, int y) {
    int r = x - y;
    // HD 2-12 Overflow iff the arguments have different signs 【and】 the sign of the result is different than the sign of x
    if (((x ^ y) & (x ^ r)) < 0)  throw new ArithmeticException("integer overflow");
    return r;
}

• static int multiplyExact(int x, int y)：返回【(int)( (long)x * (long)y )】的值，如果***
• static long multiplyExact(long x, long y)

public static int multiplyExact(int x, int y) {
    long r = (long)x * (long)y;
    if ((int)r != r) throw new ArithmeticException("integer overflow");
    return (int)r;
}

• static int incrementExact(int a)：【参数值+1】
• static long incrementExact(long a)

public static int incrementExact(int a) {
    if (a == Integer.MAX_VALUE) throw new ArithmeticException("integer overflow");
    return a + 1;
}

• static int decrementExact(int a)：【参数值-1】
• static long decrementExact(long a)

public static int decrementExact(int a) {
    if (a == Integer.MIN_VALUE)  throw new ArithmeticException("integer overflow");
    return a - 1;
}

• static int negateExact(int a)：【参数的相反数】
• static long negateExact(long a)

public static int negateExact(int a) {
    if (a == Integer.MIN_VALUE) throw new ArithmeticException("integer overflow");
    return -a;
}

• static int toIntExact(long value)：【long类型对应的int类型值】

public static int toIntExact(long value) {
    if ((int)value != value) throw new ArithmeticException("integer overflow");
    return (int)value;
}

• static int floorDiv(int x, int y)： 返回小于或等于【x / y的商】的最大整数值
  
  Returns the largest (closest to positive infinity 最接近正无穷大) int value that is less than or equal to小于或等于 the algebraic代数 quotient商.
• static long floorDiv(long x, long y)

public static int floorDiv(int x, int y) {
    int r = x / y;
    // if the signs are different and modulo not zero, round down
    if ((x ^ y) < 0 && (r * y != x))  r--;
    return r;
}

• static int floorMod(int x, int y)
  
  Returns the floor modulus模 of the int arguments.

The floor modulus is x - (floorDiv(x, y) * y), has the same sign符号  as the divisor除数 y, and is in the range of -abs(y) < r < +abs(y).

The relationship关系 between floorDiv and floorMod is such that:

floorDiv(x, y) * y + floorMod(x, y) == x
The difference in values between floorMod and the % operator操作符 is due to由于 the difference between (floorDiv that returns the integer less than or equal to the quotient商) and (the / operator that returns the integer closest to zero).

floorMod和％操作符之间的值之间的差异是由于，【返回的小于或等于商的整数floorDiv】与【返回最接近零的整数的/运算符】之间的差异。

Examples:

If the signs of the arguments are the same, the results of floorMod and the % operator are the same.  如果参数的符号相同，则floorMod和％运算符的结果是相同的。
floorMod(4, 3) == 1;   and (4 % 3) == 1
If the signs of the arguments are different, the results differ from the % operator.  如果参数的符号不同，则结果与％运算符不同。
floorMod(+4, -3) == -2;   and (+4 % -3) == +1
floorMod(-4, +3) == +2;   and (-4 % +3) == -1
floorMod(-4, -3) == -1;   and (-4 % -3) == -1
If the signs of arguments are unknown and a positive正 modulus is needed it can be computed as ( floorMod(x, y)  +  abs(y) )  %  abs(y).

• static long floorMod(long x, long y)

public static int floorMod(int x, int y) {
    return x - floorDiv(x, y) * y;
}

• static double nextDown(double d)：返回与负无穷大方向相邻的d的浮点值。
  
  这个方法语义上等同于nextAfter(d，Double.NEGATIVE_INFINITY); 然而，nextDown实现可能比其等同的nextAfter调用运行得更快。
• static float nextDown(float f)

public static double nextDown(double d) {
    if (Double.isNaN(d) || d == Double.NEGATIVE_INFINITY)  return d;
    else {
        if (d == 0.0)  return -Double.MIN_VALUE;
        else  return Double.longBitsToDouble(Double.doubleToRawLongBits(d) + ((d > 0.0d)?-1L:+1L));
    }
}

Math 常用 API 使用演示

Math.abs(12.3);                 //12.3 返回这个数的绝对值
Math.abs(-12.3);                //12.3  

Math.copySign(1.23, -12.3);     //-1.23,返回第一个参数的量值和第二个参数的符号
Math.copySign(-12.3, 1.23);     //12.3  

Math.signum(x);                 //如果x大于0则返回1.0，小于0则返回-1.0，等于0则返回0
Math.signum(12.3);              //1.0
Math.signum(-12.3);             //-1.0
Math.signum(0);                 //0.0  

//指数
Math.exp(x);                    //e的x次幂
Math.expm1(x);                  //e的x次幂 - 1  

Math.scalb(x, y);               //x*(2的y次幂）
Math.scalb(12.3, 3);            //12.3*2³  

//取整
Math.ceil(12.3);                //返回最近的且大于这个数的整数13.0
Math.ceil(-12.3);               //-12.0  

Math.floor(12.3);               //返回最近的且小于这个数的整数12.0
Math.floor(-12.3);              //-13.0  

//x和y平方和的二次方根
Math.hypot(x, y);               //√（x²+y²）  

//返回概述的二次方根
Math.sqrt(x);                   //√(x) x的二次方根
Math.sqrt(9);                   //3.0
Math.sqrt(16);                  //4.0  

//返回该数的立方根
Math.cbrt(27.0);                //3
Math.cbrt(-125.0);              //-5  

//对数函数
Math.log(e);                    //1 以e为底的对数
Math.log10(100);                //10 以10为底的对数
Math.log1p(x);                  //Ln（x+ 1）  

//返回较大值和较小值
Math.max(x, y);                 //返回x、y中较大的那个数
Math.min(x, y);                 //返回x、y中较小的那个数  

//返回 x的y次幂
Math.pow(x, y);
Math.pow(2, 3);                 //即2³ 即返回：8  

//随机返回[0,1)之间的无符号double值
Math.random();                    

//返回最接近这个数的整数,如果刚好居中，则取偶数
Math.rint(12.3);                //12.0
Math.rint(-12.3);               //-12.0
Math.rint(78.9);                //79.0
Math.rint(-78.9);               //-79.0
Math.rint(34.5);                //34.0
Math.rint(35.5);                //36.0  

Math.round(12.3);               //与rint相似，返回值为long  

//三角函数
Math.sin(α);                    //sin（α）的值
Math.cos(α);                    //cos（α）的值
Math.tan(α);                    //tan（α）的值  

//求角
Math.asin(x/z);                 //返回角度值[-π/2，π/2]  arc sin（x/z）
Math.acos(y/z);                 //返回角度值[0~π]   arc cos（y/z）
Math.atan(y/x);                 //返回角度值[-π/2，π/2]
Math.atan2(y-y0, x-x0);         //同上，返回经过点（x，y）与原点的的直线和经过点（x0，y0）与原点的直线之间所成的夹角  

Math.sinh(x);                   //双曲正弦函数sinh(x)=(exp(x) - exp(-x)) / 2.0;
Math.cosh(x);                   //双曲余弦函数cosh(x)=(exp(x) + exp(-x)) / 2.0;
Math.tanh(x);                   //tanh(x) = sinh(x) / cosh(x);  

//角度弧度互换
Math.toDegrees(angrad);         //角度转换成弧度，返回：angrad * 180d / PI  

Math.toRadians(angdeg);         //弧度转换成角度，返回：angdeg / 180d * PI  

2017-6-9

数值类 API

Number

抽象类 Number 的子类必须提供将表示的数值转换为 byte、double、float、int、long 和 short 的方法。

直接子类：AtomicInteger, AtomicLong, BigDecimal, BigInteger, Byte, Double, Float, Integer, Long, Short

• 构造方法 Number()
• byte byteValue() 以 byte 形式返回指定的数值。
• abstract double doubleValue() 以 double 形式返回指定的数值。
• abstract float floatValue() 以 float 形式返回指定的数值。
• abstract int intValue() 以 int 形式返回指定的数值。
• abstract long longValue() 以 long 形式返回指定的数值。
• short shortValue() 以 short 形式返回指定的数值。

Integer

public final class Integer extends Number implements Comparable<Integer>

Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。

此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。

构造方法

• Integer(int value) 构造一个新分配的 Integer 对象，它表示指定的 int 值。
• Integer(String s) 构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。

字段

• static int MAX_VALUE 值为 2^31－1 的常量，它表示 int 类型能够表示的最大值。
• static int MIN_VALUE 值为－2^31 的常量，它表示 int 类型能够表示的最小值。
• static int SIZE 用来以二进制补码形式表示 int 值的比特位数。
• static Class TYPE 表示基本类型 int 的 Class 实例。

静态方法

• static int bitCount(int i) 返回指定 int 值的二进制补码表示形式的 1 位的数量。
• static Integer getInteger(String nm) 确定具有指定名称的系统属性的整数值。
• static Integer getInteger(String nm, int val) 确定具有指定名称的系统属性的整数值。
• static Integer getInteger(String nm, Integer val) 返回具有指定名称的系统属性的整数值。
• static int signum(int i) 返回指定 int 值的符号函数。
• static int highestOneBit(int i) 返回具有至多单个 1 位的 int 值，在指定的 int 值中最高位（最左边）的 1 位的位置。
• static int lowestOneBit(int i) 返回具有至多单个 1 位的 int 值，在指定的 int 值中最低位（最右边）的 1 位的位置。
• static int numberOfLeadingZeros(int i) 在指定 int 值的二进制补码表示形式中最高位（最左边）的 1 位之前，返回零位的数量。
• static int numberOfTrailingZeros(int i) 返回指定的 int 值的二进制补码表示形式中最低（“最右边”）的为 1 的位后面的零位个数。
• static Integer decode(String nm) 将 String 解码为 Integer

跟在（可选）负号和/或基数说明符（“0x”、“0X”、“#”或前导零）后面的字符序列是使用指示的基数（10、16 或 8）通过 Integer.parseInt 方法解析的。

字符序列必须表示一个正值，否则会抛出 NumberFormatException。

如果指定的 String 的第一个字符是减号，则对结果求反。String 中不允许出现空白字符。

• static int parseInt(String s) 将字符串参数作为有符号的十进制整数进行解析

• 除了第一个字符可以是用来表示负值的 ASCII 减号 '-' ( '\u002D') 外，字符串中的字符都必须是十进制数字。返回得到的整数值，就好像将该参数和基数 10 作为参数赋予 parseInt(String, int) 方法一样。
• 参数：s - 包含要解析的 int 表示形式的 String。
• 返回：用十进制参数表示的整数值。

• 如果字符串不包含可解析的整数，NumberFormatException

• static int parseInt(String s, int radix) 使用第二个参数指定的基数，将字符串参数解析为有符号的整数

• 除了第一个字符可以是用来表示负值的 ASCII 减号 '-' ( '\u002D’)外，字符串中的字符必须都是指定基数的数字（通过 Character.digit(char, int) 是否返回一个负值确定）。返回得到的整数值。
• 如果发生以下任意一种情况，则抛出一个 NumberFormatException 类型的异常：

  1、第一个参数为 null 或一个长度为零的字符串。

  2、基数小于 Character.MIN_RADIX 或者大于 Character.MAX_RADIX。

  3、假如字符串的长度超过 1，那么除了第一个字符可以是减号 '-' ('u002D’) 外，字符串中存在任意不是由指定基数的数字表示的字符。

  4、字符串表示的值不是 int 类型的值。

• 参数：radix - 解析 s 时使用的基数。

• 返回：使用指定基数的字符串参数表示的整数。

• static int reverse(int i) 返回通过反转指定 int 值的二进制补码表示形式中位的顺序而获得的值。

• static int reverseBytes(int i) 返回通过反转指定 int 值的二进制补码表示形式中字节的顺序而获得的值。
• static int rotateLeft(int i, int distance) 返回根据指定的位数循环左移指定的 int 值的二进制补码表示形式而得到的值。
• static int rotateRight(int i, int distance) 返回根据指定的位数循环右移指定的 int 值的二进制补码表示形式而得到的值。
• static String toBinaryString(int i) 以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。
• static String toHexString(int i) 以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。
• static String toOctalString(int i) 以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。

• static String toString(int i) 返回一个表示指定整数的 String 对象。

  将该参数转换为有符号的十进制表示形式，以字符串形式返回它，就好像将参数和基数 10 作为参数赋予 toString(int, int) 方法。

• static String toString(int i, int radix) 返回用第二个参数指定基数表示的第一个参数的字符串表示形式。

• 如果基数radix小于 Character.MIN_RADIX 或者大于 Character.MAX_RADIX，则改用基数 10。
• 如果第一个参数为负，则结果中的第一个元素为 ASCII 的减号 '-' ('\u002D')。如果第一个参数为非负，则没有符号字符出现在结果中。
• 结果中的剩余字符表示第一个参数的大小。如果大小为零，则用一个零字符 '0' ('\u0030') 表示；否则，大小的表示形式中的第一个字符将不是零字符。
• 用以下 ASCII 字符作为数字：0123456789abcdefghijklmnopqrstuvwxyz。其范围是从 '\u0030' 到 '\u0039' 和从 '\u0061' 到 '\u007A'。

• 如果 radix 为 N, 则按照所示顺序，使用这些字符中的前 N 个作为其数字。因此，十六进制（基数为 16）的数字是 0123456789abcdef。

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

  如果不需要新的 Integer 实例，则通常应优先使用该方法，而不是构造方法 Integer(int)，因为该方法有可能通过缓存经常请求的值而显著提高空间和时间性能。

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

  将该参数解释为表示一个有符号的十进制整数, 就好像将该参数赋予 parseInt(String) 方法一样。结果是一个表示字符串指定的整数值的 Integer 对象。

  该方法返回一个等于以下值的 Integer 对象：new Integer(Integer.parseInt(s))

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

  该方法返回一个等于以下值的 Integer 对象：new Integer(Integer.parseInt(s, radix))

公共方法

• byte byteValue() 以 byte 类型返回该 Integer 的值。
• double doubleValue() 以 double 类型返回该 Integer 的值。
• float floatValue() 以 float 类型返回该 Integer 的值。 int intValue() 以 int 类型返回该 Integer 的值。
• long longValue() 以 long 类型返回该 Integer 的值。
• short shortValue() 以 short 类型返回该 Integer 的值。

重载自Object的方法

• int compareTo(Integer anotherInteger) 在数字上比较两个 Integer 对象。
• boolean equals(Object obj) 比较此对象与指定对象。
• int hashCode() 返回此 Integer 的哈希码。
• String toString() 返回一个表示该 Integer 值的 String 对象。

Float

public final class Float extends Number implements Comparable<Float>

Float 类在对象中包装一个基本类型 float 的值。Float 类型的对象包含一个 float 类型的字段。

此外，此类提供了几种方法，可将 float 类型与 String 类型互相转换，还提供了处理 float 类型时非常有用的其他一些常量和方法。

构造方法

• Float(double value) 构造一个新分配的 Float 对象，它表示转换为 float 类型的参数。
• Float(float value) 构造一个新分配的 Float 对象，它表示基本的 float 参数。
• Float(String s) 构造一个新分配的 Float 对象，它表示用字符串表示的 float 类型的浮点值。

静态字段

• static int MAX_EXPONENT 有限 float 变量可能具有的最大指数。它等于 Math.getExponent(Float.MAX_VALUE) 返回的值。
• static int MIN_EXPONENT 标准化 float 变量可能具有的最小指数。它等于 Math.getExponent(Float.MIN_NORMAL) 返回的值。
• static float MAX_VALUE 保存 float 类型的最大正有限值的常量，即 (2-2^-23)·2^127。它等于十六进制的浮点字面值 0x1.fffffeP+127f，也等于 Float.intBitsToFloat(0x7f7fffff)。
• static float MIN_VALUE 保存 float 类型数据的【最小正非零值】的常量，即 2^-149。它等于十六进制的浮点字面值 0x1.0p-126f，也等于 Float.intBitsToFloat(0x00800000)。
• static float MIN_NORMAL 保存 float 类型数据的最小正标准值的常量，即 2^-126。它等于十六进制的浮点字面值 0x1.0p-126f，也等于 Float.intBitsToFloat(0x00800000)。
• static float NaN 保存 float 类型的非数字 (NaN) 值的常量。它等于 Float.intBitsToFloat(0x7fc00000) 返回的值。
• static float NEGATIVE_INFINITY 保存 float 类型的负无穷大值的常量。它等于 Float.intBitsToFloat(0xff800000) 返回的值。
• static float POSITIVE_INFINITY 保存 float 类型的正无穷大值的常量。它等于 Float.intBitsToFloat(0x7f800000) 返回的值。
• static int SIZE 表示一个 float 值所使用的位数。
• static Class TYPE 表示 float 基本类型的 Class 实例。

静态方法

• static int compare(float f1, float f2) 比较两个指定的 float 值。
• static int floatToIntBits(float value) 根据 IEEE 754 浮点“单一格式”位布局，返回指定浮点值的表示形式。
• static int floatToRawIntBits(float value) 根据 IEEE 754 浮点“单一格式”位布局，返回指定浮点值的表示形式，并保留非数字 (NaN) 值。
• static float intBitsToFloat(int bits) 返回对应于给定位表示形式的 float 值。
• static boolean isInfinite(float v) 如果指定数的数值是无穷大，则返回 true，否则返回 false。
• static boolean isNaN(float v) 如果指定的数是一个非数字 (NaN) 值，则返回 true，否则返回 false。
• static float parseFloat(String s) 返回一个新的 float 值，该值被初始化为用指定 String 表示的值，这与 Float 类的 valueOf 方法一样。
• static String toHexString(float f) 返回 float 参数的十六进制字符串表示形式。
• static String toString(float f) 返回 float 参数的字符串表示形式。
• static Float valueOf(float f) 返回表示指定的 float 值的 Float 实例。
• static Float valueOf(String s) 返回保存用参数字符串 s 表示的 float 值的 Float 对象。

公共方法

• byte byteValue() 将此 Float 值以 byte 形式返回（强制转换为 byte）。
• double doubleValue() 返回此 Float 对象的 double 值。
• float floatValue() 返回此 Float 对象的 float 值。
• int intValue() 将此 Float 值以 int 形式返回（强制转换为 int 类型）。
• boolean isInfinite() 如果此 Float 值的大小是无穷大，则返回 true，否则返回 false。
• boolean isNaN() 如果此 Float 值是一个非数字 (NaN) 值，则返回 true，否则返回 false。
• long longValue() 将此 Float 值以 long 形式返回（强制转换为 long 类型）。
• short shortValue() 将此 Float 值以 short 形式返回（强制转换为 short）。

重载自Object的方法

• int compareTo(Float anotherFloat) 比较两个 Float 对象所表示的数值。
• boolean equals(Object obj) 将此对象与指定对象进行比较。
• int hashCode() 返回此 Float 对象的哈希码。
• String toString() 返回此 Float 对象的字符串表示形式。

Random

java.util.Random extends java.lang.Object Number implements Serializable

此类的实例用于生成伪随机数流。此类使用 48 位的种子，使用线性同余公式 (linear congruential form) 对其进行了修改。

如果用相同的种子创建两个 Random 实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。为了保证此属性的实现，为类 Random 指定了特定的算法。为了 Java 代码的完全可移植性，Java 实现必须让类 Random 使用此处所示的所有算法。但是允许 Random 类的子类使用其他算法，只要其符合所有方法的常规协定即可。

Random 类实现的算法使用一个 protected 实用工具方法，每次调用它最多可提供 32 个伪随机生成的位。

很多应用程序会发现 Math.random() 方法更易于使用。

构造方法

• Random() 创建一个新的随机数生成器。
  
  此构造方法将随机数生成器的种子设置为某个值，该值与此构造方法的所有其他调用所用的值完全不同。
• Random(long seed) 使用单个 long 种子创建一个新的随机数生成器。 参数：seed - 初始种子
  
  该种子是伪随机数生成器的内部状态的初始值，该生成器可通过方法 next(int) 维护。
  
  调用 new Random(seed) 等效于： Random r = new Random(); r.setSeed(seed);

方法

• protected int next(int bits) 生成下一个伪随机数。当被所有其他方法使用时，子类应该重写此方法。

• next 的常规协定是，返回一个 int 值，如果参数 bits 位处于 [ 1 , 32 ] 之间，那么返回值的多数低位都将（大致）是单独选择的位值，每个位值是 0 或 1 的机会（大致）相等。
• 参数：bits - 随机位。

• 返回：随机数生成器序列的下一个伪随机值。

• void setSeed(long seed) 使用单个 long 种子设置此随机数生成器的种子。

• setSeed 的常规协定是它更改此随机数生成器对象的状态，使其状态好像是刚刚使用参数 seed 作为种子创建它的状态一样。
• 通过将种子自动更新为 (seed ^ 0x5DEECE66DL) & ((1L << 48) - 1) 并清除 nextGaussian() 使用的 haveNextNextGaussian 标志， Random 类可实现 setSeed 方法。
• Random 类实现的 setSeed 恰好只使用 48 位的给定种子。但是，通常重写方法可能使用 long 参数的所有 64 位作为种子值。

生成一个指定的伪随机数

• boolean nextBoolean() 返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 boolean 值。
  
  nextBoolean 的常规协定是，伪随机地生成并返回一个 boolean 值。值 true 和 false 的生成概率（大致）相同。
  
  Random 类按如下方式实现 nextBoolean 方法： public boolean nextBoolean() { return next(1) != 0; }

• void nextBytes(byte[] bytes) 生成随机字节并将其置于用户提供的 byte 数组中。
  
  所生成的随机字节数等于该 byte 数组的长度。
  
  参数：bytes - 用随机字节填充的 byte 数组

• double nextDouble() 返回下一个伪随机数，它是取自此随机数生成器序列的、在 [ 0.0 , 1.0 ) 之间均匀分布的 double 值。
  
  nextDouble 的常规协定是，伪随机地生成并返回一个从 0.0d（包括）到 1.0d（不包括）范围内均匀选择（大致）的 double 值。
  
  Random 类按如下方式实现 nextDouble 方法： public double nextDouble() { return (((long)next(26) << 27) + next(27)) / (double)(1L << 53); }

• float nextFloat() 返回下一个伪随机数，它是取自此随机数生成器序列的、在 [ 0.0 , 1.0 ] 之间均匀分布的 float 值。
  
  nextFloat 的常规协定是，伪随机地生成并返回一个从 0.0f（包括）到 1.0f（包括）范围内均匀选择（大致）的 float 值。所有可能的 2^24 个 float 值（其形式为 m x 2^-24，其中 m 是一个小于 2^24 的正整数）的生成概率（大致）相同。
  
  Random 类按如下方式实现 nextFloat 方法： public float nextFloat() { return next(24) / ((float)(1 << 24)); }

• double nextGaussian() 返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的 double 值，其平均值是 0.0，标准差是 1.0。
  
  nextGaussian 的常规协定是，伪随机地生成并返回一个 double 值，该值从（大致）具有平均值 0.0 和标准差 1.0 的标准正态分布中选择。

• int nextInt() 返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
  
  nextInt 的常规协定是，伪随机地生成并返回一个 int 值。所有 2^32 个可能 int 值的生成概率（大致）相同。
  
  Random 类按如下方式实现 nextInt 方法： public int nextInt() { return next(32); }

• int nextInt(int n) 返回一个伪随机数，它是取自此随机数生成器序列的、在 [ 0 , 指定值 ) 之间均匀分布的 int 值。
  
  nextInt 的常规协定是，伪随机地生成并返回指定范围中的一个 int 值。所有可能的 n 个 int 值的生成概率（大致）相同。
  
  n 必须为正数，否则抛出IllegalArgumentException

• long nextLong() 返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值。
  
  Random 类按如下方式实现 nextLong 方法： public long nextLong() { return ((long)next(32) << 32) + next(32); }
  
  因为 Random 类使用只以 48 位表示的种子，所以此算法不会返回所有可能的 long 值。

示例代码

自动装箱和拆箱

Integer i = 4; //自动装箱，会自动转换为以下形式：Integer i = new Integer(4);
i += 6; //先自动拆箱为int，后再自动装箱为Integer
System.out.println(i);//10。这里 i 仍为Integer，只不过会自动调用 i.toString() 方法

关于是否相等

System.out.println(new Integer(128) == new Integer(128));//false
System.out.println(new Integer(127) == new Integer(127));//false
System.out.println("*****************************************");
Integer c1 = 128;//等价于 Integer c1 =new Integer(128);
Integer c2 = 128;
System.out.println(c1 == c2);//false
Integer d1 = 127;
Integer d2 = 127;
System.out.println(d1 == d2);//true，若自动装箱的是【一个字节】，那么该对象会被共享不会重新创建
System.out.println("*****************************************");
int e1 = 127;
Integer e2 = 127;
System.out.println(e1 == e2);//true
System.out.println(e1 == new Integer(127));//true
System.out.println(e2 == new Integer(127));//false

基本类型和字符串相互装换

// 基本类型--->字符串
System.out.println(123 + 1 + "");//124
System.out.println("" + 123 + 1);//1231
System.out.println(Integer.toString(123) + 1);//1231
System.out.println(String.valueOf(123) + 1);//1231
System.out.println("******************************************");
// 字符串--->基本类型
System.out.println(new Integer(123) + 1);//124，先自动拆箱，后自动装箱
System.out.println(new Integer("123") + 1);//124
System.out.println(Integer.parseInt("123") + 1);//124
System.out.println(new Integer("123").intValue());//123
System.out.println(new Integer(123).intValue());//123

进制转换

// 十进制-->其他进制
System.out.println(Integer.toBinaryString(16));//2进制，10000
System.out.println(Integer.toOctalString(16));//8进制，20
System.out.println(Integer.toHexString(16));//16进制，10
System.out.println(Integer.toString(16, 2));//可转化为任意进制，10000
System.out.println("*******************************************");
// 某进制的字符串-->十进制数
System.out.println(Integer.parseInt("-06"));//-6，将十进制字符串转换为十进制数
System.out.println(Integer.parseInt("-10", 2));//-2，将二进制字符串转换为十进制数
System.out.println(Integer.parseInt("-10", 16));//-16，将16进制字符串转换为十进制数  

包装类中封装的基本信息

//包装类中封装的基本信息
System.out.println(Boolean.TYPE);//boolean。注意boolean类型没有给出精确的定义，所以Boolean类中也没有定义BYTES等静态字段的值
System.out.println(Character.TYPE + "  " + Character.BYTES + "  " + (0 + Character.MIN_VALUE) + "  " + (0 + Character.MAX_VALUE));//char  2  0  65535

//整数类型。在Java7之后可以在数字字面【数字之间】的任何位置添加任何数量的下划线"_"
System.out.println(Byte.TYPE + "  " + Byte.BYTES + "  " + Byte.MIN_VALUE + "  " + Byte.MAX_VALUE);//byte  1  -128  127
System.out.println(Short.TYPE + "  " + Short.BYTES + "  " + Short.MIN_VALUE + "  " + Short.MAX_VALUE);//short  2  -32768  32767
System.out.println(Integer.TYPE + "  " + Integer.BYTES + "  " + Integer.MIN_VALUE + "  " + Integer.MAX_VALUE);//int  4  -21474_83648  21474_83647，十位数，约21亿
System.out.println(Long.TYPE + "  " + Long.BYTES + "  " + Long.MIN_VALUE + "  " + Long.MAX_VALUE);//long  8  -92233_72036_85477_5808  92233_72036_85477_5807，小于20位数

//浮点类型
System.out.println(Float.TYPE + "  " + Float.BYTES + "  " + Float.MIN_VALUE + "  " + Float.MAX_VALUE);//float  4  1.4E-45(最小正非零值)  3.4028_235E38
System.out.println(Double.TYPE + "  " + Double.BYTES + "  " + Double.MIN_VALUE + "  " + Double.MAX_VALUE);//double  8  4.9E-324(最小正非零值)  1.7976_93134_86231_57E308

//要注意了，浮点类型所能表示的最大值是远远远远远远大于整形同长度位数所能表示的最大值的，因为它是采用科学计数法表示的
//更要注意，虽然浮点型(如float)所能表示的最大值远远大于整形同长度位数(如int)所能表示的最大值，但精度却远远小于int
System.out.println((float) Integer.MAX_VALUE + "  " + Integer.MAX_VALUE);//2.1474_8365E9  21474_83647
System.out.println((double) Long.MAX_VALUE + "  " + Long.MAX_VALUE);//9.2233_72036_85477_6E18  92233_72036_85477_5807

2017-8-27