Double.ValueOf Metodo

[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

Parametri

Valori restituiti

oggetto Double che contiene il valore rappresentato dall'argomento String .

Attributi

RegisterAttribute

Eccezioni

Commenti

Restituisce un Double oggetto che contiene il double valore rappresentato dalla stringa sdell'argomento .

Se s è null, viene generata un'eccezione NullPointerException .

Gli spazi vuoti iniziali e finali in s vengono ignorati. Lo spazio vuoto viene rimosso come se dal String#trim metodo , ovvero sia lo spazio ASCII che i caratteri di controllo vengono rimossi. Il resto di s deve costituire un FloatValue come descritto dalle regole della sintassi lessicale:

<blockquote><dl><dt>FloatValue:<dd>Sign sub<opt>/sub<dd Sign>><><>/dl><><><><>

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

<dl><dt>HexSignificand:<dd>HexNumeral<dd>HexNumeral.<dd>0xHexDigits sub<opt>/sub< HexDigits>.dd<>>./dl <>

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

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

</blockquote>

dove Sign, FloatingPointLiteral, HexNumeral, HexDigits, SignedInteger e FloatTypeSuffix sono definiti nelle sezioni della struttura lessicale di <cite>The Java Language Specification</cite>, ad eccezione del fatto che i caratteri di sottolineatura non vengono accettati tra le cifre. Se s non ha la forma di floatValue, viene generata un'eccezione NumberFormatException . In caso contrario, s viene considerato come un valore decimale esatto nella consueta notazione scientifica "computerizzata" o come valore esadecimale esatto. Questo valore numerico esatto viene quindi convertito concettualmente in un valore binario "infinitamente preciso" che viene quindi arrotondato al tipo double dalla regola arrotondamento più vicino consueto di IEEE 754 a virgola mobile, che include il mantenimento del segno di un valore zero.

Si noti che la regola round-to-near più implica anche il comportamento di overflow e underflow; se il valore esatto di è sufficientemente grande in grandezza (maggiore o uguale a (s#MAX_VALUE + /2), l'arrotondamento a Math#ulp(double) ulp(MAX_VALUE) comporterà un infinito e se il valore esatto di doubles è sufficientemente piccolo in grandezza (minore o uguale a #MIN_VALUE/2), l'arrotondamento a float comporterà uno zero.

Infine, dopo l'arrotondamento di un Double oggetto che rappresenta questo double valore viene restituito.

Per interpretare le rappresentazioni di stringa localizzate di un valore a virgola mobile, usare sottoclassi di java.text.NumberFormat.

Si noti che gli identificatori di formato finali, gli identificatori che determinano il tipo di un valore letterale a virgola mobile (1.0f è un float1.0d valore), double non<>< influiscono sui> risultati di questo metodo. In altre parole, il valore numerico della stringa di input viene convertito direttamente nel tipo a virgola mobile di destinazione. La sequenza in due passaggi delle conversioni, stringa da float seguire da float a double, è <em>not</em> equivalente alla conversione di una stringa direttamente in double. Ad esempio, il float valore letterale 0.1f è uguale al double valore 0.10000000149011612. Il float valore letterale 0.1f rappresenta un valore numerico diverso rispetto al double valore letterale 0.1. Il valore numerico 0.1 non può essere rappresentato esattamente in un numero a virgola mobile binaria.

Per evitare di chiamare questo metodo su una stringa non valida e generare un'eccezione NumberFormatException , è possibile usare l'espressione regolare seguente per visualizzare la stringa di input:

{@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
             }
            }

per java.lang.Double.valueOf(java.lang.String).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

Vedi anche

• ParseDouble(String)

[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

Parametri

Valori restituiti

Double Istanza di che rappresenta d.

Attributi

RegisterAttribute

Commenti

Restituisce un'istanza Double che rappresenta il valore specificato double . Se non è necessaria una nuova Double istanza, questo metodo deve in genere essere usato in preferenza per il costruttore #Double(double), perché questo metodo produce probabilmente prestazioni di spazio e tempo notevolmente migliori memorizzando nella cache i valori richiesti di frequente.

Aggiunto nella versione 1.5.

per java.lang.Double.valueOf(double).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.