Berbeda antara parseInt () dan valueOf () di java?

Bagaimana parseInt()bedanya valueOf()?

Mereka muncul untuk melakukan hal yang sama dengan saya (juga berlaku untuk parseFloat(), parseDouble(), parseLong()dll, bagaimana mereka berbeda dari Long.valueOf(string)?

Juga, yang mana yang lebih disukai dan digunakan lebih sering oleh konvensi?

Nah, API untuk Integer.valueOf(String)memang mengatakan bahwa Stringditafsirkan persis seolah-olah itu diberikan kepada Integer.parseInt(String). Namun, valueOf(String)mengembalikan objek sedangkan mengembalikan yang primitif .new Integer()parseInt(String)int

Jika Anda ingin menikmati manfaat caching potensial Integer.valueOf(int), Anda juga dapat menggunakan pemandangan buruk ini:

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

Sekarang, jika apa yang Anda inginkan adalah objek dan bukan primitif, kemudian menggunakan valueOf(String)mungkin lebih menarik daripada membuat objek baru dari parseInt(String)karena mantan adalah konsisten hadir di seluruh Integer, Long, Double, dll

Dari forum ini :

parseInt()mengembalikan tipe integer primitif ( int ), di mana valueOfmengembalikan java.lang.Integer , yang merupakan objek perwakilan dari integer. Ada beberapa situasi di mana Anda mungkin menginginkan objek Integer, bukan tipe primitif.

Tentu saja, perbedaan jelas lainnya adalah bahwa intValue adalah metode instance dimana parseInt adalah metode statis.

Integer.valueOf(s)

mirip dengan

new Integer(Integer.parseInt(s))

Perbedaannya adalah valueOf()mengembalikan sebuah Integer, dan parseInt()mengembalikan sebuah int(tipe primitif). Perhatikan juga bahwa valueOf()dapat mengembalikan Integerinstance yang di- cache , yang dapat menyebabkan hasil membingungkan di mana hasil ==tes tampaknya sesekali benar. Sebelum melakukan autoboxing mungkin ada perbedaan dalam kenyamanan, setelah java 1.5 tidak masalah.

Selain itu, Integer.parseInt(s)dapat mengambil tipe data primitif juga.

Lihatlah sumber-sumber Java: valueOfsedang menggunakan 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 kembali 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 bisa mengembalikan int sebagai tipe asli.

Integer.valueOf mungkin benar-benar perlu mengalokasikan objek Integer, kecuali jika integer tersebut merupakan salah satu yang sudah dialokasikan sebelumnya. Ini lebih mahal.

Jika Anda hanya perlu tipe asli, gunakan parseInt. Jika Anda membutuhkan objek, gunakan valueOf.

Juga, karena alokasi potensial ini, autoboxing sebenarnya bukan hal yang baik dalam segala hal. Itu bisa memperlambat segalanya.

Variasi parse * mengembalikan tipe primitif dan versi valueOf mengembalikan Objek. Saya percaya versi valueOf juga akan menggunakan kumpulan referensi internal untuk mengembalikan objek SAMA untuk nilai yang diberikan, bukan hanya contoh lain dengan nilai internal yang sama.

Karena Anda mungkin menggunakan jdk1.5 + dan itu otomatis dikonversi ke int. Jadi dalam kode Anda Integer pengembalian pertama dan kemudian otomatis dikonversi ke int.

kode Anda sama dengan

int abc = new Integer(123);

Jika Anda memeriksa kelas Integer Anda akan menemukan nilai metode parseInt panggilan itu. Perbedaan besar adalah caching ketika Anda memanggil value of API. Itu cache jika nilainya antara -128 hingga 127. Silakan temukan di bawah tautan untuk informasi lebih lanjut

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

public Integer valueOf (String s)

1. Argumen diinterpretasikan sebagai mewakili bilangan bulat desimal yang ditandatangani, persis seperti jika argumen diberikan kepada metode parseInt (java.lang.String).

2. Hasilnya adalah objek Integer yang mewakili nilai integer yang ditentukan oleh string.

3. Dengan kata lain, metode ini mengembalikan objek Integer yang sama dengan nilai: integer baru (Integer.parseInt (s))

• valueOf - mengkonversi ke kelas Wrapper
• parseInt - mengkonversi ke tipe primitif

Integer.parseInt hanya menerima String dan mengembalikan tipe integer primitif (int).

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

Iteger.value Jika menerima int dan String. Jika nilainya adalah String, valueOf mengubahnya menjadi int sederhana menggunakan parseInt dan mengembalikan Integer baru jika input kurang dari -128 atau lebih besar dari 127. Jika input dalam kisaran (-128 - 127) selalu mengembalikan objek Integer dari suatu IntegerCache internal. Kelas integer mempertahankan kelas IntegerCache statis dalam yang bertindak sebagai cache dan menyimpan objek integer dari -128 ke 127 dan itulah sebabnya ketika kami mencoba untuk mendapatkan objek integer untuk 127 (misalnya) kami selalu mendapatkan objek yang sama.

Iteger.valueOf(200)akan memberikan Integer baru dari 200. Rasanya new Integer(200) Iteger.valueOf(127)sama dengan Integer = 127;

Jika Anda tidak ingin mengkonversi String ke penggunaan Integer Iteger.valueOf.

Jika Anda tidak ingin mengkonversi String ke penggunaan int sederhana Integer.parseInt. Ini bekerja lebih cepat.

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

Dan membandingkan Integer.valueOf (127) == Integer.valueOf (127) mengembalikan nilai 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 

Karena itu dibutuhkan objek Integer dengan referensi yang sama dari cache.

Tetapi Integer.valueOf (128) == Integer.valueOf (128) salah, karena 128 berada di luar kisaran IntegerCache dan mengembalikan Integer baru, sehingga objek akan memiliki referensi yang berbeda.

1. Dalam kasus ValueOf -> itu menciptakan objek Integer. bukan tipe primitif dan bukan metode statis.
2. Dalam hal ParseInt.ParseFloat -> mengembalikan tipe primitif masing-masing. dan merupakan metode statis.

Kita harus menggunakan siapa saja tergantung pada kebutuhan kita. Dalam kasus ValueOf karena instantiasi objek. itu akan mengkonsumsi lebih banyak sumber daya jika kita hanya perlu nilai beberapa teks maka kita harus menggunakan parseInt, parseFloat dll.