Append() Method sa Java: StringBuilder at StringBuffer

append() ay isang Java method ng StringBuilder at StringBuffer na mga klase na nagdaragdag ng ilang value sa isang kasalukuyang sequence. Kahit na hindi mo alam kung ano ang append() na paraan, malamang na ginamit mo na ito nang payak. Nangyari ito noong pinagsama mo ang Strings sa Java gamit ang + operator. Ang punto ay ang String concatenation sa Java ay ipinatupad gamit ang StringBuilder o StringBuffer class at ang kanilang append() na pamamaraan.

Napakaikli tungkol sa String, StringBuffer at StringBuilder

Tulad ng alam mo na ang String class ay pangwakas (wala itong mga child class) at hindi nababago (mga pagkakataon ng klase na ito ay hindi mababago pagkatapos ng paglikha). Sa katunayan, dahil sa immutability ng String class, ang mga bagong string instance ay nilikha bilang resulta ng bawat operasyon, at ang mga luma ay itinatapon, na bumubuo ng maraming basura. Upang harapin ang pagbuo ng pansamantalang basura dahil sa mga pagbabago sa String object, maaari mong gamitin ang mga klase ng StringBuffer o StringBuilder. Ang pangunahing pagkakaiba sa pagitan ng huling dalawa ay ang StringBuffer ay Naka-synchronize habang ang StringBuilder ay hindi. Samakatuwid, gamitin ang StringBuffer para sa mga string na madalas na babaguhin sa isang multi-threaded na kapaligiran at StringBuilder sa kaso ng isang single-threaded na kapaligiran.

Append() sa StringBuilder at StringBuffer

append() ay isa sa mga nangungunang pamamaraan ng StringBuilder at StringBuffer na mga klase. Nagdaragdag ito ng bagong halaga sa kasalukuyang sequence. Mayroong 13 iba't ibang overloaded append() na pamamaraan sa parehong StringBuffer at StringBuilder na mga klase. Tingnan natin ang paraan ng append para sa StringBuilder. Gayon pa man, pareho silang gumagana sa kaso ng StringBuffer.

• pampublikong StringBuilder append(boolean b)
• pampublikong StringBuilder append(char c)
• pampublikong StringBuilder append(char[] str)
• pampublikong StringBuilder append(char[] str, int offset, int len)
• pampublikong StringBuilder append(CharSequence cs)
• pampublikong StringBuilder append(CharSequence cs, int start, int end)
• pampublikong StringBuilder append(double d)
• pampublikong StringBuilder append(float f)
• pampublikong StringBuilder append(int i)
• pampublikong StringBuilder append(mahaba lng)
• pampublikong StringBuilder append(Object obj)
• pampublikong StringBuilder append(String str)
• pampublikong StringBuilder append(StringBuffer sb)

Suriin natin ang ilan sa mga ito at ipaliwanag kasama ng mga halimbawa kung ano ang eksaktong ginagawa ng paraan ng append() .

Java.lang.StringBuilder.append(int i)

Ang java.lang.StringBuilder.append(int i) ay isang paraan na nagbibigay-daan sa pagdaragdag ng integer sa isang umiiral na object ng StringBuilder. Tingnan natin ang mga halimbawa ng paggamit ng 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);

Ang magiging output dito ay: Anong nangyari dito? Una, gumawa kami ng StringBuilder na pinangalanang s na may halagang "I love Java". Pagkatapos ay idinagdag dito ang isang integer 14 gamit ang append(int) . Sa mahigpit na pagsasalita, hindi kami nagdagdag ng isang integer, ngunit ang string na "14" at nakakuha ng na-update na StringBuilder na halaga sa "Mahal ko ang Java 14". Kaya, ginagawang StringBuilder object ng pamamaraan ang argumento, ibinubukod ito sa isang umiiral nang StringBuilder object, at ibinabalik ang na-update.

StringBuilder append() halimbawa para sa Object, int, boolean at String argument

Ang parehong kuwento ay magiging sa lahat ng iba pang mga overloaded na pamamaraan na may mga elemento ng numero, string, char o arrays. Gumawa tayo ng LegoBrick Class at Color enum para ipakita ang pampublikong StringBuilder append(Object obj) na paraan.

//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 +
              '}';
   }
}

Ngayon, gumawa tayo ng AppendDemo Class kung saan magpapakita tayo ng appending ng isang basic StringBuilder na may String, int, LegoBrick at boolean. Kakaiba ang tunog, ngunit gumagana ito!

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));
   }
}

Ang output ay: Una, ginawa at ipinakita namin ang StringBuilder na "I love", pagkatapos ay Una, wethen sunud-sunod na idinagdag dito gamit ang append() method na isang String, isang int number, isang String na representasyon ng isang Object at isang boolean.

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

Tingnan natin ang paraan ng append() na may tatlong parameter. Nagdaragdag ito ng representasyon ng isang subarray ng isang ibinigay na char array sa string. Kaya eto:

• Ang cstr ay isang hanay ng mga character na idaragdag
• itakda ito ng index ng unang character na isasama
• ang haba ay ang dami ng mga character na idaragdag.

Katulad ng iba pang mga paraan ng append() , ang isang ito ay nagbabalik ng pinalawak na StringBuilder object. Narito ang isang halimbawa ng paggamit ng append(char[], cstr, int set, int length) bilang bahagi ng Java app code.

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);
   }
}

Ang output ay:

StringBuilder append() na mga pamamaraan na may argumentong CharSequence

Maaaring napansin mo ang dalawang pamamaraan na mayroong CharSequence bilang kanilang mga argumento.

• pampublikong StringBuilder append(CharSequence cs)
• pampublikong StringBuilder append(CharSequence cs, int start, int end)

Hindi alam ng lahat ng nagsisimula na ang CharSequence ay isang Interface. Ayon sa dokumentasyon , ang CharSequence ay isang nababasang pagkakasunud-sunod ng mga halaga ng char at nagbibigay ng pare-pareho, read-only na access sa maraming iba't ibang uri ng char sequences. Ang interface ay ipinapatupad ng mga Java Classes gaya ng String, StringBuffer, StringBuilder at higit pa. Kaya kung hindi mo alam kung ano ang mas mahusay na gamitin sa iyong programa, String, StringBuffer o StringBuilder maaari mong gamitin ang CharSequence. Ang StringBuilder append(CharSequence cs, int start, int end) ay gumagana halos gaya ng append(char[] cstr, int set, int length)napag-usapan natin sa itaas. Gayunpaman, ang pamamaraang ito ay tumutukoy sa unang elemento ng kasunod at ang huli. Mahalagang tandaan na ang simula ay kasama sa kasunod, ngunit ang pagtatapos ay hindi (iyon ay, ang huling elemento sa kasunod ay ang elemento na nauuna bago ang katapusan). Bakit ganon? Ganito lang talaga sa Java. Ipakita natin kung ano ang CharSequence at mga paraan ng append(CharSequence cs) at append(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);
       }
   }

Ang output ay: Gumawa kami ng dalawang CharSequences, pinagtali ang String at StringBuilder sa kanila at na-print ang mga ito. Hindi namin mailalapat ang paraan ng append() nang direkta sa myStringBuilder, dahil walang ganitong paraan ang CharSequence (kung hindi mo maintindihan kung bakit, kailangan mong malaman ang tungkol sa pamana pati na rin ang pagpapalawak at pagpapaliit ng mga uri ng sanggunian). Samakatuwid, lumikha kami ng isang StringBuilder na may at pinagsama-sama gamit ang paraan ng pagdugtong nang sunud-sunod sa parehong CharSequence. Sa dulo, idinagdag namin ang aming StringBuilder na may kasunod na “ay” (“i” ay isang ika-5 elemento ng myStringBuilder at s ay ang ika-6. Tandaan na sa pamamaraan, ang elementong tinukoy bilang dulo ay hindi kasama sa kasunod.

Paano ang StringBuffer append()?

Ang StringBuffer.append ay mayroon ding 13 variant ng pamamaraan at gumagana ang mga ito sa parehong paraan tulad ng StringBuilder.

• pampublikong StringBuffer append(boolean b)
• pampublikong StringBuffer append(char c)
• pampublikong StringBuffer append(char[] str)
• pampublikong StringBuffer append(char[] str, int offset, int len)
• pampublikong StringBuffer append(double d)
• pampublikong StringBuffer append(float f)
• pampublikong StringBuffer append(int i)
• pampublikong StringBuffer append​(mahaba lng)
• pampublikong StringBuffer append(CharSequence s)
• pampublikong StringBuffer append(CharSequence s, int start, int end)
• pampublikong StringBuffer append (Object obj)
• pampublikong StringBuffer append(String str)
• pampublikong StringBuffer append(StringBuffer sb)

Magkaroon tayo ng halimbawa ng StringBuffer.append upang sumali sa isang substring. Kinukuha lang namin ang halimbawa ng StringBuilder at binago ang lahat ng StringBuilder sa code sa 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);
   }
}

Ang output ay: Magagawa mo ito sa bawat halimbawa ng artikulong ito. Magtatrabaho sila!

Konklusyon

Dahil ang StringBuilder at StringBuffer ay nagbabahagi ng karamihan sa mga function, hindi nakakagulat na ang parehong mga klase ay may magkatulad na paraan upang magamit ang append() na paraan. Magandang balita iyon para sa mga developer — hindi mo kailangang matuto ng magkakahiwalay na pamamaraan para sa bawat klase. Sa pagsasabing, kung isasaalang-alang ang iba't ibang paraan ng paggamit append() , tiyaking magsagawa ng ilang oras ng pagsasanay sa pagdaragdag ng mga representasyon ng iba't ibang uri ng data sa isang string.