Integer.toString (int i) vs String.valueOf (int i)

Saya bertanya-tanya mengapa metode ini String.valueOf(int i)ada? Saya menggunakan metode ini untuk mengkonversi intmenjadi Stringdan baru saja menemukan Integer.toString(int i)metode ini.

Setelah melihat implementasi dari metode ini saya melihat bahwa yang pertama memanggil yang kedua. Sebagai akibatnya, semua panggilan saya String.valueOf(int i)melibatkan satu panggilan lebih banyak daripada panggilan langsungInteger.toString(int i)

Hanya dua cara berbeda untuk melakukan hal yang sama. Ini mungkin merupakan alasan historis (tidak dapat mengingat jika ada yang datang sebelum yang lain).

Dalam tipe String kami memiliki beberapa metode valueOf

static String   valueOf(boolean b) 
static String   valueOf(char c) 
static String   valueOf(char[] data) 
static String   valueOf(char[] data, int offset, int count) 
static String   valueOf(double d) 
static String   valueOf(float f) 
static String   valueOf(int i) 
static String   valueOf(long l) 
static String   valueOf(Object obj) 

Seperti yang dapat kita lihat, metode tersebut mampu menyelesaikan semua jenis angka

setiap implementasi metode spesifik seperti yang Anda sajikan: Jadi untuk bilangan bulat yang kami miliki

Integer.toString(int i)

untuk dobel

Double.toString(double d)

dan seterusnya

Menurut pendapat saya ini bukan hal historis, tetapi lebih berguna bagi pengembang untuk menggunakan metode valueOfdari kelas String daripada dari jenis yang tepat, karena mengarah ke lebih sedikit perubahan bagi kita untuk membuat.

Sampel 1:

public String doStuff(int num) {

  // Do something with num...

  return String.valueOf(num);

 }

Contoh2:

public String doStuff(int num) {

 // Do something with num...

 return Integer.toString(num);

 }

Seperti yang kita lihat dalam sampel 2 kita harus melakukan dua perubahan, berlawanan dengan sampel satu.

Dalam kesimpulan saya, menggunakan valueOfmetode dari kelas String lebih fleksibel dan itu sebabnya tersedia di sana.

Satu perbedaan besar adalah bahwa jika Anda memanggil toString()objek nol Anda akan mendapatkan NullPointerExceptionsementara, menggunakan String.valueOf()Anda tidak dapat memeriksa null.

Kelas String menyediakan metode valueOf untuk semua tipe primitif dan tipe objek jadi saya menganggap mereka adalah metode praktis yang semuanya dapat diakses melalui satu kelas.

Hasil NB Profiling

Rata-rata intToString = 5368ms, Rata-rata stringValueOf = 5689ms (untuk 100.000.000 operasi)

public class StringIntTest {


    public static long intToString () {
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            String j = Integer.toString(i);
        }
        long finishTime = System.currentTimeMillis();

        return finishTime - startTime;
    }

    public static long stringValueOf () {

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            String j = String.valueOf(i);
        }
        long finishTime = System.currentTimeMillis();

        return finishTime - startTime;
    }

    public static void main(String[] args) {
        long intToStringElapsed = 0;
        long stringValueOfElapsed = 0;
        for (int i = 0; i < 10; i++) {
            intToStringElapsed += intToString();
            stringValueOfElapsed+= stringValueOf();
        }
        System.out.println("Average intToString = "+ (intToStringElapsed /10));
        System.out.println("Average stringValueOf = " +(stringValueOfElapsed / 10));
    }
}

Dari sumber Java:

/**
 * Returns the string representation of the {@code int} argument.
 * <p>
 * The representation is exactly the one returned by the
 * {@code Integer.toString} method of one argument.
 *
 * @param   i   an {@code int}.
 * @return  a string representation of the {@code int} argument.
 * @see     java.lang.Integer#toString(int, int)
 */
public static String valueOf(int i) {
    return Integer.toString(i);
}

Jadi mereka memberikan hasil yang persis sama dan satu sebenarnya memanggil yang lain. String.valueOf lebih fleksibel jika Anda dapat mengubah jenisnya nanti.

Jika Anda melihat kode sumber untuk Stringkelas, itu sebenarnya memanggil Integer.toString()saat Anda meneleponvalueOf() .

Yang sedang berkata, Integer.toString()mungkin sedikit lebih cepat jika pemanggilan metode tidak dioptimalkan pada waktu kompilasi (yang mungkin).

Implementasi String.valueOf()yang Anda lihat adalah cara paling sederhana untuk memenuhi kontrak yang ditentukan dalam API: "Representasi persis yang dikembalikan oleh Integer.toString()metode satu argumen."

Untuk menjawab pertanyaan OP, itu hanya pembungkus pembantu untuk memiliki panggilan lain, dan turun ke pilihan gaya dan hanya itu. Saya pikir ada banyak informasi yang salah di sini dan hal terbaik yang dapat dilakukan oleh pengembang Java adalah melihat implementasi untuk setiap metode, itu satu atau dua klik saja dalam IDE. Anda akan melihat dengan jelas bahwa String.valueOf(int)itu hanya panggilanInteger.toString(int) Anda.

Oleh karena itu, sama sekali tidak ada perbedaan, di mana mereka berdua membuat buffer char, berjalan melalui angka-angka dalam angka, kemudian menyalinnya ke dalam String baru dan mengembalikannya (oleh karena itu masing-masing membuat satu objek String). Satu-satunya perbedaan adalah satu panggilan tambahan, yang dihilangkan oleh kompiler menjadi satu panggilan.

Jadi yang penting bukan yang Anda panggil, selain mungkin konsistensi kode. Mengenai komentar tentang null, dibutuhkan primitif, oleh karena itu tidak boleh nol! Anda akan mendapatkan kesalahan waktu kompilasi jika Anda tidak menginisialisasi int yang diteruskan. Jadi tidak ada perbedaan dalam cara menangani null karena tidak ada dalam kasus ini.

Anda tidak perlu khawatir tentang panggilan ekstra ini sehingga menimbulkan masalah efisiensi. Jika ada biaya, itu akan minimal, dan harus diabaikan dalam gambaran yang lebih besar.

Mungkin alasan mengapa keduanya ada adalah untuk menawarkan keterbacaan. Dalam konteks banyak jenis yang dikonversi String, maka berbagai panggilan ke String.valueOf(SomeType)mungkin lebih mudah dibaca daripada berbagai SomeType.toStringpanggilan.

openion saya adalah valueof () selalu disebut tostring () untuk representasi dan juga untuk representasi dari tipe primtive valueof digeneralisasi. dan java secara default tidak mendukung tipe data tetapi mendefinisikan pekerjaannya dengan objaect dan kelas itu membuat semuanya dalam kllas dan dibuat objek .di sini Integer.toString (int i) membuat batas konversi hanya untuk integer.

Tidak ada perbedaan antara Integer.toString (5) dan String.valueOf (5);

karena String.valueOf kembali:

public static String valueOf(int i) {
    return Integer.toString(i);
}
public static String valueOf(float f) {
    return Float.toString(f);
}

dll ..

Dengan menggunakan metode ini, String.valueOf () Anda tidak perlu khawatir tentang data (apakah itu int, long, char, char [], boolean, Object), Anda dapat menghubungi:

• nilai String statisOf ()

menggunakan satu-satunya sintaks String.valueOf () dapat apa pun yang Anda berikan sebagai parameter dikonversi ke String dan dikembalikan ..

Jika tidak, jika Anda menggunakan Integer.toString (), Float.toString () dll. (Mis. SomeType.toString ()) maka Anda harus memeriksa datatype parameter yang ingin dikonversi menjadi string. Jadi, lebih baik menggunakan String.valueOf () untuk konversi semacam itu.

Jika Anda memiliki array kelas objek yang berisi nilai-nilai yang berbeda seperti Integer, Char, Float dll. Kemudian dengan menggunakan metode String.valueOf () Anda dapat mengkonversi elemen-elemen array tersebut menjadi bentuk String dengan mudah. Sebaliknya, jika Anda ingin menggunakan SomeType.toString () maka pada awalnya Anda perlu tahu tentang ada kelas datatype mereka (mungkin dengan menggunakan operator "instanceOf") dan kemudian hanya Anda yang dapat melanjutkan untuk typecast.

Metode String.valueOf () ketika dipanggil cocok dengan parameter yang dilewati (apakah itu Integer, Char, Float dll.) Dan dengan menggunakan metode overload panggilan metode "valueOf ()" yang parameternya dicocokkan, dan kemudian di dalam metode itu adalah panggilan langsung ke metode "toString ()" yang sesuai ..

Jadi, kita dapat melihat bagaimana overhead memeriksa datatype dan kemudian memanggil metode "toString ()" yang sesuai dihapus. Hanya kita perlu memanggil metode String.valueOf (), tidak peduli tentang apa yang ingin kita konversi ke String.

Kesimpulan: Metode String.valueOf () memiliki kepentingannya hanya dengan biaya satu panggilan lagi.

toString ()

1. hadir di kelas Objek, umumnya ditimpa dalam kelas turunan
2. typecast ke kelas yang sesuai diperlukan untuk memanggil metode toString ().

Nilai dari()

1. Metode statis kelebihan beban hadir dalam kelas String.

2. menangani tipe primitif serta tipe objek.

   Integer a = null;
   System.out.println(Integer.toString()) ; NUll pointer exception
   System.out.println(String.valueOf() ; give NULL as value

periksa tautan ini sangat bagus. http://code4reference.com/2013/06/which-one-is-better-valueof-or-tostring/