前言
今天来看看Double这个类的源码。
Double相关概念
Double是被final修饰的，因此该类不能被继承。另外它是double类的包装类。继承了抽象类Number，并且实现了Comparable接口，所以可以进行参数的比较。
Double源码
package java.lang;import jdk.internal.HotSpotIntrinsicCandidate;import jdk.internal.math.DoubleConsts;import jdk.internal.math.FloatingDecimal;// Double是被final修饰的，因此该类不能被继承。另外它是double类的包装类。继承了抽象类Number，并且实现了Comparable接口，所以可以进行参数的比较。public final class Double extends Number implements Comparable<Double> { /** use serialVersionUID from JDK 1.0.2 for interoperability */ private static final long serialVersionUID = -9172774392245257468L; // 相当于double.class @SuppressWarnings("unchecked") public static final Class TYPE = (Class) Class.getPrimitiveClass("double"); /** * 代表正无穷大的常数：Infinity * 该返回值 等于 Double.longBitsToDouble(0x7ff0000000000000L) * 说明：这是java的规定，没必要深究为什么1.0/0.0不报错，不过1/0肯定报错 */ public static final double POSITIVE_INFINITY = 1.0 / 0.0; /** * 代表负无穷大的常数：-Infinity * 该返回值 等于 Double.longBitsToDouble(0xfff0000000000000L) * 说明：这是java的规定，没必要深究为什么-1.0/0.0不报错，不过-1/0肯定报错 */ public static final double NEGATIVE_INFINITY = -1.0 / 0.0; /** * 代表非数字 * 该返回值 等于 Double.longBitsToDouble(0x7ff8000000000000L) */ public static final double NaN = 0.0d / 0.0; /** * Double最大值： * (2-2^-52)*2^1023 = 1.7976931348623157e+308 */ public static final double MAX_VALUE = 0x1.fffffffffffffP+1023; /** * Double最小正值： * 2^-1022 = 2.2250738585072014E-308 * 相当于 Double.longBitsToDouble(0x0010000000000000L) * @since 1.6 */ public static final double MIN_NORMAL = 0x1.0p-1022; /** * Double最小非零值： * 2^-1074 = 4.9e-324 * 相当于 Double.longBitsToDouble(0x1L) */ public static final double MIN_VALUE = 0x0.0000000000001P-1022; /** * 最大指数 * @since 1.6 */ public static final int MAX_EXPONENT = 1023; /** * 最小指数 * @since 1.6 */ public static final int MIN_EXPONENT = -1022; /** * 当前类型所占bit[位]数：64位 *一个Double占64位 * @since 1.5 */ public static final int SIZE = 64; /** * *当前类型所占字节数(Double类型占8个字节) * 64 / 8 = 8 * @since 1.8 */ public static final int BYTES = SIZE / Byte.SIZE; /** * 当前类包装的值 * * @serial */ private final double value; /** * Double有参构造，传入double类型参数，用于创建Double对象 */ @Deprecated(since = "9") public Double(double value) { this.value = value; } /** * Double 有参构造，传入String类型参数，用于创建Double对象 */ @Deprecated(since = "9") public Double(String s) throws NumberFormatException { value = parseDouble(s); } /** *double-->Double 默认的装箱行为 * @since 1.5 */ @HotSpotIntrinsicCandidate public static Double valueOf(double d) { return new Double(d); } /** * 将字符串s解析为double值，然后再装箱位Double类型 */ public static Double valueOf(String s) throws NumberFormatException { return new Double(parseDouble(s)); } /** *重写父类(Number)方法，将Double值转换为byte类型 * @since 1.1 */ public byte byteValue() { return (byte) value; } /** * 重写父类(Number)方法，将Double值转换为short类型 * @since 1.1 */ public short shortValue() { return (short) value; } /** * 重写父类(Number)方法，将Double值转换为int类型 */ public int intValue() { return (int) value; } /** * 重写父类(Number)方法，将Double值转换为int类型 */ // 以long形式返回当前对象的值 public long longValue() { return (long) value; } /** * 重写父类(Number)方法，将Double值转换为float类型 * @since 1.0 */ public float floatValue() { return (float) value; } /** * 重写父类(Number)方法，将Double值转换为double 默认的拆箱行为 */ @HotSpotIntrinsicCandidate public double doubleValue() { return value; } /** * 将字符串s解析为double值 * @since 1.2 */ public static double parseDouble(String s) throws NumberFormatException { return FloatingDecimal.parseDouble(s); } /** *将当前Double转为字符串返回 */ public String toString() { return toString(value); } /** * 将double数据转换成字符串 */ public static String toString(double d) { return FloatingDecimal.toJavaFormatString(d); } /** * 将10进制的double转换成16进制的字符串 * 例：567.9D --> 0x1.1bf3333333333p9 * @since 1.5 */ public static String toHexString(double d) { if(!isFinite(d)) // 对于无穷大和NaN，请使用小数输出。 return Double.toString(d); else { // 初始化为最大输出大小为24(默认16) StringBuilder answer = new StringBuilder(24); // d为负，将"-"添加在首位 if(Math.copySign(1.0, d) == -1.0) answer.append("-"); // 添加16进制的标志(0x开头表示为16进制) answer.append("0x"); // 求绝对值 d = Math.abs(d); if(d == 0.0) { answer.append("0.0p0"); } else { // 判断是以1开头还是以0开头 boolean subnormal = (d // Isolate significand bits and OR in a high-order bit so that the string representation has a known length. long signifBits = (Double.doubleToLongBits(d) & DoubleConsts.SIGNIF_BIT_MASK) | 0x1000000000000000L; // Subnormal values have a 0 implicit bit; normal values have a 1 implicit bit. answer.append(subnormal ? "0." : "1."); // 获取小数位的16进制 String signif = Long.toHexString(signifBits).substring(3, 16); answer.append(signif.equals("0000000000000") ? // 13 zeros "0" : signif.replaceFirst("0{1,12}$", "")); answer.append('p'); /* * 计算该值是2的多少次方 */ answer.append(subnormal ? Double.MIN_EXPONENT : Math.getExponent(d)); } return answer.toString(); } } /** *比较两个double数据,返回-1，0，1 * @since 1.4 */ public static int compare(double d1, double d2) { if(d1 return -1; if(d1>d2) return 1; // 由于NaNs的可能性，不能使用doubleToRawLongBits long thisBits = Double.doubleToLongBits(d1); long anotherBits = Double.doubleToLongBits(d2); return (thisBits == anotherBits ? 0 // Values are equal : (thisBits ? -1 // (-0.0, 0.0) or (!NaN, NaN) : 1) // (0.0, -0.0) or (NaN, !NaN) ); } /** *比较两个double数据 * @since 1.2 */ public int compareTo(Double anotherDouble) { return Double.compare(value, anotherDouble.value); } /** * 先计算value的二进制格式，然后返回该二进制格式表示的long */ @HotSpotIntrinsicCandidate public static long doubleToLongBits(double value) { if(!isNaN(value)) { return doubleToRawLongBits(value); } return 0x7ff8000000000000L; } /** *先计算value的二进制格式，然后返回该二进制格式表示的long * @since 1.3 */ @HotSpotIntrinsicCandidate public static native long doubleToRawLongBits(double value); /** * 先计算bits的二进制格式，然后返回该二进制格式表示的double */ @HotSpotIntrinsicCandidate public static native double longBitsToDouble(long bits); /** * 求和, jdk8新增运算 * @since 1.8 */ public static double sum(double a, double b) { return a + b; } /** *求最大值, jdk8新增运算 * @since 1.8 */ public static double max(double a, double b) { return Math.max(a, b); } /** * 求最小值, jdk8新增运算 * @since 1.8 */ public static double min(double a, double b) { return Math.min(a, b); } /** * 判断当前double值是否为NaN */ public boolean isNaN() { return isNaN(value); } /** * 判断v是否为NaN */ public static boolean isNaN(double v) { return (v != v); } /** * 判断当前double值是否为正无穷大/负无穷大 */ public boolean isInfinite() { return isInfinite(value); } /** * 判断v是否为正无穷大/负无穷大 */ public static boolean isInfinite(double v) { return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY); } /** * 判断d是否为有限值 * @since 1.8 */ public static boolean isFinite(double d) { return Math.abs(d)<=Double.MAX_VALUE; } /** *获取double数据的hashCode */ @Override public int hashCode() { return Double.hashCode(value); } /** * 计算double数据的hashCode * * @since 1.8 */ public static int hashCode(double value) { long bits = doubleToLongBits(value); return (int) (bits ^ (bits >>> 32)); } /** * 比较两个double数据 */ public boolean equals(Object obj) { return (obj instanceof Double) && (doubleToLongBits(((Double) obj).value) == doubleToLongBits(value)); } }Double源码测试
1.取值范围测试
@Testpublic void test(){ // 正无穷大的常数 System.out.println(Double.POSITIVE_INFINITY);// Infinity // 负无穷大的常数 System.out.println(Double.NEGATIVE_INFINITY);// -Infinity // 非数字 System.out.println(Double.NaN);// NaN // Double最大值：(2-2^-52)*2^1023 System.out.println(Double.MAX_VALUE);// 1.7976931348623157e+308 // Double最小正值：2^-1022 System.out.println(Double.MIN_NORMAL); // 2.2250738585072014E-308 // Double最小非零值：：2^-1074，正规数 System.out.println(Double.MIN_VALUE);// 4.9e-324 // Double最大指数 1023 System.out.println(Double.MAX_EXPONENT); // Double最小指数 -1022 System.out.println(Double.MIN_EXPONENT); System.out.println("Double所占用的位数：" + Double.SIZE);// 64 System.out.println("Double所占用的字节数：" + Double.BYTES);// 8}2 . Double和String方法测试
@Testpublic void testpparse(){ //将String转为Double System.out.println(Double.parseDouble("16"));// 16.0 //将Double转为String System.out.println(Double.toString(16));// 16.0}
3.public static String toHexString(double d)方法测试
@Testpublic void testtoHexString(){ System.out.println(Double.toHexString(4));// 0x1.0p2 System.out.println(Double.toHexString(-4));// -0x1.0p2}4.public static int compare(float f1, float f2)方法测试
@Testpublic void testcompare(){ //==比较0f和-0f是相等的，但compare方法比较时0f>-0f。 System.out.println(0f==-0f);//true System.out.println(Double.compare(0f,-0f));//1 //==比较NaN和NaN是不相等的，但compare方法比较时相等。 System.out.println(Double.NaN==Double.NaN);//false System.out.println(Double.NaN==Double.NaN+1);//false System.out.println(Double.compare(Double.NaN,Double.NaN));//0 System.out.println(Double.compare(Double.NaN,Double.NaN+1));//0 //compare方法比较时,Double.NaN大于任何非NaN System.out.println(Double.compare(Double.NaN,Double.MAX_VALUE));//1 System.out.println(Double.compare(Double.NaN,Double.POSITIVE_INFINITY));//1}5.常用计算方法测试
@Testpublic void testsum(){ // 获取两数之和 System.out.println(Double.sum(-1f, -20f)); // -21.0 // 获取两个值中最大的一个 System.out.println(Double.max(-1f, -20f)); // -1.0 // 获取两个值中最小的一个 System.out.println(Double.min(-1f, -20f)); // -20.0}6.public static long doubleToLongBits(double value)方法测试
@Test public void testdoubleToLongBits(){ System.out.println(Double.doubleToLongBits(0));//0 System.out.println(Double.doubleToLongBits(2));//4611686018427387904 System.out.println(Double.doubleToLongBits(4));//4616189618054758400 }7.public static int hashCode(double value)方法测试
@Testpublic void testhashCode(){ System.out.println(Double.hashCode(2));// 1073741824 System.out.println(Double.hashCode(4));// 1074790400}
长
按
关
注
解锁更多精彩内容
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
