Pertanyaan Perbedaan antara StringBuilder dan StringBuffer


Apa perbedaan utama antara StringBuffer dan StringBuilder? Apakah ada masalah kinerja ketika memutuskan salah satu dari ini?


1322
2017-12-10 04:34


asal


Jawaban:


StringBuffer disinkronkan, StringBuilder tidak.


1452
2017-12-10 04:36



StringBuilder lebih cepat daripada StringBuffer karena tidak synchronized.

Berikut ini adalah tes benchmark sederhana:

public class Main {
    public static void main(String[] args) {
        int N = 77777777;
        long t;

        {
            StringBuffer sb = new StringBuffer();
            t = System.currentTimeMillis();
            for (int i = N; i --> 0 ;) {
                sb.append("");
            }
            System.out.println(System.currentTimeMillis() - t);
        }

        {
            StringBuilder sb = new StringBuilder();
            t = System.currentTimeMillis();
            for (int i = N; i > 0 ; i--) {
                sb.append("");
            }
            System.out.println(System.currentTimeMillis() - t);
        }
    }
}

SEBUAH uji coba memberikan angka 2241 ms untuk StringBuffer vs 753 ms untuk StringBuilder.


664
2018-05-05 09:15



Pada dasarnya, StringBuffer metode disinkronkan sementara StringBuilder tidak.

Operasi "hampir" sama, tetapi menggunakan metode tersinkronisasi dalam satu utas adalah berlebihan.

Itu cukup banyak tentang itu.

Kutipan dari API StringBuilder:

Kelas ini [StringBuilder] menyediakan API yang kompatibel dengan StringBuffer, tetapi tanpa jaminan sinkronisasi. Kelas ini dirancang untuk digunakan sebagai pengganti drop-in untuk StringBuffer di tempat-tempat di mana string buffer sedang digunakan oleh satu thread (seperti umumnya terjadi). Jika memungkinkan, disarankan agar kelas ini digunakan dalam preferensi ke StringBuffer as itu akan lebih cepat di bawah sebagian besar implementasi.

Jadi itu dibuat untuk menggantikannya.

Hal yang sama terjadi pada Vector dan ArrayList.


228
2017-12-10 04:37



Tetapi diperlukan untuk mendapatkan perbedaan yang jelas dengan bantuan contoh?

StringBuffer atau StringBuilder

Cukup gunakan StringBuilder kecuali Anda benar-benar mencoba berbagi buffer antara utas. StringBuilder adalah adik yang tidak sinkron (lebih sedikit overhead = lebih efisien) dari yang asli disinkronkan StringBuffer kelas.


151
2018-01-25 12:30



Pertama mari kita lihat kesamaan: StringBuilder dan StringBuffer bisa berubah. Itu berarti Anda dapat mengubah kontennya, dengan di lokasi yang sama.

Perbedaan: StringBuffer bisa berubah dan disinkronkan juga. Di mana StringBuilder bisa berubah tetapi tidak disinkronisasi secara default.

Arti sinkronisasi (sinkronisasi): Ketika beberapa hal disinkronkan, maka beberapa utas dapat mengakses, dan memodifikasinya tanpa masalah atau efek samping apa pun. StringBuffer disinkronkan, sehingga Anda dapat menggunakannya dengan beberapa utas tanpa masalah apa pun.

Yang mana yang akan digunakan? StringBuilder: Saat Anda membutuhkan string, yang dapat dimodifikasi, dan hanya satu utas yang mengakses dan memodifikasinya. StringBuffer: Ketika Anda membutuhkan string, yang dapat dimodifikasi, dan beberapa utas mengakses dan memodifikasinya.

Catatan : Jangan gunakan StringBuffer yang tidak perlu, yaitu, jangan menggunakannya hanya jika satu thread memodifikasi dan mengaksesnya karena banyak penguncian dan membuka kunci kode untuk sinkronisasi yang tidak perlu menghabiskan waktu CPU. Jangan gunakan kunci kecuali jika diperlukan.


74
2017-12-11 07:11



Dalam satu utas, StringBuffer tidak lebih lambat dari StringBuilder, berkat optimisasi JVM. Dan dalam multithreading, Anda tidak dapat menggunakan StringBuilder dengan aman.

Ini tes saya:

public static void main(String[] args) {

    String withString ="";
    long t0 = System.currentTimeMillis();
    for (int i = 0 ; i < 100000; i++){
        withString+="some string";
    }
    System.out.println("strings:" + (System.currentTimeMillis() - t0));

    t0 = System.currentTimeMillis();
    StringBuffer buf = new StringBuffer();
    for (int i = 0 ; i < 100000; i++){
        buf.append("some string");
    }
    System.out.println("Buffers : "+(System.currentTimeMillis() - t0));

    t0 = System.currentTimeMillis();
    StringBuilder building = new StringBuilder();
    for (int i = 0 ; i < 100000; i++){
        building.append("some string");
    }
    System.out.println("Builder : "+(System.currentTimeMillis() - t0));
}

Hasil:
string: 319740
Buffer: 23
Builder: 7!

Jadi Pembangun lebih cepat daripada Buffer, dan CARA lebih cepat daripada penggabungan string. Sekarang mari gunakan Executor untuk beberapa utas:

public class StringsPerf {

    public static void main(String[] args) {

        ThreadPoolExecutor executorService = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
        //With Buffer
        StringBuffer buffer = new StringBuffer();
        for (int i = 0 ; i < 10; i++){
            executorService.execute(new AppendableRunnable(buffer));
        }
        shutdownAndAwaitTermination(executorService);
        System.out.println(" Thread Buffer : "+ AppendableRunnable.time);

        //With Builder
        AppendableRunnable.time = 0;
        executorService = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
        StringBuilder builder = new StringBuilder();
        for (int i = 0 ; i < 10; i++){
            executorService.execute(new AppendableRunnable(builder));
        }
        shutdownAndAwaitTermination(executorService);
        System.out.println(" Thread Builder: "+ AppendableRunnable.time);

    }

   static void shutdownAndAwaitTermination(ExecutorService pool) {
        pool.shutdown(); // code reduced from Official Javadoc for Executors
        try {
            if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
                pool.shutdownNow();
                if (!pool.awaitTermination(60, TimeUnit.SECONDS))
                    System.err.println("Pool did not terminate");
            }
        } catch (Exception e) {}
    }
}

class AppendableRunnable<T extends Appendable> implements Runnable {

    static long time = 0;
    T appendable;
    public AppendableRunnable(T appendable){
        this.appendable = appendable;
    }

    @Override
    public void run(){
        long t0 = System.currentTimeMillis();
        for (int j = 0 ; j < 10000 ; j++){
            try {
                appendable.append("some string");
            } catch (IOException e) {}
        }
        time+=(System.currentTimeMillis() - t0);
    }
}

Sekarang StringBuffers ambil 157 ms untuk 100000 menambahkan. Ini bukan tes yang sama, tetapi dibandingkan dengan 37 ms sebelumnya, Anda dapat mengasumsikannya dengan aman Menambahkan StringBuffers lebih lambat dengan penggunaan multithreading. Alasannya adalah bahwa JIT / hotspot / compiler / sesuatu membuat pengoptimalan ketika mendeteksi ada tidak perlu untuk memeriksa kunci.

Tapi dengan StringBuilder, Anda memiliki java.lang.ArrayIndexOutOfBoundsException, karena benang konkuren mencoba menambahkan sesuatu di mana seharusnya tidak.

Kesimpulannya adalah Anda tidak perlu mengejar StringBuffers. Dan di mana Anda memiliki benang, pikirkan apa yang mereka lakukan, sebelum mencoba mendapatkan beberapa nanodetik.


42
2017-11-15 16:20



StringBuilder diperkenalkan di Java 1.5 sehingga tidak akan berfungsi dengan JVM sebelumnya.

Dari Javadocs:

Kelas StringBuilder menyediakan API yang kompatibel dengan StringBuffer, tetapi tanpa jaminan sinkronisasi. Kelas ini dirancang untuk digunakan sebagai pengganti drop-in untuk StringBuffer di tempat-tempat di mana string buffer sedang digunakan oleh satu thread (seperti umumnya terjadi). Jika memungkinkan, disarankan agar kelas ini digunakan dalam preferensi untuk StringBuffer karena akan lebih cepat di bawah sebagian besar implementasi.


37
2017-12-10 04:38



Pertanyaan yang Cukup Bagus

Berikut perbedaannya, saya perhatikan:

StringBuffer: -

StringBuffer is  synchronized
StringBuffer is  thread-safe
StringBuffer is  slow (try to write a sample program and execute it, it will take more time than StringBuilder)

StringBuilder: -

 StringBuilder is not synchronized 
 StringBuilder is not thread-safe
 StringBuilder performance is better than StringBuffer.

Hal yang biasa :-

Keduanya memiliki metode yang sama dengan tanda tangan yang sama. Keduanya bisa berubah.


33
2018-04-11 20:25



StringBuilder tidak aman. String Buffer adalah. Info lebih lanjut sini.

EDIT: Adapun kinerja, setelah hotspot tendangan masuk, StringBuilder adalah pemenangnya. Namun, untuk iterasi kecil, perbedaan kinerja dapat diabaikan.


19
2017-12-10 04:41



StringBuilder dan StringBuffer hampir sama. Perbedaannya adalah itu StringBuffer disinkronkan dan StringBuilder tidak. Meskipun, StringBuilder lebih cepat daripada StringBuffer, perbedaan dalam kinerjanya sangat sedikit. StringBuilder adalah pengganti SUN StringBuffer. Itu hanya menghindari sinkronisasi dari semua metode publik. Daripada itu, fungsi mereka sama.

Contoh penggunaan yang baik:

Jika teks Anda akan berubah dan digunakan oleh beberapa utas, maka lebih baik digunakan StringBuffer. Jika teks Anda akan berubah tetapi digunakan oleh satu utas, kemudian gunakan StringBuilder.


19
2017-12-03 06:38



StringBuffer

StringBuffer bisa berubah berarti seseorang dapat mengubah nilai objek. Objek yang dibuat melalui StringBuffer disimpan di heap. StringBuffer memiliki metode yang sama dengan StringBuilder, tetapi setiap metode dalam StringBuffer disinkronkan yaitu StringBuffer adalah thread safe.

karena ini tidak memungkinkan dua utas untuk mengakses metode yang sama secara bersamaan. Setiap metode dapat diakses oleh satu utas sekaligus.

Tetapi menjadi thread safe juga memiliki kelemahan karena kinerja StringBuffer karena properti thread safe. Jadi StringBuilder lebih cepat daripada StringBuffer ketika memanggil metode yang sama untuk setiap kelas.

Nilai StringBuffer dapat diubah, artinya dapat ditetapkan ke nilai baru. Saat ini pertanyaan wawancara yang paling umum, perbedaan antara kelas-kelas di atas. String Buffer dapat dikonversi ke string dengan menggunakan toString () metode.

StringBuffer demo1 = new StringBuffer(“Hello”) ;
// The above object stored in heap and its value can be changed .

demo1=new StringBuffer(“Bye”);
// Above statement is right as it modifies the value which is allowed in the StringBuffer

StringBuilder

StringBuilder sama dengan StringBuffer, yaitu menyimpan objek di heap dan itu juga dapat dimodifikasi. Perbedaan utama antara StringBuffer dan StringBuilder adalah bahwa StringBuilder juga tidak aman. StringBuilder cepat karena tidak aman.

StringBuilder demo2= new StringBuilder(“Hello”);
// The above object too is stored in the heap and its value can be modified

demo2=new StringBuilder(“Bye”);
// Above statement is right as it modifies the value which is allowed in the StringBuilder

enter image description here

Sumber: String Vs StringBuffer Vs StringBuilder


18
2017-09-20 17:40