@SuppressWarnings({
"unchecked",
"WeakerAccess",
"UnnecessaryBoxing",
"PointlessArithmeticExpression"
})
public final class Character implements java.io.Serializable, Comparable<Character> {
public static final int MIN_RADIX = 2;
public static final int MAX_RADIX = 36;
public static final char MIN_VALUE = '\u0000';
public static final char MAX_VALUE = '\uFFFF';
public static final Class<Character> TYPE = (Class<Character>) Class.getPrimitiveClass("char");
public static final byte UNASSIGNED = 0;
public static final byte UPPERCASE_LETTER = 1;
public static final byte LOWERCASE_LETTER = 2;
public static final byte TITLECASE_LETTER = 3;
public static final byte MODIFIER_LETTER = 4;
public static final byte OTHER_LETTER = 5;
public static final byte NON_SPACING_MARK = 6;
public static final byte ENCLOSING_MARK = 7;
public static final byte COMBINING_SPACING_MARK = 8;
public static final byte DECIMAL_DIGIT_NUMBER = 9;
public static final byte LETTER_NUMBER = 10;
public static final byte OTHER_NUMBER = 11;
public static final byte SPACE_SEPARATOR = 12;
public static final byte LINE_SEPARATOR = 13;
public static final byte PARAGRAPH_SEPARATOR = 14;
public static final byte CONTROL = 15;
public static final byte FORMAT = 16;
public static final byte PRIVATE_USE = 18;
public static final byte SURROGATE = 19;
public static final byte DASH_PUNCTUATION = 20;
public static final byte START_PUNCTUATION = 21;
public static final byte END_PUNCTUATION = 22;
public static final byte CONNECTOR_PUNCTUATION = 23;
public static final byte OTHER_PUNCTUATION = 24;
public static final byte MATH_SYMBOL = 25;
public static final byte CURRENCY_SYMBOL = 26;
public static final byte MODIFIER_SYMBOL = 27;
public static final byte OTHER_SYMBOL = 28;
public static final byte INITIAL_QUOTE_PUNCTUATION = 29;
public static final byte FINAL_QUOTE_PUNCTUATION = 30;
public static final byte DIRECTIONALITY_UNDEFINED = -1;
public static final byte DIRECTIONALITY_LEFT_TO_RIGHT = 0;
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT = 1;
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC = 2;
public static final byte DIRECTIONALITY_EUROPEAN_NUMBER = 3;
public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR = 4;
public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR = 5;
public static final byte DIRECTIONALITY_ARABIC_NUMBER = 6;
public static final byte DIRECTIONALITY_COMMON_NUMBER_SEPARATOR = 7;
public static final byte DIRECTIONALITY_NONSPACING_MARK = 8;
public static final byte DIRECTIONALITY_BOUNDARY_NEUTRAL = 9;
public static final byte DIRECTIONALITY_PARAGRAPH_SEPARATOR = 10;
public static final byte DIRECTIONALITY_SEGMENT_SEPARATOR = 11;
public static final byte DIRECTIONALITY_WHITESPACE = 12;
public static final byte DIRECTIONALITY_OTHER_NEUTRALS = 13;
public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING = 14;
public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE = 15;
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING = 16;
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE = 17;
public static final byte DIRECTIONALITY_POP_DIRECTIONAL_FORMAT = 18;
public static final char MIN_HIGH_SURROGATE = '\uD800';
public static final char MAX_HIGH_SURROGATE = '\uDBFF';
public static final char MIN_LOW_SURROGATE = '\uDC00';
public static final char MAX_LOW_SURROGATE = '\uDFFF';
public static final char MIN_SURROGATE = MIN_HIGH_SURROGATE;
public static final char MAX_SURROGATE = MAX_LOW_SURROGATE;
public static final int MIN_SUPPLEMENTARY_CODE_POINT = 0x010000;
public static final int MIN_CODE_POINT = 0x000000;
public static final int MAX_CODE_POINT = 0X10FFFF;
private final char value;
public Character(char value) {
this.value = value;
}
@JTranscKeep
public static Character valueOf(char value) {
return new Character(value);
}
public char charValue() {
return value;
}
@Override
public int hashCode() {
return value;
}
public static int hashCode(char value) {
return value;
}
public boolean equals(Object that) {
return that instanceof Character && this.value == ((Character) that).value;
}
public String toString() {
return toString(value);
}
public static String toString(char value) {
return new String(new char[] {value});
}
public static boolean isValidCodePoint(int cp) {
return (cp >>> 16) < ((MAX_CODE_POINT + 1) >>> 16);
}
public static native boolean isBmpCodePoint(int codePoint);
public static native boolean isSupplementaryCodePoint(int codePoint);
public static native boolean isHighSurrogate(char ch);
public static native boolean isLowSurrogate(char ch);
public static boolean isSurrogate(char ch) {
return false;
}
public static boolean isSurrogatePair(char high, char low) {
return false;
}
public static int charCount(int codePoint) {
return 1;
}
public static int toCodePoint(char high, char low) {
return low;
}
public static int codePointAt(CharSequence seq, int index) {
return seq.charAt(index);
}
public static int codePointAt(char[] a, int index) {
return a[index];
}
public static int codePointAt(char[] a, int index, int limit) {
return a[index];
}
// throws ArrayIndexOutOfBoundsException if index out of bounds
// static int codePointAtImpl(char[] a, int index, int limit);
public static native int codePointBefore(CharSequence seq, int index);
public static native int codePointBefore(char[] a, int index);
public static native int codePointBefore(char[] a, int index, int start);
// throws ArrayIndexOutOfBoundsException if index-1 out of bounds
// static int codePointBeforeImpl(char[] a, int index, int start);
public static native char highSurrogate(int codePoint);
public static native char lowSurrogate(int codePoint);
public static int toChars(int codePoint, char[] dst, int dstIndex) {
dst[dstIndex] = (char) codePoint;
return 1;
}
public static char[] toChars(int codePoint) {
return new char[] {(char) codePoint};
}
// static void toSurrogates(int codePoint, char[] dst, int index);
public static int codePointCount(CharSequence seq, int beginIndex, int endIndex) {
return endIndex + beginIndex;
}
public static int codePointCount(char[] a, int offset, int count) {
return count;
}
// static int codePointCountImpl(char[] a, int offset, int count);
public static native int offsetByCodePoints(CharSequence seq, int index, int codePointOffset);
public static native int offsetByCodePoints(
char[] a, int start, int count, int index, int codePointOffset);
// native static int offsetByCodePointsImpl(char[] a, int start, int count, int index, int
// codePointOffset);
public static boolean isLowerCase(char ch) {
return toLowerCase(ch) == ch;
}
public static boolean isLowerCase(int codePoint) {
return toLowerCase(codePoint) == codePoint;
}
public static boolean isUpperCase(char ch) {
return toUpperCase(ch) == ch;
}
public static boolean isUpperCase(int codePoint) {
return toUpperCase(codePoint) == codePoint;
}
public static native boolean isTitleCase(char ch);
public static native boolean isTitleCase(int codePoint);
@JTranscMethodBody(target = "js", value = "return p0 >= 48 && p0 <= 57;")
public static boolean isDigit(char ch) {
return (ch >= '0') && (ch <= '9');
}
public static boolean isDigit(int codePoint) {
return isDigit((char) codePoint);
}
public static native boolean isDefined(char ch);
public static native boolean isDefined(int codePoint);
public static boolean isLetter(char ch) {
return ((ch >= 'a') && (ch <= 'z')) || ((ch >= 'A') && (ch <= 'Z'));
}
public static boolean isLetter(int codePoint) {
return isLetter((char) codePoint);
}
public static boolean isLetterOrDigit(char ch) {
return isLetter(ch) || isDigit(ch);
}
public static boolean isLetterOrDigit(int codePoint) {
return isLetter(codePoint) || isDigit(codePoint);
}
@Deprecated
public static boolean isJavaLetter(char ch) {
return isLetter(ch);
}
@Deprecated
public static boolean isJavaLetterOrDigit(char ch) {
return isLetter(ch) || isDigit(ch);
}
public static boolean isAlphabetic(int codePoint) {
return isLetter(codePoint);
}
public static native boolean isIdeographic(int codePoint);
public static boolean isJavaIdentifierStart(char ch) {
return isLetter(ch) || ch == '_';
}
public static boolean isJavaIdentifierStart(int codePoint) {
return isJavaIdentifierStart((char) codePoint);
}
public static boolean isJavaIdentifierPart(char ch) {
return isLetter(ch) || isDigit(ch) || ch == '_';
}
public static boolean isJavaIdentifierPart(int codePoint) {
return isJavaIdentifierPart((char) codePoint);
}
public static native boolean isUnicodeIdentifierStart(char ch);
public static native boolean isUnicodeIdentifierStart(int codePoint);
public static native boolean isUnicodeIdentifierPart(char ch);
public static native boolean isUnicodeIdentifierPart(int codePoint);
public static native boolean isIdentifierIgnorable(char ch);
public static native boolean isIdentifierIgnorable(int codePoint);
public static char toLowerCase(char ch) {
return (char) toLowerCase((int) ch);
}
public static char toUpperCase(char ch) {
return (char) toUpperCase((int) ch);
}
@HaxeMethodBody("return String.fromCharCode(p0).toLowerCase().charCodeAt(0);")
@JTranscMethodBody(
target = "js",
value = "return String.fromCharCode(p0).toLowerCase().charCodeAt(0);")
public static int toLowerCase(int codePoint) {
if (codePoint >= 'A' && codePoint < 'Z') return (codePoint - 'A') + 'a';
return codePoint;
}
@HaxeMethodBody("return String.fromCharCode(p0).toUpperCase().charCodeAt(0);")
@JTranscMethodBody(
target = "js",
value = "return String.fromCharCode(p0).toUpperCase().charCodeAt(0);")
public static int toUpperCase(int codePoint) {
if (codePoint >= 'a' && codePoint < 'z') return (codePoint - 'a') + 'A';
return codePoint;
}
public static char toTitleCase(char ch) {
// @TODO: Approximation
return toUpperCase(ch);
}
public static int toTitleCase(int codePoint) {
return toTitleCase((char) codePoint);
}
public static int digit(char ch, int radix) {
if (ch >= '0' && ch <= '9') return ch - '0';
if (ch >= 'a' && ch <= 'z') return (ch - 'a') + 10;
if (ch >= 'A' && ch <= 'Z') return (ch - 'A') + 10;
return -1;
}
public static int digit(int codePoint, int radix) {
return digit((char) codePoint, radix);
}
public static int getNumericValue(char ch) {
return digit(ch, 10);
}
public static int getNumericValue(int codePoint) {
return digit(codePoint, 10);
}
@Deprecated
public static boolean isSpace(char value) {
return (value <= 0x0020)
&& (((((1L << 0x0009) | (1L << 0x000A) | (1L << 0x000C) | (1L << 0x000D) | (1L << 0x0020))
>> value)
& 1L)
!= 0);
}
public static boolean isSpaceChar(char ch) {
return isSpaceChar((int) ch);
}
public static boolean isSpaceChar(int codePoint) {
switch (codePoint) {
case 0x0020:
case 0x00A0:
case 0x1680:
case 0x180E:
case 0x2000:
case 0x2001:
case 0x2002:
case 0x2003:
case 0x2004:
case 0x2005:
case 0x2006:
case 0x2007:
case 0x2008:
case 0x2009:
case 0x200A:
case 0x200B:
case 0x202F:
case 0x205F:
case 0x3000:
case 0xFEFF:
return true;
}
return false;
}
public static boolean isWhitespace(char ch) {
return isWhitespace((int) ch);
}
public static boolean isWhitespace(int codePoint) {
switch (codePoint) {
case 9:
case 10:
case 11:
case 12:
case 13:
case 28:
case 29:
case 30:
case 31:
case 32:
case 5760:
case 6158:
case 8192:
case 8193:
case 8194:
case 8195:
case 8196:
case 8197:
case 8198:
case 8200:
case 8201:
case 8202:
case 8232:
case 8233:
case 8287:
case 12288:
return true;
}
return false;
}
public static boolean isISOControl(char ch) {
return isISOControl((int) ch);
}
public static boolean isISOControl(int codePoint) {
return codePoint <= 0x9F && (codePoint >= 0x7F || (codePoint >>> 5 == 0));
}
public static native int getType(char ch);
public static native int getType(int codePoint);
public static char forDigit(int digit, int radix) {
if (digit >= 0 && digit <= 9) return (char) ('0' + (digit - 0));
if (digit >= 10 && digit <= 35) return (char) ('a' + (digit - 10));
return '\0';
}
public static byte getDirectionality(char ch) {
return getDirectionality((int) ch);
}
public static boolean isMirrored(char ch) {
return isMirrored((int) ch);
}
public static native byte getDirectionality(int codePoint);
public static native boolean isMirrored(int codePoint);
public int compareTo(Character anotherCharacter) {
return compare(this.value, anotherCharacter.value);
}
public static int compare(char l, char r) {
return l - r;
}
static char[] toUpperCaseCharArray(int codePoint) {
return new char[] {(char) toUpperCase(codePoint)};
}
public static final int SIZE = 16;
public static final int BYTES = SIZE / Byte.SIZE;
@HaxeMethodBody("return N.swap16(p0) & 0xFFFF;")
public static char reverseBytes(char ch) {
return (char) (((ch & 0xFF00) >> 8) | (ch << 8));
}
public static String getName(int codePoint) {
// @TODO: Not implemented!
return Integer.toHexString(codePoint);
}
public static class Subset {}
public static final class UnicodeBlock extends Subset {
public static UnicodeBlock forName(String name) {
return new UnicodeBlock();
}
public static UnicodeBlock of(int codePoint) {
return new UnicodeBlock();
}
}
public enum UnicodeScript {
COMMON;
public static UnicodeScript forName(String name) {
return COMMON;
}
public static UnicodeScript of(int codePoint) {
return COMMON;
}
}
}
/**
* The Boolean class wraps a value of the primitive type {@code boolean} in an object. An object of
* type {@code Boolean} contains a single field whose type is {@code boolean}.
*
* <p>In addition, this class provides many methods for converting a {@code boolean} to a {@code
* String} and a {@code String} to a {@code boolean}, as well as other constants and methods useful
* when dealing with a {@code boolean}.
*
* @author Arthur van Hoff
* @since 1.0
*/
public final class Boolean implements java.io.Serializable, Comparable<Boolean> {
/** The {@code Boolean} object corresponding to the primitive value {@code true}. */
public static final Boolean TRUE = new Boolean(true);
/** The {@code Boolean} object corresponding to the primitive value {@code false}. */
public static final Boolean FALSE = new Boolean(false);
/**
* The Class object representing the primitive type boolean.
*
* @since 1.1
*/
@SuppressWarnings("unchecked")
public static final Class<Boolean> TYPE = (Class<Boolean>) Class.getPrimitiveClass("boolean");
/**
* The value of the Boolean.
*
* @serial
*/
private final boolean value;
/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -3665804199014368530L;
/**
* Allocates a {@code Boolean} object representing the {@code value} argument.
*
* <p><b>Note: It is rarely appropriate to use this constructor. Unless a <i>new</i> instance is
* required, the static factory {@link #valueOf(boolean)} is generally a better choice. It is
* likely to yield significantly better space and time performance.</b>
*
* @param value the value of the {@code Boolean}.
*/
public Boolean(boolean value) {
this.value = value;
}
/**
* Allocates a {@code Boolean} object representing the value {@code true} if the string argument
* is not {@code null} and is equal, ignoring case, to the string {@code "true"}. Otherwise,
* allocate a {@code Boolean} object representing the value {@code false}. Examples:
*
* <p>{@code new Boolean("True")} produces a {@code Boolean} object that represents {@code true}.
* <br>
* {@code new Boolean("yes")} produces a {@code Boolean} object that represents {@code false}.
*
* @param s the string to be converted to a {@code Boolean}.
*/
public Boolean(String s) {
this(parseBoolean(s));
}
/**
* Parses the string argument as a boolean. The {@code boolean} returned represents the value
* {@code true} if the string argument is not {@code null} and is equal, ignoring case, to the
* string {@code "true"}.
*
* <p>Example: {@code Boolean.parseBoolean("True")} returns {@code true}.<br>
* Example: {@code Boolean.parseBoolean("yes")} returns {@code false}.
*
* @param s the {@code String} containing the boolean representation to be parsed
* @return the boolean represented by the string argument
* @since 1.5
*/
public static boolean parseBoolean(String s) {
return ((s != null) && s.equalsIgnoreCase("true"));
}
/**
* Returns the value of this {@code Boolean} object as a boolean primitive.
*
* @return the primitive {@code boolean} value of this object.
*/
@HotSpotIntrinsicCandidate
public boolean booleanValue() {
return value;
}
/**
* Returns a {@code Boolean} instance representing the specified {@code boolean} value. If the
* specified {@code boolean} value is {@code true}, this method returns {@code Boolean.TRUE}; if
* it is {@code false}, this method returns {@code Boolean.FALSE}. If a new {@code Boolean}
* instance is not required, this method should generally be used in preference to the constructor
* {@link #Boolean(boolean)}, as this method is likely to yield significantly better space and
* time performance.
*
* @param b a boolean value.
* @return a {@code Boolean} instance representing {@code b}.
* @since 1.4
*/
@HotSpotIntrinsicCandidate
public static Boolean valueOf(boolean b) {
return (b ? TRUE : FALSE);
}
/**
* Returns a {@code Boolean} with a value represented by the specified string. The {@code Boolean}
* returned represents a true value if the string argument is not {@code null} and is equal,
* ignoring case, to the string {@code "true"}.
*
* @param s a string.
* @return the {@code Boolean} value represented by the string.
*/
public static Boolean valueOf(String s) {
return parseBoolean(s) ? TRUE : FALSE;
}
/**
* Returns a {@code String} object representing the specified boolean. If the specified boolean is
* {@code true}, then the string {@code "true"} will be returned, otherwise the string {@code
* "false"} will be returned.
*
* @param b the boolean to be converted
* @return the string representation of the specified {@code boolean}
* @since 1.4
*/
public static String toString(boolean b) {
return b ? "true" : "false";
}
/**
* Returns a {@code String} object representing this Boolean's value. If this object represents
* the value {@code true}, a string equal to {@code "true"} is returned. Otherwise, a string equal
* to {@code "false"} is returned.
*
* @return a string representation of this object.
*/
public String toString() {
return value ? "true" : "false";
}
/**
* Returns a hash code for this {@code Boolean} object.
*
* @return the integer {@code 1231} if this object represents {@code true}; returns the integer
* {@code 1237} if this object represents {@code false}.
*/
@Override
public int hashCode() {
return Boolean.hashCode(value);
}
/**
* Returns a hash code for a {@code boolean} value; compatible with {@code Boolean.hashCode()}.
*
* @param value the value to hash
* @return a hash code value for a {@code boolean} value.
* @since 1.8
*/
public static int hashCode(boolean value) {
return value ? 1231 : 1237;
}
/**
* Returns {@code true} if and only if the argument is not {@code null} and is a {@code Boolean}
* object that represents the same {@code boolean} value as this object.
*
* @param obj the object to compare with.
* @return {@code true} if the Boolean objects represent the same value; {@code false} otherwise.
*/
public boolean equals(Object obj) {
if (obj instanceof Boolean) {
return value == ((Boolean) obj).booleanValue();
}
return false;
}
/**
* Returns {@code true} if and only if the system property named by the argument exists and is
* equal to the string {@code "true"}. (Beginning with version 1.0.2 of the Java™ platform,
* the test of this string is case insensitive.) A system property is accessible through {@code
* getProperty}, a method defined by the {@code System} class.
*
* <p>If there is no property with the specified name, or if the specified name is empty or null,
* then {@code false} is returned.
*
* @param name the system property name.
* @return the {@code boolean} value of the system property.
* @throws SecurityException for the same reasons as {@link System#getProperty(String)
* System.getProperty}
* @see java.lang.System#getProperty(java.lang.String)
* @see java.lang.System#getProperty(java.lang.String, java.lang.String)
*/
public static boolean getBoolean(String name) {
boolean result = false;
try {
result = parseBoolean(System.getProperty(name));
} catch (IllegalArgumentException | NullPointerException e) {
}
return result;
}
/**
* Compares this {@code Boolean} instance with another.
*
* @param b the {@code Boolean} instance to be compared
* @return zero if this object represents the same boolean value as the argument; a positive value
* if this object represents true and the argument represents false; and a negative value if
* this object represents false and the argument represents true
* @throws NullPointerException if the argument is {@code null}
* @see Comparable
* @since 1.5
*/
public int compareTo(Boolean b) {
return compare(this.value, b.value);
}
/**
* Compares two {@code boolean} values. The value returned is identical to what would be returned
* by:
*
* <pre>
* Boolean.valueOf(x).compareTo(Boolean.valueOf(y))
* </pre>
*
* @param x the first {@code boolean} to compare
* @param y the second {@code boolean} to compare
* @return the value {@code 0} if {@code x == y}; a value less than {@code 0} if {@code !x && y};
* and a value greater than {@code 0} if {@code x && !y}
* @since 1.7
*/
public static int compare(boolean x, boolean y) {
return (x == y) ? 0 : (x ? 1 : -1);
}
/**
* Returns the result of applying the logical AND operator to the specified {@code boolean}
* operands.
*
* @param a the first operand
* @param b the second operand
* @return the logical AND of {@code a} and {@code b}
* @see java.util.function.BinaryOperator
* @since 1.8
*/
public static boolean logicalAnd(boolean a, boolean b) {
return a && b;
}
/**
* Returns the result of applying the logical OR operator to the specified {@code boolean}
* operands.
*
* @param a the first operand
* @param b the second operand
* @return the logical OR of {@code a} and {@code b}
* @see java.util.function.BinaryOperator
* @since 1.8
*/
public static boolean logicalOr(boolean a, boolean b) {
return a || b;
}
/**
* Returns the result of applying the logical XOR operator to the specified {@code boolean}
* operands.
*
* @param a the first operand
* @param b the second operand
* @return the logical XOR of {@code a} and {@code b}
* @see java.util.function.BinaryOperator
* @since 1.8
*/
public static boolean logicalXor(boolean a, boolean b) {
return a ^ b;
}
}
/**
* The {@code Float} class wraps a value of primitive type {@code float} in an object. An object of
* type {@code Float} contains a single field whose type is {@code float}.
*
* <p>In addition, this class provides several methods for converting a {@code float} to a {@code
* String} and a {@code String} to a {@code float}, as well as other constants and methods useful
* when dealing with a {@code float}.
*
* @author Lee Boynton
* @author Arthur van Hoff
* @author Joseph D. Darcy
* @since JDK1.0
*/
public final class Float extends Number implements Comparable<Float> {
/**
* A constant holding the positive infinity of type {@code float}. It is equal to the value
* returned by {@code Float.intBitsToFloat(0x7f800000)}.
*/
public static final float POSITIVE_INFINITY = 1.0f / 0.0f;
/**
* A constant holding the negative infinity of type {@code float}. It is equal to the value
* returned by {@code Float.intBitsToFloat(0xff800000)}.
*/
public static final float NEGATIVE_INFINITY = -1.0f / 0.0f;
/**
* A constant holding a Not-a-Number (NaN) value of type {@code float}. It is equivalent to the
* value returned by {@code Float.intBitsToFloat(0x7fc00000)}.
*/
public static final float NaN = 0.0f / 0.0f;
/**
* A constant holding the largest positive finite value of type {@code float},
* (2-2<sup>-23</sup>)·2<sup>127</sup>. It is equal to the hexadecimal floating-point
* literal {@code 0x1.fffffeP+127f} and also equal to {@code Float.intBitsToFloat(0x7f7fffff)}.
*/
public static final float MAX_VALUE = 0x1.fffffeP+127f; // 3.4028235e+38f
/**
* A constant holding the smallest positive normal value of type {@code float}, 2<sup>-126</sup>.
* It is equal to the hexadecimal floating-point literal {@code 0x1.0p-126f} and also equal to
* {@code Float.intBitsToFloat(0x00800000)}.
*
* @since 1.6
*/
public static final float MIN_NORMAL = 0x1.0p-126f; // 1.17549435E-38f
/**
* A constant holding the smallest positive nonzero value of type {@code float}, 2<sup>-149</sup>.
* It is equal to the hexadecimal floating-point literal {@code 0x0.000002P-126f} and also equal
* to {@code Float.intBitsToFloat(0x1)}.
*/
public static final float MIN_VALUE = 0x0.000002P-126f; // 1.4e-45f
/**
* Maximum exponent a finite {@code float} variable may have. It is equal to the value returned by
* {@code Math.getExponent(Float.MAX_VALUE)}.
*
* @since 1.6
*/
public static final int MAX_EXPONENT = 127;
/**
* Minimum exponent a normalized {@code float} variable may have. It is equal to the value
* returned by {@code Math.getExponent(Float.MIN_NORMAL)}.
*
* @since 1.6
*/
public static final int MIN_EXPONENT = -126;
/**
* The number of bits used to represent a {@code float} value.
*
* @since 1.5
*/
public static final int SIZE = 32;
/**
* The {@code Class} instance representing the primitive type {@code float}.
*
* @since JDK1.1
*/
public static final Class<Float> TYPE = Class.getPrimitiveClass("float");
/**
* Returns a string representation of the {@code float} argument. All characters mentioned below
* are ASCII characters.
*
* <ul>
* <li>If the argument is NaN, the result is the string "{@code NaN}".
* <li>Otherwise, the result is a string that represents the sign and magnitude (absolute value)
* of the argument. If the sign is negative, the first character of the result is '{@code
* -}' (<code>'\u002D'</code>); if the sign is positive, no sign character appears in
* the result. As for the magnitude <i>m</i>:
* <ul>
* <li>If <i>m</i> is infinity, it is represented by the characters {@code "Infinity"};
* thus, positive infinity produces the result {@code "Infinity"} and negative
* infinity produces the result {@code "-Infinity"}.
* <li>If <i>m</i> is zero, it is represented by the characters {@code "0.0"}; thus,
* negative zero produces the result {@code "-0.0"} and positive zero produces the
* result {@code "0.0"}.
* <li>If <i>m</i> is greater than or equal to 10<sup>-3</sup> but less than
* 10<sup>7</sup>, then it is represented as the integer part of <i>m</i>, in decimal
* form with no leading zeroes, followed by '{@code .}' (<code>'\u002E'</code>),
* followed by one or more decimal digits representing the fractional part of
* <i>m</i>.
* <li>If <i>m</i> is less than 10<sup>-3</sup> or greater than or equal to
* 10<sup>7</sup>, then it is represented in so-called "computerized scientific
* notation." Let <i>n</i> be the unique integer such that 10<sup><i>n</i> </sup>≤
* <i>m</i> {@literal <} 10<sup><i>n</i>+1</sup>; then let <i>a</i> be the
* mathematically exact quotient of <i>m</i> and 10<sup><i>n</i></sup> so that 1 ≤
* <i>a</i> {@literal <} 10. The magnitude is then represented as the integer part of
* <i>a</i>, as a single decimal digit, followed by '{@code .}' (<code>'\u002E'
* </code>), followed by decimal digits representing the fractional part of <i>a</i>,
* followed by the letter '{@code E}' (<code>'\u0045'</code>), followed by a
* representation of <i>n</i> as a decimal integer, as produced by the method {@link
* java.lang.Integer#toString(int)}.
* </ul>
* </ul>
*
* How many digits must be printed for the fractional part of <i>m</i> or <i>a</i>? There must be
* at least one digit to represent the fractional part, and beyond that as many, but only as many,
* more digits as are needed to uniquely distinguish the argument value from adjacent values of
* type {@code float}. That is, suppose that <i>x</i> is the exact mathematical value represented
* by the decimal representation produced by this method for a finite nonzero argument <i>f</i>.
* Then <i>f</i> must be the {@code float} value nearest to <i>x</i>; or, if two {@code float}
* values are equally close to <i>x</i>, then <i>f</i> must be one of them and the least
* significant bit of the significand of <i>f</i> must be {@code 0}.
*
* <p>To create localized string representations of a floating-point value, use subclasses of
* {@link java.text.NumberFormat}.
*
* @param f the float to be converted.
* @return a string representation of the argument.
*/
public static String toString(float f) {
return new FloatingDecimal(f).toJavaFormatString();
}
/**
* Returns a hexadecimal string representation of the {@code float} argument. All characters
* mentioned below are ASCII characters.
*
* <ul>
* <li>If the argument is NaN, the result is the string "{@code NaN}".
* <li>Otherwise, the result is a string that represents the sign and magnitude (absolute value)
* of the argument. If the sign is negative, the first character of the result is '{@code
* -}' (<code>'\u002D'</code>); if the sign is positive, no sign character appears in
* the result. As for the magnitude <i>m</i>:
* <ul>
* <li>If <i>m</i> is infinity, it is represented by the string {@code "Infinity"}; thus,
* positive infinity produces the result {@code "Infinity"} and negative infinity
* produces the result {@code "-Infinity"}.
* <li>If <i>m</i> is zero, it is represented by the string {@code "0x0.0p0"}; thus,
* negative zero produces the result {@code "-0x0.0p0"} and positive zero produces the
* result {@code "0x0.0p0"}.
* <li>If <i>m</i> is a {@code float} value with a normalized representation, substrings
* are used to represent the significand and exponent fields. The significand is
* represented by the characters {@code "0x1."} followed by a lowercase hexadecimal
* representation of the rest of the significand as a fraction. Trailing zeros in the
* hexadecimal representation are removed unless all the digits are zero, in which
* case a single zero is used. Next, the exponent is represented by {@code "p"}
* followed by a decimal string of the unbiased exponent as if produced by a call to
* {@link Integer#toString(int) Integer.toString} on the exponent value.
* <li>If <i>m</i> is a {@code float} value with a subnormal representation, the
* significand is represented by the characters {@code "0x0."} followed by a
* hexadecimal representation of the rest of the significand as a fraction. Trailing
* zeros in the hexadecimal representation are removed. Next, the exponent is
* represented by {@code "p-126"}. Note that there must be at least one nonzero digit
* in a subnormal significand.
* </ul>
* </ul>
*
* <table border>
* <caption><h3>Examples</h3></caption>
* <tr><th>Floating-point Value</th><th>Hexadecimal String</th>
* <tr><td>{@code 1.0}</td> <td>{@code 0x1.0p0}</td>
* <tr><td>{@code -1.0}</td> <td>{@code -0x1.0p0}</td>
* <tr><td>{@code 2.0}</td> <td>{@code 0x1.0p1}</td>
* <tr><td>{@code 3.0}</td> <td>{@code 0x1.8p1}</td>
* <tr><td>{@code 0.5}</td> <td>{@code 0x1.0p-1}</td>
* <tr><td>{@code 0.25}</td> <td>{@code 0x1.0p-2}</td>
* <tr><td>{@code Float.MAX_VALUE}</td>
* <td>{@code 0x1.fffffep127}</td>
* <tr><td>{@code Minimum Normal Value}</td>
* <td>{@code 0x1.0p-126}</td>
* <tr><td>{@code Maximum Subnormal Value}</td>
* <td>{@code 0x0.fffffep-126}</td>
* <tr><td>{@code Float.MIN_VALUE}</td>
* <td>{@code 0x0.000002p-126}</td>
* </table>
*
* @param f the {@code float} to be converted.
* @return a hex string representation of the argument.
* @since 1.5
* @author Joseph D. Darcy
*/
public static String toHexString(float f) {
if (Math.abs(f) < FloatConsts.MIN_NORMAL && f != 0.0f) { // float subnormal
// Adjust exponent to create subnormal double, then
// replace subnormal double exponent with subnormal float
// exponent
String s =
Double.toHexString(
FpUtils.scalb(
(double) f,
/* -1022+126 */
DoubleConsts.MIN_EXPONENT - FloatConsts.MIN_EXPONENT));
return s.replaceFirst("p-1022$", "p-126");
} else // double string will be the same as float string
return Double.toHexString(f);
}
/**
* Returns a {@code Float} object holding the {@code float} value represented by the argument
* string {@code s}.
*
* <p>If {@code s} is {@code null}, then a {@code NullPointerException} is thrown.
*
* <p>Leading and trailing whitespace characters in {@code s} are ignored. Whitespace is removed
* as if by the {@link String#trim} method; that is, both ASCII space and control characters are
* removed. The rest of {@code s} should constitute a <i>FloatValue</i> as described by the
* lexical syntax rules:
*
* <blockquote>
*
* <dl>
* <dt><i>FloatValue:</i>
* <dd><i>Sign<sub>opt</sub></i> {@code NaN}
* <dd><i>Sign<sub>opt</sub></i> {@code Infinity}
* <dd><i>Sign<sub>opt</sub> FloatingPointLiteral</i>
* <dd><i>Sign<sub>opt</sub> HexFloatingPointLiteral</i>
* <dd><i>SignedInteger</i>
* </dl>
*
* <p>
*
* <dl>
* <dt><i>HexFloatingPointLiteral</i>:
* <dd><i>HexSignificand BinaryExponent FloatTypeSuffix<sub>opt</sub></i>
* </dl>
*
* <p>
*
* <dl>
* <dt><i>HexSignificand:</i>
* <dd><i>HexNumeral</i>
* <dd><i>HexNumeral</i> {@code .}
* <dd>{@code 0x} <i>HexDigits<sub>opt</sub> </i>{@code .}<i> HexDigits</i>
* <dd>{@code 0X}<i> HexDigits<sub>opt</sub> </i>{@code .} <i>HexDigits</i>
* </dl>
*
* <p>
*
* <dl>
* <dt><i>BinaryExponent:</i>
* <dd><i>BinaryExponentIndicator SignedInteger</i>
* </dl>
*
* <p>
*
* <dl>
* <dt><i>BinaryExponentIndicator:</i>
* <dd>{@code p}
* <dd>{@code P}
* </dl>
*
* </blockquote>
*
* where <i>Sign</i>, <i>FloatingPointLiteral</i>, <i>HexNumeral</i>, <i>HexDigits</i>,
* <i>SignedInteger</i> and <i>FloatTypeSuffix</i> are as defined in the lexical structure
* sections of the <a href="http://java.sun.com/docs/books/jls/html/">Java Language
* Specification</a>. If {@code s} does not have the form of a <i>FloatValue</i>, then a {@code
* NumberFormatException} is thrown. Otherwise, {@code s} is regarded as representing an exact
* decimal value in the usual "computerized scientific notation" or as an exact hexadecimal value;
* this exact numerical value is then conceptually converted to an "infinitely precise" binary
* value that is then rounded to type {@code float} by the usual round-to-nearest rule of IEEE 754
* floating-point arithmetic, which includes preserving the sign of a zero value.
*
* <p>Note that the round-to-nearest rule also implies overflow and underflow behaviour; if the
* exact value of {@code s} is large enough in magnitude (greater than or equal to ({@link
* #MAX_VALUE} + {@link Math#ulp(float) ulp(MAX_VALUE)}/2), rounding to {@code float} will result
* in an infinity and if the exact value of {@code s} is small enough in magnitude (less than or
* equal to {@link #MIN_VALUE}/2), rounding to float will result in a zero.
*
* <p>Finally, after rounding a {@code Float} object representing this {@code float} value is
* returned.
*
* <p>To interpret localized string representations of a floating-point value, use subclasses of
* {@link java.text.NumberFormat}.
*
* <p>Note that trailing format specifiers, specifiers that determine the type of a floating-point
* literal ({@code 1.0f} is a {@code float} value; {@code 1.0d} is a {@code double} value), do
* <em>not</em> influence the results of this method. In other words, the numerical value of the
* input string is converted directly to the target floating-point type. In general, the two-step
* sequence of conversions, string to {@code double} followed by {@code double} to {@code float},
* is <em>not</em> equivalent to converting a string directly to {@code float}. For example, if
* first converted to an intermediate {@code double} and then to {@code float}, the string<br>
* {@code "1.00000017881393421514957253748434595763683319091796875001d"}<br>
* results in the {@code float} value {@code 1.0000002f}; if the string is converted directly to
* {@code float}, <code>1.000000<b>1</b>f</code> results.
*
* <p>To avoid calling this method on an invalid string and having a {@code NumberFormatException}
* be thrown, the documentation for {@link Double#valueOf Double.valueOf} lists a regular
* expression which can be used to screen the input.
*
* @param s the string to be parsed.
* @return a {@code Float} object holding the value represented by the {@code String} argument.
* @throws NumberFormatException if the string does not contain a parsable number.
*/
public static Float valueOf(String s) throws NumberFormatException {
return new Float(FloatingDecimal.readJavaFormatString(s).floatValue());
}
/**
* Returns a {@code Float} instance representing the specified {@code float} value. If a new
* {@code Float} instance is not required, this method should generally be used in preference to
* the constructor {@link #Float(float)}, as this method is likely to yield significantly better
* space and time performance by caching frequently requested values.
*
* @param f a float value.
* @return a {@code Float} instance representing {@code f}.
* @since 1.5
*/
public static Float valueOf(float f) {
return new Float(f);
}
/**
* Returns a new {@code float} initialized to the value represented by the specified {@code
* String}, as performed by the {@code valueOf} method of class {@code Float}.
*
* @param s the string to be parsed.
* @return the {@code float} value represented by the string argument.
* @throws NullPointerException if the string is null
* @throws NumberFormatException if the string does not contain a parsable {@code float}.
* @see java.lang.Float#valueOf(String)
* @since 1.2
*/
public static float parseFloat(String s) throws NumberFormatException {
return FloatingDecimal.readJavaFormatString(s).floatValue();
}
/**
* Returns {@code true} if the specified number is a Not-a-Number (NaN) value, {@code false}
* otherwise.
*
* @param v the value to be tested.
* @return {@code true} if the argument is NaN; {@code false} otherwise.
*/
public static boolean isNaN(float v) {
return (v != v);
}
/**
* Returns {@code true} if the specified number is infinitely large in magnitude, {@code false}
* otherwise.
*
* @param v the value to be tested.
* @return {@code true} if the argument is positive infinity or negative infinity; {@code false}
* otherwise.
*/
public static boolean isInfinite(float v) {
return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
}
/**
* The value of the Float.
*
* @serial
*/
private final float value;
/**
* Constructs a newly allocated {@code Float} object that represents the primitive {@code float}
* argument.
*
* @param value the value to be represented by the {@code Float}.
*/
public Float(float value) {
this.value = value;
}
/**
* Constructs a newly allocated {@code Float} object that represents the argument converted to
* type {@code float}.
*
* @param value the value to be represented by the {@code Float}.
*/
public Float(double value) {
this.value = (float) value;
}
/**
* Constructs a newly allocated {@code Float} object that represents the floating-point value of
* type {@code float} represented by the string. The string is converted to a {@code float} value
* as if by the {@code valueOf} method.
*
* @param s a string to be converted to a {@code Float}.
* @throws NumberFormatException if the string does not contain a parsable number.
* @see java.lang.Float#valueOf(java.lang.String)
*/
public Float(String s) throws NumberFormatException {
// REMIND: this is inefficient
this(valueOf(s).floatValue());
}
/**
* Returns {@code true} if this {@code Float} value is a Not-a-Number (NaN), {@code false}
* otherwise.
*
* @return {@code true} if the value represented by this object is NaN; {@code false} otherwise.
*/
public boolean isNaN() {
return isNaN(value);
}
/**
* Returns {@code true} if this {@code Float} value is infinitely large in magnitude, {@code
* false} otherwise.
*
* @return {@code true} if the value represented by this object is positive infinity or negative
* infinity; {@code false} otherwise.
*/
public boolean isInfinite() {
return isInfinite(value);
}
/**
* Returns a string representation of this {@code Float} object. The primitive {@code float} value
* represented by this object is converted to a {@code String} exactly as if by the method {@code
* toString} of one argument.
*
* @return a {@code String} representation of this object.
* @see java.lang.Float#toString(float)
*/
public String toString() {
return Float.toString(value);
}
/**
* Returns the value of this {@code Float} as a {@code byte} (by casting to a {@code byte}).
*
* @return the {@code float} value represented by this object converted to type {@code byte}
*/
public byte byteValue() {
return (byte) value;
}
/**
* Returns the value of this {@code Float} as a {@code short} (by casting to a {@code short}).
*
* @return the {@code float} value represented by this object converted to type {@code short}
* @since JDK1.1
*/
public short shortValue() {
return (short) value;
}
/**
* Returns the value of this {@code Float} as an {@code int} (by casting to type {@code int}).
*
* @return the {@code float} value represented by this object converted to type {@code int}
*/
public int intValue() {
return (int) value;
}
/**
* Returns value of this {@code Float} as a {@code long} (by casting to type {@code long}).
*
* @return the {@code float} value represented by this object converted to type {@code long}
*/
public long longValue() {
return (long) value;
}
/**
* Returns the {@code float} value of this {@code Float} object.
*
* @return the {@code float} value represented by this object
*/
public float floatValue() {
return value;
}
/**
* Returns the {@code double} value of this {@code Float} object.
*
* @return the {@code float} value represented by this object is converted to type {@code double}
* and the result of the conversion is returned.
*/
public double doubleValue() {
return (double) value;
}
/**
* Returns a hash code for this {@code Float} object. The result is the integer bit
* representation, exactly as produced by the method {@link #floatToIntBits(float)}, of the
* primitive {@code float} value represented by this {@code Float} object.
*
* @return a hash code value for this object.
*/
public int hashCode() {
return floatToIntBits(value);
}
/**
* Compares this object against the specified object. The result is {@code true} if and only if
* the argument is not {@code null} and is a {@code Float} object that represents a {@code float}
* with the same value as the {@code float} represented by this object. For this purpose, two
* {@code float} values are considered to be the same if and only if the method {@link
* #floatToIntBits(float)} returns the identical {@code int} value when applied to each.
*
* <p>Note that in most cases, for two instances of class {@code Float}, {@code f1} and {@code
* f2}, the value of {@code f1.equals(f2)} is {@code true} if and only if
*
* <blockquote>
*
* <pre>
* f1.floatValue() == f2.floatValue()
* </pre>
*
* </blockquote>
*
* <p>also has the value {@code true}. However, there are two exceptions:
*
* <ul>
* <li>If {@code f1} and {@code f2} both represent {@code Float.NaN}, then the {@code equals}
* method returns {@code true}, even though {@code Float.NaN==Float.NaN} has the value
* {@code false}.
* <li>If {@code f1} represents {@code +0.0f} while {@code f2} represents {@code -0.0f}, or vice
* versa, the {@code equal} test has the value {@code false}, even though {@code
* 0.0f==-0.0f} has the value {@code true}.
* </ul>
*
* This definition allows hash tables to operate properly.
*
* @param obj the object to be compared
* @return {@code true} if the objects are the same; {@code false} otherwise.
* @see java.lang.Float#floatToIntBits(float)
*/
public boolean equals(Object obj) {
return (obj instanceof Float) && (floatToIntBits(((Float) obj).value) == floatToIntBits(value));
}
/**
* Returns a representation of the specified floating-point value according to the IEEE 754
* floating-point "single format" bit layout.
*
* <p>Bit 31 (the bit that is selected by the mask {@code 0x80000000}) represents the sign of the
* floating-point number. Bits 30-23 (the bits that are selected by the mask {@code 0x7f800000})
* represent the exponent. Bits 22-0 (the bits that are selected by the mask {@code 0x007fffff})
* represent the significand (sometimes called the mantissa) of the floating-point number.
*
* <p>If the argument is positive infinity, the result is {@code 0x7f800000}.
*
* <p>If the argument is negative infinity, the result is {@code 0xff800000}.
*
* <p>If the argument is NaN, the result is {@code 0x7fc00000}.
*
* <p>In all cases, the result is an integer that, when given to the {@link #intBitsToFloat(int)}
* method, will produce a floating-point value the same as the argument to {@code floatToIntBits}
* (except all NaN values are collapsed to a single "canonical" NaN value).
*
* @param value a floating-point number.
* @return the bits that represent the floating-point number.
*/
public static int floatToIntBits(float value) {
int result = floatToRawIntBits(value);
// Check for NaN based on values of bit fields, maximum
// exponent and nonzero significand.
if (((result & FloatConsts.EXP_BIT_MASK) == FloatConsts.EXP_BIT_MASK)
&& (result & FloatConsts.SIGNIF_BIT_MASK) != 0) result = 0x7fc00000;
return result;
}
/**
* Returns a representation of the specified floating-point value according to the IEEE 754
* floating-point "single format" bit layout, preserving Not-a-Number (NaN) values.
*
* <p>Bit 31 (the bit that is selected by the mask {@code 0x80000000}) represents the sign of the
* floating-point number. Bits 30-23 (the bits that are selected by the mask {@code 0x7f800000})
* represent the exponent. Bits 22-0 (the bits that are selected by the mask {@code 0x007fffff})
* represent the significand (sometimes called the mantissa) of the floating-point number.
*
* <p>If the argument is positive infinity, the result is {@code 0x7f800000}.
*
* <p>If the argument is negative infinity, the result is {@code 0xff800000}.
*
* <p>If the argument is NaN, the result is the integer representing the actual NaN value. Unlike
* the {@code floatToIntBits} method, {@code floatToRawIntBits} does not collapse all the bit
* patterns encoding a NaN to a single "canonical" NaN value.
*
* <p>In all cases, the result is an integer that, when given to the {@link #intBitsToFloat(int)}
* method, will produce a floating-point value the same as the argument to {@code
* floatToRawIntBits}.
*
* @param value a floating-point number.
* @return the bits that represent the floating-point number.
* @since 1.3
*/
public static native int floatToRawIntBits(float value);
/**
* Returns the {@code float} value corresponding to a given bit representation. The argument is
* considered to be a representation of a floating-point value according to the IEEE 754
* floating-point "single format" bit layout.
*
* <p>If the argument is {@code 0x7f800000}, the result is positive infinity.
*
* <p>If the argument is {@code 0xff800000}, the result is negative infinity.
*
* <p>If the argument is any value in the range {@code 0x7f800001} through {@code 0x7fffffff} or
* in the range {@code 0xff800001} through {@code 0xffffffff}, the result is a NaN. No IEEE 754
* floating-point operation provided by Java can distinguish between two NaN values of the same
* type with different bit patterns. Distinct values of NaN are only distinguishable by use of the
* {@code Float.floatToRawIntBits} method.
*
* <p>In all other cases, let <i>s</i>, <i>e</i>, and <i>m</i> be three values that can be
* computed from the argument:
*
* <blockquote>
*
* <pre>
* int s = ((bits >> 31) == 0) ? 1 : -1;
* int e = ((bits >> 23) & 0xff);
* int m = (e == 0) ?
* (bits & 0x7fffff) << 1 :
* (bits & 0x7fffff) | 0x800000;
* </pre>
*
* </blockquote>
*
* Then the floating-point result equals the value of the mathematical expression
* <i>s</i>·<i>m</i>·2<sup><i>e</i>-150</sup>.
*
* <p>Note that this method may not be able to return a {@code float} NaN with exactly same bit
* pattern as the {@code int} argument. IEEE 754 distinguishes between two kinds of NaNs, quiet
* NaNs and <i>signaling NaNs</i>. The differences between the two kinds of NaN are generally not
* visible in Java. Arithmetic operations on signaling NaNs turn them into quiet NaNs with a
* different, but often similar, bit pattern. However, on some processors merely copying a
* signaling NaN also performs that conversion. In particular, copying a signaling NaN to return
* it to the calling method may perform this conversion. So {@code intBitsToFloat} may not be able
* to return a {@code float} with a signaling NaN bit pattern. Consequently, for some {@code int}
* values, {@code floatToRawIntBits(intBitsToFloat(start))} may <i>not</i> equal {@code start}.
* Moreover, which particular bit patterns represent signaling NaNs is platform dependent;
* although all NaN bit patterns, quiet or signaling, must be in the NaN range identified above.
*
* @param bits an integer.
* @return the {@code float} floating-point value with the same bit pattern.
*/
public static native float intBitsToFloat(int bits);
/**
* Compares two {@code Float} objects numerically. There are two ways in which comparisons
* performed by this method differ from those performed by the Java language numerical comparison
* operators ({@code <, <=, ==, >=, >}) when applied to primitive {@code float} values:
*
* <ul>
* <li>{@code Float.NaN} is considered by this method to be equal to itself and greater than all
* other {@code float} values (including {@code Float.POSITIVE_INFINITY}).
* <li>{@code 0.0f} is considered by this method to be greater than {@code -0.0f}.
* </ul>
*
* This ensures that the <i>natural ordering</i> of {@code Float} objects imposed by this method
* is <i>consistent with equals</i>.
*
* @param anotherFloat the {@code Float} to be compared.
* @return the value {@code 0} if {@code anotherFloat} is numerically equal to this {@code Float};
* a value less than {@code 0} if this {@code Float} is numerically less than {@code
* anotherFloat}; and a value greater than {@code 0} if this {@code Float} is numerically
* greater than {@code anotherFloat}.
* @since 1.2
* @see Comparable#compareTo(Object)
*/
public int compareTo(Float anotherFloat) {
return Float.compare(value, anotherFloat.value);
}
/**
* Compares the two specified {@code float} values. The sign of the integer value returned is the
* same as that of the integer that would be returned by the call:
*
* <pre>
* new Float(f1).compareTo(new Float(f2))
* </pre>
*
* @param f1 the first {@code float} to compare.
* @param f2 the second {@code float} to compare.
* @return the value {@code 0} if {@code f1} is numerically equal to {@code f2}; a value less than
* {@code 0} if {@code f1} is numerically less than {@code f2}; and a value greater than
* {@code 0} if {@code f1} is numerically greater than {@code f2}.
* @since 1.4
*/
public static int compare(float f1, float f2) {
if (f1 < f2) return -1; // Neither val is NaN, thisVal is smaller
if (f1 > f2) return 1; // Neither val is NaN, thisVal is larger
int thisBits = Float.floatToIntBits(f1);
int anotherBits = Float.floatToIntBits(f2);
return (thisBits == anotherBits
? 0
: // Values are equal
(thisBits < anotherBits
? -1
: // (-0.0, 0.0) or (!NaN, NaN)
1)); // (0.0, -0.0) or (NaN, !NaN)
}
/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -2671257302660747028L;
}