Java'daki parseInt () ve valueOf () arasında fark var mı?

Nasıl parseInt()farklı gelen valueOf()?

Bana göre ikisi de aynı şeyi yapmak için görünür (ayrıca gider parseFloat(), parseDouble(), parseLong()vb nasıl farklıdır Long.valueOf(string)?

Ayrıca, bunlardan hangisi tercih edilir ve konvansiyon tarafından daha sık kullanılır?

Aslında, API Integer.valueOf(String)gerçekten Stringonun verildiği gibi yorumlandığını söylüyor Integer.parseInt(String). Ancak, valueOf(String)bir nesneyi döndürürken bir ilkel döndürür .new Integer()parseInt(String)int

Potansiyel önbellekleme avantajlarından yararlanmak Integer.valueOf(int)istiyorsanız, bu gözünüzü de kullanabilirsiniz:

Integer k = Integer.valueOf(Integer.parseInt("123"))

Şimdi, istediğiniz nesne ve değilse ilkel, o zaman kullanarak valueOf(String)dışarı yeni bir nesne yapmak daha cazip olabilir parseInt(String)eski tutarlı mevcut olduğu için Integer, Long, Doublevb

Gönderen Bu forumun :

parseInt()ilkel tamsayı türünü ( int ) valueOfdöndürür , böylece tamsayının nesne temsilcisi olan java.lang.Integer öğesini döndürür . İlkel tür yerine bir Tamsayı nesnesi isteyebileceğiniz durumlar vardır.

Tabii ki, bir diğer belirgin fark intValue'nun parseInt'in statik bir yöntem olduğu bir örnek yöntem olmasıdır.

Integer.valueOf(s)

benzer

new Integer(Integer.parseInt(s))

Fark, valueOf()an değerini döndürür Integerve parseInt()bir int(ilkel tür) döndürür . Ayrıca , testlerin sonucunun aralıklı olarak doğru göründüğü durumlarda kafa karıştırıcı sonuçlara neden olabilen valueOf()önbelleğe alınmış bir Integerörnek döndürebileceğini unutmayın ==. Otomatik bokstan önce , kolaylık farkı olabilir, java 1.5'ten sonra gerçekten önemli değil.

Dahası, Integer.parseInt(s)ilkel veri tipini de alabilir.

Java kaynaklarına bakın: şunu valueOfkullanıyor 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 İadeler 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 int türünü yerel tür olarak döndürebilir.

Integer.valueOf, gerçekte önceden atanmış olanlardan biri olmadıkça, bir Integer nesnesi ayırması gerekebilir. Bu daha pahalı.

Yalnızca yerel türe ihtiyacınız varsa parseInt kullanın. Bir nesneye ihtiyacınız varsa valueOf öğesini kullanın.

Ayrıca, bu potansiyel tahsis nedeniyle, otomatik boks aslında her şekilde iyi bir şey değildir. Bazı şeyleri yavaşlatabilir.

Ayrıştırma * varyasyonları ilkel türleri döndürür ve sürümlerin valueOf nesneleri Nesneler döndürür. ValueOf sürümleri aynı zamanda sadece aynı iç değere sahip başka bir örnek değil, aynı değer için SAME nesnesini döndürmek için bir iç başvuru havuzu kullanacağına inanıyorum.

Çünkü jdk1.5 + kullanıyor olabilirsiniz ve orada int'e otomatik olarak dönüşüyor. Kodunuzda ilk tamsayı döndüren ve sonra otomatik olarak int dönüştürülür.

kodunla aynı

int abc = new Integer(123);

Integer sınıfını işaretlerseniz, bu valueeof call parseInt yöntemini bulacaksınız. Aradaki en büyük fark, valueeof API'sini çağırdığınızda önbelleğe alınmasıdır. Değer -128 ila 127 arasındaysa önbelleğe alır Daha fazla bilgi için lütfen bağlantının altında bulun

http://docs.oracle.com/javase/7/docs/api/java/lang/Integer.html

public static Integer valueOf (Dize)

1. Bağımsız değişken, tam olarak parseInt (java.lang.String) yöntemine verilmiş gibi, işaretli bir ondalık tamsayıyı temsil ettiği şeklinde yorumlanır.

2. Sonuç, dize tarafından belirtilen tam sayı değerini temsil eden bir Tamsayı nesnesidir.

3. Başka bir deyişle, bu yöntem şu değere eşit bir Integer nesnesi döndürür: new Integer (Integer.parseInt (s))

• valueOf - Wrapper sınıfına dönüştürür
• parseInt - ilkel türe dönüştürür

Integer.parseInt yalnızca String kabul eder ve ilkel tamsayı türünü (int) döndürür.

   public static int parseInt(String s) throws NumberFormatException {
        return parseInt(s,10);
    }

Iteger.valueOf int ve String kabul eder. Değer String ise, parseInt kullanarak basit int değerine dönüştürün ve giriş -128'den küçük veya 127'den büyükse yeni Tamsayı döndürün. Girdi (-128 - 127) aralığındaysa, her zaman bir Tamsayı nesnesi dahili IntegerCache. Integer sınıfı, önbellek görevi gören ve -128'den 127'ye kadar tamsayı nesneleri tutan bir iç statik IntegerCache sınıfını korur ve bu nedenle 127 (örneğin) için tamsayı nesnesi almaya çalıştığımızda (örneğin) her zaman aynı nesneyi alırız.

Iteger.valueOf(200)Sanki 200 yeni Tamsayı verecek new Integer(200) Iteger.valueOf(127)aynıdır Integer = 127;

String'i Tamsayıya dönüştürmek istemezseniz kullanın Iteger.valueOf.

Eğer basit int kullanımı String dönüştürmek alışkanlık varsa Integer.parseInt. Daha hızlı çalışır.

  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() {}
  }

Ve Integer.valueOf (127) == Integer.valueOf (127) karşılaştırması true değerini döndürür

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 

Çünkü aynı referanslara sahip Integer nesnelerini önbellekten alır.

Ancak Integer.valueOf (128) == Integer.valueOf (128) yanlıştır, çünkü 128 IntegerCache aralığının dışında olduğundan ve yeni Integer döndürdüğünden nesnelerin farklı referansları olacaktır.

1. ValueOf -> olması durumunda bir Integer nesnesi yaratır. ilkel tip değil, statik yöntem değil.
2. ParseInt.ParseFloat durumunda -> ilgili ilkel türü döndürür. ve statik bir yöntemdir.

İhtiyacımıza bağlı olarak herhangi birini kullanmalıyız. Bir nesneyi başlatırken ValueOf olması durumunda. yalnızca bir metnin değerine ihtiyacımız olursa daha fazla kaynak tüketecektir, o zaman parseInt, parseFloat vb.