mirror of
https://github.com/openjdk/jdk.git
synced 2025-08-27 23:04:50 +02:00
Initial work for JDK-8257086.
This commit is contained in:
parent
6ff18e38b4
commit
8193683fc2
1 changed files with 65 additions and 18 deletions
|
@ -790,7 +790,15 @@ public final class Double extends Number
|
||||||
* #doubleToLongBits(double)} returns the identical
|
* #doubleToLongBits(double)} returns the identical
|
||||||
* {@code long} value when applied to each.
|
* {@code long} value when applied to each.
|
||||||
*
|
*
|
||||||
* <p>Note that in most cases, for two instances of class
|
* @apiNote
|
||||||
|
* This method is defined in terms of {@link
|
||||||
|
* #doubleToLongBits(double)} rather than the {@code ==} operator
|
||||||
|
* on {@code double} values since the {@code ==} operator does
|
||||||
|
* <em>not</em> define an equivalence relation and to satisfy the
|
||||||
|
* {@linkplain Object#equals equals contract} an equivalence
|
||||||
|
* relation must be implemented.
|
||||||
|
*
|
||||||
|
* However, in most cases, for two instances of class
|
||||||
* {@code Double}, {@code d1} and {@code d2}, the
|
* {@code Double}, {@code d1} and {@code d2}, the
|
||||||
* value of {@code d1.equals(d2)} is {@code true} if and
|
* value of {@code d1.equals(d2)} is {@code true} if and
|
||||||
* only if
|
* only if
|
||||||
|
@ -800,23 +808,48 @@ public final class Double extends Number
|
||||||
* </blockquote>
|
* </blockquote>
|
||||||
*
|
*
|
||||||
* <p>also has the value {@code true}. However, there are two
|
* <p>also has the value {@code true}. However, there are two
|
||||||
* exceptions:
|
* exceptions where the properties of an equivalence relations are
|
||||||
|
* not satisfied by {@code ==}:
|
||||||
* <ul>
|
* <ul>
|
||||||
* <li>If {@code d1} and {@code d2} both represent
|
* <li>If {@code d1} and {@code d2} both represent
|
||||||
* {@code Double.NaN}, then the {@code equals} method
|
* {@code Double.NaN}, then the {@code equals} method
|
||||||
* returns {@code true}, even though
|
* returns {@code true}, even though
|
||||||
* {@code Double.NaN==Double.NaN} has the value
|
* {@code Double.NaN==Double.NaN} has the value
|
||||||
* {@code false}.
|
* {@code false}. Therefore, for two NaN arguments the
|
||||||
|
* <em>reflexive</em> property of an equivalence relation is
|
||||||
|
* <em>not</em> satisfied by the {@code ==} operator.
|
||||||
|
*
|
||||||
* <li>If {@code d1} represents {@code +0.0} while
|
* <li>If {@code d1} represents {@code +0.0} while
|
||||||
* {@code d2} represents {@code -0.0}, or vice versa,
|
* {@code d2} represents {@code -0.0}, or vice versa,
|
||||||
* the {@code equal} test has the value {@code false},
|
* the {@code equals} method returns the value {@code false},
|
||||||
* even though {@code +0.0==-0.0} has the value {@code true}.
|
* even though {@code +0.0==-0.0} has the value {@code true}.
|
||||||
|
*
|
||||||
|
* In other words, while {@code +0.0} and {@code -0.0} compare
|
||||||
|
* as equal under the {@code ==} operator, they are
|
||||||
|
* <em>not</em> equivalent values because signed zeros can be
|
||||||
|
* distinguished under other floating-point operations. For
|
||||||
|
* example, {@code 1.0/+0.0} evaluates to positive infinity
|
||||||
|
* while {@code 1.0/-0.0} evaluates to <em>negative</em>
|
||||||
|
* infinity and positive infinity and negative infinity are
|
||||||
|
* neither equal to each other nor equivalent to each other.
|
||||||
* </ul>
|
* </ul>
|
||||||
* This definition allows hash tables to operate properly.
|
*
|
||||||
|
* Despite not defining an equivalence relation, the semantics of
|
||||||
|
* the IEEE 754 {@code ==} operator were deliberately designed to
|
||||||
|
* meet other needs of numerical computation.
|
||||||
|
*
|
||||||
|
* By defining an equivalence relation largely consistent with the
|
||||||
|
* {@code ==} operator, this method allows hash tables on {@code
|
||||||
|
* Double} objects to operate properly while reducing surprising
|
||||||
|
* behavior.
|
||||||
|
*
|
||||||
* @param obj the object to compare with.
|
* @param obj the object to compare with.
|
||||||
* @return {@code true} if the objects are the same;
|
* @return {@code true} if the objects are the same;
|
||||||
* {@code false} otherwise.
|
* {@code false} otherwise.
|
||||||
* @see java.lang.Double#doubleToLongBits(double)
|
* @see java.lang.Double#doubleToLongBits(double)
|
||||||
|
* @jls 4.2.3 Floating-Point Types, Formats, and Values
|
||||||
|
* @jls 4.2.4. Floating-Point Operations
|
||||||
|
* @jls 15.21.1 Numerical Equality Operators == and !=
|
||||||
*/
|
*/
|
||||||
public boolean equals(Object obj) {
|
public boolean equals(Object obj) {
|
||||||
return (obj instanceof Double)
|
return (obj instanceof Double)
|
||||||
|
@ -968,19 +1001,29 @@ public final class Double extends Number
|
||||||
public static native double longBitsToDouble(long bits);
|
public static native double longBitsToDouble(long bits);
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Compares two {@code Double} objects numerically. There
|
* Compares two {@code Double} objects numerically.
|
||||||
* are two ways in which comparisons performed by this method
|
|
||||||
* differ from those performed by the Java language numerical
|
* This method imposes a total order on {@code Double} objects
|
||||||
* comparison operators ({@code <, <=, ==, >=, >})
|
* with two differences compared to the incomplete order defined the
|
||||||
* when applied to primitive {@code double} values:
|
* by Java language numerical comparison operators ({@code <, <=,
|
||||||
* <ul><li>
|
* ==, >=, >}) on {@code double} values.
|
||||||
* {@code Double.NaN} is considered by this method
|
|
||||||
* to be equal to itself and greater than all other
|
* There are two ways in which comparisons performed by this
|
||||||
* {@code double} values (including
|
* method differ from those performed by the Java language
|
||||||
* {@code Double.POSITIVE_INFINITY}).
|
* numerical comparison operators when applied to primitive {@code
|
||||||
* <li>
|
* double} values:
|
||||||
* {@code 0.0d} is considered by this method to be greater
|
*
|
||||||
* than {@code -0.0d}.
|
* <ul><li> A NaN is <em>unordered</em> with respect to other
|
||||||
|
* values and unequal to itself under the comparison
|
||||||
|
* operators. This method chooses to define {@code
|
||||||
|
* Double.NaN} to be equal to itself and greater than all
|
||||||
|
* other {@code double} values (including {@code
|
||||||
|
* Double.POSITIVE_INFINITY}).
|
||||||
|
*
|
||||||
|
* <li> Positive zero and negative zero compare equal
|
||||||
|
* numerically, but are distinct and distinguishable values.
|
||||||
|
* This method chooses to define positive zero ({@code
|
||||||
|
* 0.0d}), to be greater than negative zero({@code -0.0d}).
|
||||||
* </ul>
|
* </ul>
|
||||||
* This ensures that the <i>natural ordering</i> of
|
* This ensures that the <i>natural ordering</i> of
|
||||||
* {@code Double} objects imposed by this method is <i>consistent
|
* {@code Double} objects imposed by this method is <i>consistent
|
||||||
|
@ -996,6 +1039,10 @@ public final class Double extends Number
|
||||||
* {@code anotherDouble}.
|
* {@code anotherDouble}.
|
||||||
*
|
*
|
||||||
* @since 1.2
|
* @since 1.2
|
||||||
|
* @jls 4.2.3 Floating-Point Types, Formats, and Values
|
||||||
|
* @jls 4.2.4. Floating-Point Operations
|
||||||
|
* @jls 15.20.1 Numerical Comparison Operators {@code <}, {@code <=}, {@code >}, and {@code >=}
|
||||||
|
* @jls 15.21.1 Numerical Equality Operators == and !=
|
||||||
*/
|
*/
|
||||||
public int compareTo(Double anotherDouble) {
|
public int compareTo(Double anotherDouble) {
|
||||||
return Double.compare(value, anotherDouble.value);
|
return Double.compare(value, anotherDouble.value);
|
||||||
|
|
Loading…
Add table
Add a link
Reference in a new issue