In cosa parseInt()differisce da valueOf()?
Essi sembrano fare esattamente la stessa cosa a me (vale anche per parseFloat(), parseDouble(), parseLong()ecc, come sono differenti da Long.valueOf(string)?
Inoltre, quale di questi è preferibile e utilizzato più spesso per convenzione?
Risposte:
Bene, l'API per Integer.valueOf(String)effettivamente dice che Stringviene interpretato esattamente come se fosse stato dato a Integer.parseInt(String). Tuttavia, valueOf(String)restituisce un oggetto mentre restituisce una primitiva .new Integer()parseInt(String)int
Se vuoi goderti i potenziali benefici della memorizzazione nella cache Integer.valueOf(int), puoi anche usare questo pugno nell'occhio:
Integer k = Integer.valueOf(Integer.parseInt("123"))Ora, se quello che vuoi è l'oggetto e non il primitivo, quindi utilizzando valueOf(String)può essere più attraente di fare un nuovo oggetto fuori parseInt(String)perché il primo è stabilmente presente in tutto Integer, Long, Double, etc.
Integer.valueOf(Integer.parseInt("123"))non ha alcun vantaggio rispetto Integer.valueOf("123")o Integer.valueOf(123)oltre a cicli di sprecare e le dimensioni del vostro programma.
Integer.valueOf(String)fa esattamente la stessa memorizzazione nella cache di Integer.valueOf(int). In realtà, è implementato come Integer.valueOf(Integer.parseInt(…))...
int. La firma dice che restituisce un Integer, ed è esattamente quello che fa. Questa risposta è anche parzialmente errata quando dice che restituisce un "nuovo" Integer. Non è quello che dice nel Javadoc. È gratuito restituire una cache Integer.
Da questo forum :
parseInt()restituisce il tipo intero primitivo ( int ), per cuivalueOfrestituisce java.lang.Integer , che è l'oggetto rappresentativo dell'intero. Ci sono circostanze in cui potresti desiderare un oggetto intero, invece del tipo primitivo.Naturalmente, un'altra ovvia differenza è che intValue è un metodo di istanza in cui parseInt è un metodo statico.
Integer.valueOf(s)è simile a
new Integer(Integer.parseInt(s))La differenza è valueOf()restituisce un Integere parseInt()restituisce un int(un tipo primitivo). Si noti inoltre che valueOf()può restituire Integerun'istanza memorizzata nella cache , che può causare risultati confusi in cui il risultato dei ==test sembra intermittentemente corretto. Prima dell'autoboxing potrebbe esserci una differenza in termini di convenienza, dopo Java 1.5 non ha molta importanza.
Inoltre, Integer.parseInt(s)può assumere anche il tipo di dati primitivo.
Guarda le fonti Java: valueOfsta usando parseInt:
/**
* Parses the specified string as a signed decimal integer value.
*
* @param string
* the string representation of an integer value.
* @return an {@code Integer} instance containing the integer value
* represented by {@code string}.
* @throws NumberFormatException
* if {@code string} cannot be parsed as an integer value.
* @see #parseInt(String)
*/
public static Integer valueOf(String string) throws NumberFormatException {
return valueOf(parseInt(string));
}
parseInt ritorna int
/**
* Parses the specified string as a signed decimal integer value. The ASCII
* character \u002d ('-') is recognized as the minus sign.
*
* @param string
* the string representation of an integer value.
* @return the primitive integer value represented by {@code string}.
* @throws NumberFormatException
* if {@code string} cannot be parsed as an integer value.
*/
public static int parseInt(String string) throws NumberFormatException {
return parseInt(string, 10);
}
Integer.parseInt può semplicemente restituire int come tipo nativo.
Integer.valueOf potrebbe effettivamente essere necessario allocare un oggetto Integer, a meno che tale numero intero non sia uno di quelli preallocati. Questo costa di più.
Se hai bisogno solo del tipo nativo, usa parseInt. Se hai bisogno di un oggetto, usa valueOf.
Inoltre, a causa di questa potenziale allocazione, l'autoboxing non è in realtà una buona cosa in ogni modo. Può rallentare le cose.
Le varianti di analisi * restituiscono tipi primitivi e il valore delle versioni restituisce Oggetti. Credo che il valore delle versioni utilizzerà anche un pool di riferimento interno per restituire l'oggetto SAME per un determinato valore, non solo un'altra istanza con lo stesso valore interno.
Se controlli la classe Integer troverai quel valore di call parseInt method. La grande differenza sta nella memorizzazione nella cache quando si chiama valueof API. Memorizza nella cache se il valore è compreso tra -128 e 127. Per ulteriori informazioni, consulta il link sotto
http://docs.oracle.com/javase/7/docs/api/java/lang/Integer.html
valore intero statico pubblicoOf (String s)
Il risultato è un oggetto intero che rappresenta il valore intero specificato dalla stringa.
In altre parole, questo metodo restituisce un oggetto Integer uguale al valore di: new Integer (Integer.parseInt (s))
Integer.parseInt accetta solo String e restituisce il tipo intero primitivo (int).
public static int parseInt(String s) throws NumberFormatException {
return parseInt(s,10);
}
Iteger.valueOf accetta int e String. Se value è String, valueOf lo converte nel semplice int usando parseInt e restituisce il nuovo numero intero se l'input è inferiore a -128 o maggiore di 127. Se l'input è nell'intervallo (-128 - 127) restituisce sempre gli oggetti Integer da un IntegerCache interno. La classe Integer mantiene una classe IntegerCache statica interna che funge da cache e contiene oggetti interi da -128 a 127 ed è per questo che quando proviamo a ottenere un oggetto intero per 127 (ad esempio) otteniamo sempre lo stesso oggetto.
Iteger.valueOf(200)darà un nuovo numero intero da 200. È come new Integer(200)
Iteger.valueOf(127)è uguale a Integer = 127;
Se non vuoi convertire String in Integer, usa Iteger.valueOf.
Se non vuoi convertire String in un semplice int int Integer.parseInt. Funziona più velocemente.
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
public static Integer valueOf(String s) throws NumberFormatException {
return Integer.valueOf(parseInt(s, 10));
}
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}
E confrontando Integer.valueOf (127) == Integer.valueOf (127) restituisce true
Integer a = 127; // Compiler converts this line to Integer a = Integer.valueOf(127);
Integer b = 127; // Compiler converts this line to Integer b = Integer.valueOf(127);
a == b; // return true
Perché prende gli oggetti Integer con gli stessi riferimenti dalla cache.
Ma Integer.valueOf (128) == Integer.valueOf (128) è falso, perché 128 non è compreso nell'intervallo IntegerCache e restituisce un nuovo numero intero, quindi gli oggetti avranno riferimenti diversi.
Dovremmo usare qualcuno a seconda delle nostre necessità. Nel caso di ValueOf in quanto crea un'istanza di un oggetto. consumerà più risorse se avremo bisogno solo del valore di alcuni testi, quindi dovremmo usare parseInt, parseFloat ecc.