Java lang double int

The Double class wraps a value of the primitive type double in an object. An object of type Double contains a single field whose type is double . In addition, this class provides several methods for converting a double to a String and a String to a double , as well as other constants and methods useful when dealing with a double .

Field Summary

Constructor Summary

Constructs a newly allocated Double object that represents the floating-point value of type double represented by the string.

Method Summary

Returns a representation of the specified floating-point value according to the IEEE 754 floating-point «double format» bit layout.

Returns a representation of the specified floating-point value according to the IEEE 754 floating-point «double format» bit layout, preserving Not-a-Number (NaN) values.

Returns true if the argument is a finite floating-point value; returns false otherwise (for NaN and infinity arguments).

Returns a new double initialized to the value represented by the specified String , as performed by the valueOf method of class Double .

Methods inherited from class java.lang.Object

Field Detail

POSITIVE_INFINITY

public static final double POSITIVE_INFINITY

A constant holding the positive infinity of type double . It is equal to the value returned by Double.longBitsToDouble(0x7ff0000000000000L) .

NEGATIVE_INFINITY

public static final double NEGATIVE_INFINITY

A constant holding the negative infinity of type double . It is equal to the value returned by Double.longBitsToDouble(0xfff0000000000000L) .

NaN

public static final double NaN

A constant holding a Not-a-Number (NaN) value of type double . It is equivalent to the value returned by Double.longBitsToDouble(0x7ff8000000000000L) .

MAX_VALUE

public static final double MAX_VALUE

A constant holding the largest positive finite value of type double , (2-2 -52 )·2 1023 . It is equal to the hexadecimal floating-point literal 0x1.fffffffffffffP+1023 and also equal to Double.longBitsToDouble(0x7fefffffffffffffL) .

MIN_NORMAL

public static final double MIN_NORMAL

A constant holding the smallest positive normal value of type double , 2 -1022 . It is equal to the hexadecimal floating-point literal 0x1.0p-1022 and also equal to Double.longBitsToDouble(0x0010000000000000L) .

MIN_VALUE

public static final double MIN_VALUE

A constant holding the smallest positive nonzero value of type double , 2 -1074 . It is equal to the hexadecimal floating-point literal 0x0.0000000000001P-1022 and also equal to Double.longBitsToDouble(0x1L) .

MAX_EXPONENT

public static final int MAX_EXPONENT

Maximum exponent a finite double variable may have. It is equal to the value returned by Math.getExponent(Double.MAX_VALUE) .

MIN_EXPONENT

public static final int MIN_EXPONENT

Minimum exponent a normalized double variable may have. It is equal to the value returned by Math.getExponent(Double.MIN_NORMAL) .

SIZE

public static final int SIZE

BYTES

public static final int BYTES

TYPE

Constructor Detail

Double

public Double(double value)

Double

public Double(String s) throws NumberFormatException

Constructs a newly allocated Double object that represents the floating-point value of type double represented by the string. The string is converted to a double value as if by the valueOf method.

Method Detail

toString

If the argument is NaN, the result is the string » NaN «.
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 ‘ — ‘ ( ‘\u002D’ ); if the sign is positive, no sign character appears in the result. As for the magnitude m:
- If m is infinity, it is represented by the characters «Infinity» ; thus, positive infinity produces the result «Infinity» and negative infinity produces the result «-Infinity» .
- If m is zero, it is represented by the characters «0.0» ; thus, negative zero produces the result «-0.0» and positive zero produces the result «0.0» .
- If m is greater than or equal to 10 -3 but less than 10 7 , then it is represented as the integer part of m, in decimal form with no leading zeroes, followed by ‘ . ‘ ( ‘\u002E’ ), followed by one or more decimal digits representing the fractional part of m.
- If m is less than 10 -3 or greater than or equal to 10 7 , then it is represented in so-called «computerized scientific notation.» Let n be the unique integer such that 10 n ≤ m< 10 n+1 ; then let a be the mathematically exact quotient of m and 10 n so that 1 ≤ a< 10. The magnitude is then represented as the integer part of a, as a single decimal digit, followed by ‘ . ‘ ( ‘\u002E’ ), followed by decimal digits representing the fractional part of a, followed by the letter ‘ E ‘ ( ‘\u0045’ ), followed by a representation of n as a decimal integer, as produced by the method Integer.toString(int) .
toHexString
- If the argument is NaN, the result is the string » NaN «.
- Otherwise, the result is a string that represents the sign and magnitude of the argument. If the sign is negative, the first character of the result is ‘ — ‘ ( ‘\u002D’ ); if the sign is positive, no sign character appears in the result. As for the magnitude m:
  - If m is infinity, it is represented by the string «Infinity» ; thus, positive infinity produces the result «Infinity» and negative infinity produces the result «-Infinity» .
  - If m is zero, it is represented by the string «0x0.0p0» ; thus, negative zero produces the result «-0x0.0p0» and positive zero produces the result «0x0.0p0» .
  - If m is a double value with a normalized representation, substrings are used to represent the significand and exponent fields. The significand is represented by the characters «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 «p» followed by a decimal string of the unbiased exponent as if produced by a call to Integer.toString on the exponent value.
  - If m is a double value with a subnormal representation, the significand is represented by the characters «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 «p-1022» . Note that there must be at least one nonzero digit in a subnormal significand.
  valueOf
```
public static Double valueOf(String s) throws NumberFormatException
```
  Returns a Double object holding the double value represented by the argument string s . If s is null , then a NullPointerException is thrown. Leading and trailing whitespace characters in s are ignored. Whitespace is removed as if by the String.trim() method; that is, both ASCII space and control characters are removed. The rest of s should constitute a FloatValue as described by the lexical syntax rules:
  
  FloatValue: Sign_opt NaN Sign_opt Infinity Sign_opt FloatingPointLiteral Sign_opt HexFloatingPointLiteral SignedInteger HexFloatingPointLiteral: HexSignificand BinaryExponent FloatTypeSuffix_opt HexSignificand: HexNumeral HexNumeral . 0x HexDigits_opt . HexDigits 0X HexDigits_opt . HexDigits BinaryExponent: BinaryExponentIndicator SignedInteger BinaryExponentIndicator: p P
  
  where Sign, FloatingPointLiteral, HexNumeral, HexDigits, SignedInteger and FloatTypeSuffix are as defined in the lexical structure sections of The Java™ Language Specification , except that underscores are not accepted between digits. If s does not have the form of a FloatValue, then a NumberFormatException is thrown. Otherwise, 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 double by the usual round-to-nearest rule of IEEE 754 floating-point arithmetic, which includes preserving the sign of a zero value. Note that the round-to-nearest rule also implies overflow and underflow behaviour; if the exact value of s is large enough in magnitude (greater than or equal to ( MAX_VALUE + ulp(MAX_VALUE) /2), rounding to double will result in an infinity and if the exact value of s is small enough in magnitude (less than or equal to MIN_VALUE /2), rounding to float will result in a zero. Finally, after rounding a Double object representing this double value is returned. To interpret localized string representations of a floating-point value, use subclasses of NumberFormat . Note that trailing format specifiers, specifiers that determine the type of a floating-point literal ( 1.0f is a float value; 1.0d is a double value), do not 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. The two-step sequence of conversions, string to float followed by float to double , is not equivalent to converting a string directly to double . For example, the float literal 0.1f is equal to the double value 0.10000000149011612 ; the float literal 0.1f represents a different numerical value than the double literal 0.1 . (The numerical value 0.1 cannot be exactly represented in a binary floating-point number.) To avoid calling this method on an invalid string and having a NumberFormatException be thrown, the regular expression below can be used to screen the input string:
```
 final String Digits = "(\\p+)"; final String HexDigits = "(\\p+)"; // an exponent is 'e' or 'E' followed by an optionally // signed decimal integer. final String Exp = "[eE][+-]?"+Digits; final String fpRegex = ("[\\x00-\\x20]*"+ // Optional leading "whitespace" "[+-]?(" + // Optional sign character "NaN|" + // "NaN" string "Infinity|" + // "Infinity" string // A decimal floating-point string representing a finite positive // number without a leading sign has at most five basic pieces: // Digits . Digits ExponentPart FloatTypeSuffix // // Since this method allows integer-only strings as input // in addition to strings of floating-point literals, the // two sub-patterns below are simplifications of the grammar // productions from section 3.10.2 of // The Java Language Specification. // Digits ._opt Digits_opt ExponentPart_opt FloatTypeSuffix_opt "((("+Digits+"(\\.)?("+Digits+"?)("+Exp+")?)|"+ // . Digits ExponentPart_opt FloatTypeSuffix_opt "(\\.("+Digits+")("+Exp+")?)|"+ // Hexadecimal strings "((" + // 0[xX] HexDigits ._opt BinaryExponent FloatTypeSuffix_opt "(0[xX]" + HexDigits + "(\\.)?)|" + // 0[xX] HexDigits_opt . HexDigits BinaryExponent FloatTypeSuffix_opt "(0[xX]" + HexDigits + "?(\\.)" + HexDigits + ")" + ")[pP][+-]?" + Digits + "))" + "[fFdD]?))" + "[\\x00-\\x20]*");// Optional trailing "whitespace" if (Pattern.matches(fpRegex, myString)) Double.valueOf(myString); // Will not throw NumberFormatException else < // Perform suitable alternative action >
```
  valueOf
  
  Returns a Double instance representing the specified double value. If a new Double instance is not required, this method should generally be used in preference to the constructor Double(double) , as this method is likely to yield significantly better space and time performance by caching frequently requested values.
  
  parseDouble
```
public static double parseDouble(String s) throws NumberFormatException
```
  Returns a new double initialized to the value represented by the specified String , as performed by the valueOf method of class Double .
  
  isNaN
```
public static boolean isNaN(double v)
```
  Источник
  
  Читайте также: Sudo apt get install php pgsql

Java lang double int

Как double преобразовать в int java