Double.ValueOf Método

Definição

Namespace:: Java.Lang

Assembly:: Mono.Android.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Sobrecargas

Nome	Description
ValueOf(String)	Retorna um `Double` objeto que contém o `double` valor representado pela cadeia de `s`caracteres de argumento.
ValueOf(Double)	Retorna uma `Double` instância que representa o valor especificado `double` .

ValueOf(String)

Retorna um Double objeto que contém o double valor representado pela cadeia de scaracteres de 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

a cadeia de caracteres a ser analisada.

Retornos

Double

um Double objeto que contém o valor representado pelo String argumento.

Atributos: RegisterAttribute

Exceções

NumberFormatException

se string não puder ser analisado como um valor duplo.

Comentários

Retorna um Double objeto que contém o double valor representado pela cadeia de scaracteres de argumento.

Se s for null, então um NullPointerException é lançado.

Os caracteres de espaço em s branco à esquerda e à direita são ignorados. O espaço em branco é removido como se fosse pelo String#trim método; ou seja, o espaço ASCII e os caracteres de controle são removidos. O restante s deve constituir um FloatValue , conforme descrito pelas regras de sintaxe lexical:

<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><pdd>P</dl>

</blockquote>

onde Sign, FloatingPointLiteral, HexNumeral, HexDigits, SignedInteger e FloatTypeSuffix são definidos nas seções de estrutura lexical do <cite>The Java Language Specification</cite>, exceto que sublinhados não são aceitos entre dígitos. Se s não tiver a forma de um FloatValue, um NumberFormatException será lançado. Caso contrário, s é considerado como representando um valor decimal exato na "notação científica computada" usual ou como um valor hexadecimal exato; esse valor numérico exato é convertido conceitualmente em um valor binário "infinitamente preciso" que é arredondado para digitar double pela regra usual de volta para mais próxima da aritmética de ponto flutuante IEEE 754, que inclui preservar o sinal de um valor zero.

Observe que a regra de ida e volta para a mais próxima também implica comportamento de estouro e subfluxo; se o valor exato for s grande o suficiente em magnitude (maior ou igual a (#MAX_VALUE + Math#ulp(double) ulp(MAX_VALUE)/2), arredondar para double resultará em um infinito e se o valor exato for s pequeno o suficiente em magnitude (menor ou igual a #MIN_VALUE/2), arredondar para flutuar resultará em zero.

Por fim, depois de arredondar um Double objeto que representa esse double valor é retornado.

Para interpretar representações de cadeia de caracteres localizadas de um valor de ponto flutuante, use subclasses de java.text.NumberFormat.

Observe que especificadores de formato à direita, especificadores que determinam o tipo de um literal de ponto flutuante (1.0f é um float valor; 1.0d é um double valor),<> não< em/em influenciam> os resultados desse método. Em outras palavras, o valor numérico da cadeia de caracteres de entrada é convertido diretamente no tipo de ponto flutuante de destino. A sequência de duas etapas de conversões, cadeia de caracteres a float ser seguida por floatdouble, não< é ><equivalente> a converter uma cadeia de caracteres diretamente em double. Por exemplo, o float literal 0.1f é igual ao double valor 0.10000000149011612; o float literal 0.1f representa um valor numérico diferente do double literal 0.1. (O valor numérico 0.1 não pode ser exatamente representado em um número de ponto flutuante binário.)

Para evitar chamar esse método em uma cadeia de caracteres inválida e ter um NumberFormatException lançamento, a expressão regular abaixo pode ser usada para exibir a cadeia de caracteres 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
             }
            }

Java documentação para java.lang.Double.valueOf(java.lang.String).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Android Open Source Project e usadas de acordo com os termos descritos na Licença de Atribuição Creative Commons 2.5.

Confira também

ParseDouble(String)

Aplica-se a

ValueOf(Double)

Retorna uma Double instância que representa o 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

um valor duplo.

Retornos

Double

uma Double instância que drepresenta .

Atributos: RegisterAttribute

Comentários

Retorna uma Double instância que representa o valor especificado double . Se uma nova Double instância não for necessária, esse método geralmente deverá ser usado em preferência ao construtor #Double(double), pois esse método provavelmente produzirá um desempenho de espaço e tempo significativamente melhor armazenando valores solicitados com frequência.

Adicionado em 1.5.

Java documentação para java.lang.Double.valueOf(double).

Aplica-se a