Czym się parseInt()różni valueOf()?
Pojawiają się one robić dokładnie to samo do mnie (również idzie do parseFloat(), parseDouble(), parseLong()etc, w jaki sposób są one różne od Long.valueOf(string)?
Który z nich jest preferowany i częściej wykorzystywany w konwencji?
Odpowiedzi:
Cóż, API dla Integer.valueOf(String)rzeczywiście mówi, że Stringjest interpretowany dokładnie tak, jakby został przekazany Integer.parseInt(String). Jednak valueOf(String)zwraca obiekt, natomiast zwraca prymitywnych .new Integer()parseInt(String)int
Jeśli chcesz czerpać korzyści z potencjalnego buforowania Integer.valueOf(int), możesz również skorzystać z tego narzędzia do usuwania oczu:
Integer k = Integer.valueOf(Integer.parseInt("123"))Teraz, jeśli to, co chcesz, jest przedmiotem, a nie prymitywne, a następnie przy użyciu valueOf(String)mogą być bardziej atrakcyjne niż tworzenia nowego obiektu z parseInt(String)ponieważ ta pierwsza jest stale obecny w poprzek Integer, Long, Double, itd.
Integer.valueOf(Integer.parseInt("123"))nie ma korzyści Integer.valueOf("123")ani Integer.valueOf(123)marnowania cykli, ani rozmiaru twojego programu.
Integer.valueOf(String)wykonuje dokładnie takie samo buforowanie jak Integer.valueOf(int). W rzeczywistości jest zaimplementowany jako Integer.valueOf(Integer.parseInt(…))…
int. Podpis mówi, że zwraca Integeri to jest dokładnie to, co robi. Ta odpowiedź jest również częściowo niepoprawna, gdy mówi, że zwraca „nowy” Integer. Tak nie jest napisane w Javadoc. Zwrot pamięci podręcznej jest bezpłatny Integer.
Z tego forum :
parseInt()zwraca pierwotny typ liczb całkowitych ( int ), przy czymvalueOfzwraca java.lang.Integer , który jest obiektem reprezentatywnym dla liczby całkowitej. Są okoliczności, w których możesz chcieć obiektu typu Integer zamiast typu pierwotnego.Oczywiście inną oczywistą różnicą jest to, że intValue jest metodą instancji, w której parseInt jest metodą statyczną.
Integer.valueOf(s)jest podobne do
new Integer(Integer.parseInt(s))Różnica polega na valueOf()zwracaniu an Integeri parseInt()zwracaniu an int(typ pierwotny). Zauważ też, że valueOf()może zwrócić Integerinstancję z pamięci podręcznej , co może powodować mylące wyniki, gdy wyniki ==testów wydają się sporadycznie poprawne. Przed autoboxingiem może być różnica w wygodzie, po Java 1.5 nie ma to tak naprawdę znaczenia.
Ponadto Integer.parseInt(s)może również przyjmować prymitywny typ danych.
Spójrz na źródła Java: valueOfużywa 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 zwroty 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 może po prostu zwrócić int jako typ macierzysty.
Integer.valueOf może faktycznie wymagać przydzielenia obiektu Integer, chyba że ta liczba całkowita przypadkowo będzie jedną z wstępnie przydzielonych. To kosztuje więcej.
Jeśli potrzebujesz tylko rodzimego typu, użyj parseInt. Jeśli potrzebujesz obiektu, użyj valueOf.
Ponadto, z powodu tego potencjalnego przydziału, autoboxing nie jest tak naprawdę dobrą rzeczą pod każdym względem. Może spowolnić rzeczy.
Warianty parsowania * zwracają typy pierwotne, a wersje valueOf zwracają obiekty. Wierzę, że wersje valueOf będą również korzystać z wewnętrznej puli referencyjnej, aby zwrócić obiekt SAME dla danej wartości, a nie tylko innej instancji o tej samej wartości wewnętrznej.
Jeśli zaznaczysz klasę całkowitą, znajdziesz wartość metody wywołania parseInt. Dużą różnicą jest buforowanie podczas wywoływania wartości API. Buforuje, jeśli wartość mieści się w przedziale od -128 do 127. Więcej informacji można znaleźć pod linkiem
http://docs.oracle.com/javase/7/docs/api/java/lang/Integer.html
public static static Integer valueOf (String s)
Wynikiem jest obiekt typu Integer, który reprezentuje wartość całkowitą określoną przez ciąg.
Innymi słowy, ta metoda zwraca obiekt typu Integer równy wartości: new Integer (Integer.parseInt (s))
Integer.parseInt akceptuje tylko ciąg znaków i zwraca pierwotną liczbę całkowitą typu int (int).
public static int parseInt(String s) throws NumberFormatException {
return parseInt(s,10);
}Iteger.valueOf accept int i String. Jeśli wartością jest String, wartośćOf przekształca ją na zwykłą liczbę int za pomocą parseInt i zwraca nową liczbę całkowitą, jeśli wartość wejściowa jest mniejsza niż -128 lub większa niż 127. Jeśli wartość wejściowa jest w zakresie (-128 - 127), zawsze zwraca obiekty Integer z wewnętrzna IntegerCache. Klasa całkowita utrzymuje wewnętrzną statyczną klasę IntegerCache, która działa jako pamięć podręczna i przechowuje obiekty całkowite od -128 do 127 i dlatego, gdy próbujemy uzyskać obiekt całkowity dla 127 (na przykład), zawsze otrzymujemy ten sam obiekt.
Iteger.valueOf(200)da nową liczbę całkowitą od 200. To jest tak new Integer(200)
Iteger.valueOf(127)samo jak Integer = 127;
Jeśli nie chcesz konwertować ciągu znaków na liczbę całkowitą, użyj Iteger.valueOf.
Jeśli nie chcesz konwertować ciągu znaków na prosty int use Integer.parseInt. Działa szybciej.
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() {}
}I porównanie Integer.valueOf (127) == Integer.valueOf (127) zwraca 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 Ponieważ pobiera obiekty Integer z tymi samymi odwołaniami z pamięci podręcznej.
Ale Integer.valueOf (128) == Integer.valueOf (128) jest fałszem, ponieważ 128 jest poza zakresem IntegerCache i zwraca nową liczbę całkowitą, więc obiekty będą miały różne odwołania.
Powinniśmy użyć każdego w zależności od naszych potrzeb. W przypadku ValueOf, ponieważ tworzy on obiekt. zużyje więcej zasobów, jeśli potrzebujemy tylko wartości jakiegoś tekstu, wówczas powinniśmy użyć parseInt, parseFloat itp.