Double.ValueOf Método

Definición

Espacio de nombres:: Java.Lang

Ensamblado:: Mono.Android.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Sobrecargas

Nombre	Description
ValueOf(String)	Devuelve un `Double` objeto que contiene el `double` valor representado por la cadena `s`de argumento .
ValueOf(Double)	Devuelve una `Double` instancia que representa el valor especificado `double` .

ValueOf(String)

Devuelve un Double objeto que contiene el double valor representado por la cadena sde argumento .

[Android.Runtime.Register("valueOf", "(Ljava/lang/String;)Ljava/lang/Double;", "")]
public static Java.Lang.Double ValueOf(string s);

[<Android.Runtime.Register("valueOf", "(Ljava/lang/String;)Ljava/lang/Double;", "")>]
static member ValueOf : string -> Java.Lang.Double

Parámetros

s: String

cadena que se va a analizar.

Devoluciones

Double

objeto Double que contiene el valor representado por el String argumento .

Atributos: RegisterAttribute

Excepciones

NumberFormatException

si string no se puede analizar como un valor doble.

Comentarios

Devuelve un Double objeto que contiene el double valor representado por la cadena sde argumento .

Si s es null, se produce una NullPointerException excepción .

Se omiten los caracteres de espacios en blanco iniciales y finales de s . El espacio en blanco se quita como si fuera por el String#trim método ; es decir, se quitan tanto el espacio ASCII como los caracteres de control. El resto de debe constituir s como se describe en las reglas de sintaxis léxica:

<blockquote><dl><dt>FloatValue:<dd>SignoptNaN<dd>SignoptInfinity<dd>Signopt FloatingPointLiteral<dd>Signopt HexFloatingPointLiteral<dd>SignedInteger</dl>

<dl><dt>HexFloatingPointLiteral: <dd>HexSignificand BinaryExponent FloatTypeSuffixopt</dl>

<dl><dt>HexSignificand:<dd>HexNumeral<dd>HexNumeral.<dd>>.dd<>>./dl<>

<dl><dt>BinaryExponent:<dd>BinaryExponentIndicator SignedInteger</dl>

<dl><dt>BinaryExponentIndicator:<dd>p<dd>P</dl>

</blockquote>

donde Sign, FloatingPointLiteral, HexNumeral, HexDigits, SignedInteger y FloatTypeSuffix se definen en las secciones de estructura léxica de <cita>The Java Language Specification</cite>, excepto que los caracteres de subrayado no se aceptan entre dígitos. Si s no tiene la forma de floatValue, se produce una NumberFormatException excepción . De lo contrario, s se considera que representa un valor decimal exacto en la "notación científica computerizada" habitual o como un valor hexadecimal exacto; este valor numérico exacto se convierte conceptualmente en un valor binario "infinitomente preciso" que, a continuación, se redondea al tipo double por la regla normal redondeada a más cercana de IEEE 754 aritmética de punto flotante, que incluye conservar el signo de un valor cero.

Tenga en cuenta que la regla de redondeo a más cercana también implica el comportamiento de desbordamiento y subflujo; si el valor exacto de s es lo suficientemente grande en magnitud (mayor o igual que (#MAX_VALUE + Math#ulp(double) ulp(MAX_VALUE)/2), el redondeo a double dará como resultado un infinito y si el valor exacto de s es lo suficientemente pequeño en magnitud (menor o igual #MIN_VALUEque /2), el redondeo a float dará como resultado un cero.

Por último, después de redondear un Double objeto que representa este double valor se devuelve.

Para interpretar representaciones de cadena localizadas de un valor de punto flotante, use subclases de java.text.NumberFormat.

Tenga en cuenta que los especificadores de formato final, especificadores que determinan el tipo de un literal de punto flotante (1.0f es un valor; float es un 1.0ddouble valor), no <influyen en><> los resultados de este método. En otras palabras, el valor numérico de la cadena de entrada se convierte directamente en el tipo de punto flotante de destino. La secuencia de dos pasos de conversiones, cadena a float seguida de float a double, es not equivalente a convertir una cadena directamente en double. Por ejemplo, el float literal 0.1f es igual al double valor 0.10000000149011612; el float literal 0.1f representa un valor numérico diferente al double literal 0.1. (El valor numérico 0.1 no se puede representar exactamente en un número de punto flotante binario).

Para evitar llamar a este método en una cadena no válida y tener una NumberFormatException excepción , la expresión regular siguiente se puede usar para pantalla la cadena de entrada:

{@code
             final String Digits     = "(\\p{Digit}+)";
             final String HexDigits  = "(\\p{XDigit}+)";
             // 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
             }
            }

Documentación de Java para java.lang.Double.valueOf(java.lang.String).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el proyecto de código abierto de Android y se usan según los términos descritos en la licencia de atribución de Creative Commons 2.5.

Consulte también

ParseDouble(String)

Se aplica a

ValueOf(Double)

Devuelve una Double instancia que representa el valor especificado double .

[Android.Runtime.Register("valueOf", "(D)Ljava/lang/Double;", "")]
public static Java.Lang.Double ValueOf(double d);

[<Android.Runtime.Register("valueOf", "(D)Ljava/lang/Double;", "")>]
static member ValueOf : double -> Java.Lang.Double

Parámetros

d: Double

un valor doble.

Devoluciones

Double

instancia Double de dque representa .

Atributos: RegisterAttribute

Comentarios

Devuelve una Double instancia que representa el valor especificado double . Si no se requiere una nueva Double instancia, este método normalmente se debe usar en preferencia para el constructor #Double(double), ya que es probable que este método produzca un rendimiento de espacio y tiempo significativamente mejor mediante el almacenamiento en caché de valores solicitados con frecuencia.

Agregado en 1.5.

Documentación de Java para java.lang.Double.valueOf(double).

Se aplica a