深入學習java原始碼之Math.max()與 Math.min()

java基本資料型別及自動轉型

8種基本資料型別及其所佔空間大小：

一、byte，佔用一個位元組，取值範圍為 -128-127，預設是“\u0000”，表示空
二、short，佔用兩個位元組，取值範圍為 -32768-32767
三、int，佔用四個位元組，-2147483648-2147483647
四、long，佔用八個位元組，對 long 型變數賦值時必須加上"L"或“l”,否則不認為是 long 型
五、float，佔用四個位元組，對 float 型進行賦值的時候必須加上“F”或“f”，如果不加，會產生編譯錯誤，因為系統
自動將其定義為 double 型變數。double轉換為float型別資料會損失精度。float a = 12.23產生編譯錯誤的，float a = 12是正確的
六、double，佔用八個位元組，對 double 型變數賦值的時候最好加上“D”或“d”，但加不加不是硬性規定
七、char,佔用兩個位元組，在定義字元型變數時，要用單引號括起來
八、boolean，只有兩個值“true”和“false”，預設值為false，不能用0或非0來代替，這點和C語言不同
 

自動型別轉換

1）兩種型別是彼此相容的

2）轉換的目的型別佔得空間範圍一定要大於轉化的源型別

正向過程：由低位元組向高位元組自動轉換

byte->short->int->long->float->double

逆向過程：使用強制轉換,可能丟失精度。

// 自動型別轉換
short s=1;
int i;
// 自動型別轉換 short型別轉成int型別
i=s;

整數型別（byte/short/int/long）中，對於未宣告資料型別的整形，其預設型別為int型。在浮點型別（float/double）中，對於未宣告資料型別的浮點型，預設為double型。

int a=(int)3.14;

 小數的預設數字型別是double, 例如3.12. 當float a = 3.12時會報錯, 因為3.12的預設資料型別是double, 我們需要使用如下的賦值方法:

float a = 3.12F
float b = (float)3.12

第一種方法在3.12後面加了一個F, 告訴編譯器這是一個float的數. 第二種方法對3.12進行了強制的型別轉換. 

double d=1.333;
float f;
// 把double型別的資料強制轉換成float型別
f=(float)d;

int x;
double y;
x = (int)34.56 + (int)11.2;  // 丟失精度
y = (double)x + (double)10 + 1;  // 提高精度
System.out.println("x=" + x);
System.out.println("y=" + y);

x=45
y=56.0
 

java原始碼

public final class Math {

    private Math() {}

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

    public static long max(long a, long b) {
        return (a >= b) ? a : b;
    }
    //在有保證的非NaN引數上使用原始的逐位轉換。
    private static long negativeZeroFloatBits  = Float.floatToRawIntBits(-0.0f);
    private static long negativeZeroDoubleBits = Double.doubleToRawLongBits(-0.0d);

    public static float max(float a, float b) {
        if (a != a)
            return a;   // a is NaN
        if ((a == 0.0f) &&
            (b == 0.0f) &&
            (Float.floatToRawIntBits(a) == negativeZeroFloatBits)) {
            // Raw conversion ok since NaN can't map to -0.0.
            return b;
        }
        return (a >= b) ? a : b;
    }

    public static double max(double a, double b) {
        if (a != a)
            return a;   // a is NaN
        if ((a == 0.0d) &&
            (b == 0.0d) &&
            (Double.doubleToRawLongBits(a) == negativeZeroDoubleBits)) {
            // Raw conversion ok since NaN can't map to -0.0.
            return b;
        }
        return (a >= b) ? a : b;
    }

    public static int min(int a, int b) {
        return (a <= b) ? a : b;
    }

    public static long min(long a, long b) {
        return (a <= b) ? a : b;
    }

    public static float min(float a, float b) {
        if (a != a)
            return a;   // a is NaN
        if ((a == 0.0f) &&
            (b == 0.0f) &&
            (Float.floatToRawIntBits(b) == negativeZeroFloatBits)) {
            // Raw conversion ok since NaN can't map to -0.0.
            return b;
        }
        return (a <= b) ? a : b;
    }

    public static double min(double a, double b) {
        if (a != a)
            return a;   // a is NaN
        if ((a == 0.0d) &&
            (b == 0.0d) &&
            (Double.doubleToRawLongBits(b) == negativeZeroDoubleBits)) {
            // Raw conversion ok since NaN can't map to -0.0.
            return b;
        }
        return (a <= b) ? a : b;
    }	

}

public final class StrictMath {

    private StrictMath() {}

    public static int max(int a, int b) {
        return Math.max(a, b);
    }

    public static long max(long a, long b) {
        return Math.max(a, b);
    }

    public static float max(float a, float b) {
        return Math.max(a, b);
    }	
   
    public static double max(double a, double b) {
        return Math.max(a, b);
    }
	
    public static int min(int a, int b) {
        return Math.min(a, b);
    }

    public static long min(long a, long b) {
        return Math.min(a, b);
    }

    public static float min(float a, float b) {
        return Math.min(a, b);
    }

    public static double min(double a, double b) {
        return Math.min(a, b);
    }
}