Kaedah Append() dalam Java: StringBuilder dan StringBuffer

append() ialah kaedah Java bagi kelas StringBuilder dan StringBuffer yang menambahkan beberapa nilai pada jujukan semasa. Walaupun anda tidak tahu apa itu kaedah append() , anda mungkin sudah menggunakannya secara tersirat. Ini berlaku apabila anda menggabungkan Strings dalam Java menggunakan operator +. Intinya ialah penggabungan String dalam Java dilaksanakan menggunakan kelas StringBuilder atau StringBuffer dan kaedah append() mereka .

Secara ringkas tentang String, StringBuffer dan StringBuilder

Seperti yang anda ketahui, kelas String adalah muktamad (ia tidak mempunyai kelas anak) dan tidak boleh diubah (contoh kelas ini tidak boleh diubah suai selepas penciptaan). Malah, disebabkan oleh ketidakbolehubahan kelas String, contoh rentetan baharu dicipta hasil daripada setiap operasi, dan yang lama dibuang, menghasilkan banyak sampah. Untuk menangani penjanaan sampah sementara akibat pengubahsuaian pada objek String, anda boleh menggunakan kelas StringBuffer atau StringBuilder. Perbezaan utama antara dua yang terakhir ialah StringBuffer disegerakkan manakala StringBuilder tidak. Oleh itu, gunakan StringBuffer untuk rentetan yang akan kerap diubah suai dalam persekitaran berbilang benang dan StringBuilder dalam kes persekitaran berulir tunggal.

Append() dalam StringBuilder dan StringBuffer

append() ialah salah satu kaedah teratas kelas StringBuilder dan StringBuffer. Ia menambahkan nilai baharu pada jujukan semasa. Terdapat 13 pelbagai kaedah append() terbeban dalam kedua-dua kelas StringBuffer dan StringBuilder. Mari lihat kaedah tambah untuk StringBuilder. Bagaimanapun, ia berfungsi sama dalam kes StringBuffer.

• tambah StringBuilder awam(boolean b)
• tambahkan StringBuilder awam(char c)
• tambah StringBuilder awam(char[] str)
• tambah StringBuilder awam(char[] str, int offset, int len)
• tambah StringBuilder awam(CharSequence cs)
• tambahkan StringBuilder awam(CharSequence cs, int start, int end)
• tambah StringBuilder awam (dua kali d)
• tambah StringBuilder awam(float f)
• tambahkan StringBuilder awam(int i)
• tambah StringBuilder awam (long lng)
• tambah StringBuilder awam (obj objek)
• tambah StringBuilder awam(String str)
• tambah StringBuilder awam(StringBuffer sb)

Mari kita semak beberapa daripadanya dan terangkan dengan contoh apa sebenarnya yang dilakukan oleh kaedah append() .

Java.lang.StringBuilder.append(int i)

java.lang.StringBuilder.append(int i) ialah kaedah yang membenarkan penambahan integer pada objek StringBuilder sedia ada. Mari kita lihat contoh penggunaan Java.lang.StringBuilder.append(int i) :

StringBuilder s = new StringBuilder(“I love Java ”);
int i = 14;
//the method appends StringBuilder and integer
s.append(i);
System.out.println(s);

Output di sini ialah: Apa yang berlaku di sini? Pertama, kami mencipta StringBuilder bernama s dengan nilai "Saya suka Java". Kemudian tambahkan padanya integer 14 menggunakan append(int) . Tegasnya, kami tidak menambah integer, tetapi rentetan "14" dan mendapat nilai StringBuilder yang dikemas kini kepada "Saya suka Java 14". Oleh itu, kaedah menukar hujah menjadi objek StringBuilder, mengikatnya pada objek StringBuilder sedia ada dan mengembalikan yang dikemas kini.

StringBuilder append() contoh untuk Object, int, boolean dan argumen String

Kisah yang sama akan berlaku dengan semua kaedah terlampau beban lain dengan elemen nombor, rentetan, aksara atau tatasusunan. Mari kita cipta Kelas LegoBrick dan enum Warna untuk menunjukkan kaedah tambahan StringBuilder awam (Object obj) .

//enum with colors
 public enum Color {
   RED, YELLOW, BLUE;
}
//LegoBrick Class code
public class LegoBrick {
   Color color;
   boolean isConnected;

   public void connect() {
       System.out.println("This brick is connected");
       this.isConnected = true;
   }

   public void disconnect() {
       System.out.println("Disconnected");
       isConnected = false;
   }

   public LegoBrick(Color color, boolean isConnected) {
       this.color = color;
       this.isConnected = isConnected;
   }

   public Color getColor() {
       return color;
   }

   public boolean isConnected() {
       return isConnected;
   }

   @Override
   public String toString() {
       return "LegoBrick{" +
              "color=" + color +
              ", isConnected=" + isConnected +
              '}';
   }
}

Sekarang mari kita cipta Kelas AppendDemo di mana kita akan menunjukkan penambahan StringBuilder asas dengan String, int, LegoBrick dan boolean. Bunyi pelik, tetapi ia berkesan!

public class AppendDemo {

   public static void main(String[] args) {
       StringBuilder s = new StringBuilder("I love");
System.out.println(s)
//the method appends StringBuilder and String
       s.append(" Java");
       System.out.println(s);
//the method appends StringBuilder and int
       s.append(14);
       System.out.println(s);
       LegoBrick legoBrick = new LegoBrick(Color.RED, false);
//the method appends StringBuilder and LegoBrick
       s.append(legoBrick);
       System.out.println(s);
//the method appends StringBuilder and boolean
       System.out.println(s.append(5<7));
   }
}

Outputnya ialah: Mula-mula, kami mencipta dan memaparkan StringBuilder "Saya suka", kemudian Pertama, membasahkan secara berurutan ditambah kepadanya menggunakan kaedah append() String, nombor int, perwakilan String Objek dan boolean.

StringBuilder append(char[] cstr, set int, panjang int)

Mari lihat kaedah append() dengan tiga parameter. Ia menambah perwakilan subarray bagi tatasusunan aksara yang diberikan kepada rentetan. Jadi disini:

• cstr ialah susunan aksara untuk dilampirkan
• tetapkan indeks bagi aksara pertama yang akan ditambahkan
• panjang ialah kuantiti aksara untuk ditambahkan.

Begitu juga dengan kaedah append() yang lain , kaedah ini mengembalikan objek StringBuilder yang diperluaskan. Berikut ialah contoh menggunakan append(char[], cstr, int set, int length) sebagai sebahagian daripada kod aplikasi Java.

public class AppendDemo {
   // an example of using append(char[], cStr, int set, int length)

   public static void main(String[] args) {
       StringBuilder s = new StringBuilder("I love ");
      //here is a char's array, part of which we are going to append to s
       char[] cStr = new char[]
               {'c', 'o', 'd', 'e', 'J', 'a', 'v', 'a', '1', '4'};
       //we append 4 elements of cStr from the 4th element "J"
       s.append(cStr, 4, 4);
       System.out.println(s);
   }
}

Outputnya ialah:

StringBuilder append() kaedah dengan argumen CharSequence

Anda mungkin perasan dua kaedah yang mempunyai CharSequence sebagai hujahnya.

• tambah StringBuilder awam(CharSequence cs)
• tambahkan StringBuilder awam(CharSequence cs, int start, int end)

Tidak semua pemula tahu bahawa CharSequence ialah Antara Muka. Menurut dokumentasi CharSequence ialah jujukan nilai aksara yang boleh dibaca dan menyediakan akses baca sahaja yang seragam kepada pelbagai jenis jujukan aksara yang berbeza. Antara muka dilaksanakan oleh Kelas Java seperti String, StringBuffer, StringBuilder dan banyak lagi. Jadi jika anda tidak tahu apa yang lebih baik untuk digunakan dalam program anda, String, StringBuffer atau StringBuilder anda boleh menggunakan CharSequence. StringBuilder append(CharSequence cs, int start, int end) berfungsi hampir seperti append(char[] cstr, int set, int length)kita bincangkan di atas. Walau bagaimanapun, kaedah ini menentukan elemen pertama bagi yang berikutnya dan yang terakhir. Adalah penting untuk diingat bahawa permulaan termasuk dalam urutan, tetapi akhir tidak (iaitu, elemen terakhir dalam urutan adalah elemen yang datang sebelum akhir). Kenapa begitu? Ia seperti yang berlaku di Jawa. Mari kita tunjukkan apa itu CharSequence dan kaedah tambah(CharSequence cs) dan tambah(CharSequence cs, int start, int end) .

public class CharSequenceDemo {

   public static void printCharSequence(CharSequence ch) {
       System.out.println(ch);
   }
       public static void main(String[] args) {
           CharSequence myString = new String("This is String ");
           printCharSequence(myString);
           CharSequence myStringBuilder = new StringBuilder("This is StringBuilder ");
           printCharSequence(myStringBuilder);
           StringBuilder s = new StringBuilder("my StringBuilder ");
//StringBuilder.append
s.append(myStringBuilder);
           System.out.println(s);
//StringBuilder.append
           s.append(myString);
           System.out.println(s);
           s.append(myString, 5,7);
           System.out.println(s);
       }
   }

Outputnya ialah: Kami mencipta dua CharSequences, mengikat String dan StringBuilder kepada mereka dan mencetaknya. Kami tidak boleh menggunakan kaedah append() terus ke myStringBuilder, kerana CharSequence tidak mempunyai kaedah ini (jika anda tidak faham mengapa, anda perlu memikirkan tentang warisan serta mengembangkan dan menyempitkan jenis rujukan). Oleh itu, kami mencipta StringBuilder dengan dan menggabungkan menggunakan kaedah tambah secara berurutan dengan kedua-dua CharSequence. Pada penghujungnya kami menambahkan StringBuilder kami dengan urutan "is" ("i" ialah elemen ke-5 myStringBuilder dan s ialah yang ke-6. Ingat bahawa dalam kaedah, elemen yang dinyatakan sebagai akhir dikecualikan daripada urutan.

Bagaimana pula dengan StringBuffer append()?

StringBuffer.append juga mempunyai 13 varian kaedah dan ia berfungsi dengan cara yang sama seperti StringBuilder.

• tambah StringBuffer awam (boolean b)
• tambah StringBuffer awam(char c)
• tambah StringBuffer awam(char[] str)
• tambah StringBuffer awam(char[] str, int offset, int len)
• tambahan StringBuffer awam (dua kali d)
• tambahan StringBuffer awam (float f)
• lampiran StringBuffer awam(int i)
• tambah StringBuffer awam (long panjang)
• tambahan StringBuffer awam (CharSequence s)
• tambah StringBuffer awam (CharSequence s, int start, int end)
• tambah StringBuffer awam (obj objek)
• tambah StringBuffer awam (String str)
• tambah StringBuffer awam (StringBuffer sb)

Mari kita dapatkan contoh StringBuffer.append untuk menyertai subrentetan. Kami hanya mengambil contoh StringBuilder dan menukar semua StringBuilders dalam kod kepada StringBuffers.

public class AppendDemo {
   // an example of using append(char[], cStr, int set, int length)

   public static void main(String[] args) {
       StringBuffer s = new StringBuffer("I love ");
      //here is a char's array, part of which we are going to append to s
       char[] cStr = new char[]
               {'c', 'o', 'd', 'e', 'J', 'a', 'v', 'a', '1', '4'};
       //we append 4 elements of cStr from the 4th element "J"
//with StringBuffer.append
       s.append(cStr, 4, 4);
       System.out.println(s);
//StringBuffer.append adds int 14 to s
s.append(14);
System.out.println(s);
   }
}

Outputnya ialah: Anda boleh melakukannya dengan setiap contoh artikel ini. Mereka akan bekerja!

Kesimpulan

Memandangkan StringBuilder dan StringBuffer berkongsi kebanyakan fungsi, tidak hairanlah bahawa kedua-dua kelas mempunyai cara yang sama untuk menggunakan kaedah append() . Itu berita baik untuk pembangun — anda tidak perlu mempelajari kaedah berasingan untuk setiap kelas. Setelah berkata demikian, mempertimbangkan kepelbagaian cara untuk menggunakan append() , pastikan anda melakukan beberapa jam berlatih menambah perwakilan jenis data yang berbeza pada rentetan.