Append()-metode i Java: StringBuilder og StringBuffer

append() er en Java-metode for StringBuilder- og StringBuffer-klasser som legger til en verdi til en gjeldende sekvens. Selv om du ikke visste hva append()- metoden er, har du sannsynligvis allerede brukt den implisitt. Dette skjedde når du koblet sammen strenger i Java ved å bruke +-operatoren. Poenget er at String-sammenkobling i Java er implementert ved å bruke StringBuilder- eller StringBuffer-klassen og deres append()- metode.

Veldig kort om String, StringBuffer og StringBuilder

Som du sikkert vet er String-klassen endelig (den har ingen barneklasser) og uforanderlig (forekomster av denne klassen kan ikke endres etter opprettelse). Faktisk, på grunn av uforanderligheten til String-klassen, opprettes nye strengforekomster som et resultat av hver operasjon, og gamle blir kastet, og genererer mye søppel. For å håndtere generering av midlertidig søppel på grunn av modifikasjoner av String-objektet, kan du bruke StringBuffer- eller StringBuilder-klassene. Hovedforskjellen mellom de to sistnevnte er at StringBuffer er synkronisert mens StringBuilder ikke er det. Bruk derfor StringBuffer for strenger som vil bli endret ofte i et flertrådsmiljø og StringBuilder i et enkelttrådsmiljø.

Append() i StringBuilder og StringBuffer

append() er en av de beste metodene for StringBuilder- og StringBuffer-klassene. Den legger til en ny verdi til gjeldende sekvens. Det er 13 forskjellige overbelastede append()- metoder i både StringBuffer- og StringBuilder-klassene. La oss se på append-metoden for StringBuilder. Uansett, de fungerer akkurat det samme i tilfelle StringBuffer.

• public StringBuilder append(boolsk b)
• public StringBuilder append(char c)
• public StringBuilder append(char[] str)
• public StringBuilder append(char[] str, int offset, int len)
• public StringBuilder append(CharSequence cs)
• public StringBuilder append(CharSequence cs, int start, int end)
• offentlig StringBuilder vedlegg (dobbel d)
• public StringBuilder append(float f)
• public StringBuilder append(int i)
• public StringBuilder append(lang lng)
• public StringBuilder append(Object obj)
• public StringBuilder append(String str)
• public StringBuilder append(StringBuffer sb)

La oss gå gjennom noen av dem og forklare med eksempler hva append()- metoden gjør.

Java.lang.StringBuilder.append(int i)

java.lang.StringBuilder.append(int i) er en metode som tillater å legge til et heltall til et eksisterende StringBuilder-objekt. La oss ta en titt på eksemplene på bruk av 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);

Utgangen her vil være: Hva skjedde her? Først opprettet vi en StringBuilder kalt s med verdien "Jeg elsker Java". Deretter la det til et heltall 14 ved å bruke append(int) . Strengt tatt la vi ikke til et heltall, men strengen "14" og fikk en oppdatert StringBuilder-verdi til "Jeg elsker Java 14". Dermed gjør metoden argumentet til et StringBuilder-objekt, binder det til et eksisterende StringBuilder-objekt og returnerer et oppdatert.

StringBuilder append() eksempel for Object, int, boolean og String argument

Den samme historien vil være med alle de andre overbelastede metodene med tall-, streng-, char- eller array-elementer. La oss lage en LegoBrick Class and Color enum for å demonstrere den offentlige StringBuilder append(Object obj) metoden.

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

La oss nå lage en AppendDemo-klasse hvor vi viser tillegging av en grunnleggende StringBuilder med String, int, LegoBrick og boolean. Høres rart ut, men det fungerer!

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

Utgangen er: Først opprettet og viste vi StringBuilder "I love", deretter først, våt sekvensielt lagt til den ved å bruke append() -metoden en streng, et int-nummer, en strengrepresentasjon av et objekt og en boolsk.

StringBuilder append(char[] cstr, int sett, int lengde)

La oss se på append() -metoden med tre parametere. Den legger til en representasjon av en undergruppe av en gitt char-matrise til strengen. Så her:

• cstr er en rekke tegn som skal legges til
• angi indeksen til det første tegnet som skal legges til
• lengde er antallet tegn som skal legges til.

På samme måte som andre append() -metoder, returnerer denne et utvidet StringBuilder-objekt. Her er et eksempel på bruk av append(char[], cstr, int set, int length) som en del av Java-appkoden.

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

Utgangen er:

StringBuilder append()-metoder med CharSequence-argument

Du har kanskje lagt merke til to metoder som har CharSequence som argumenter.

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

Ikke alle nybegynnere vet at CharSequence er et grensesnitt. Ifølge dokumentasjon er CharSequence en lesbar sekvens av char-verdier og gir ensartet, skrivebeskyttet tilgang til mange forskjellige typer char-sekvenser. Grensesnittet er implementert av slike Java-klasser som String, StringBuffer, StringBuilder og mer. Så hvis du ikke vet hva som er bedre å bruke i programmet, String, StringBuffer eller StringBuilder, kan du bruke CharSequence. StringBuilder append(CharSequence cs, int start, int end) fungerer nesten som append(char[] cstr, int set, int length)vi diskuterte ovenfor. Denne metoden spesifiserer imidlertid det første elementet i undersekvensen og det siste. Det er viktig å huske at start er inkludert i delsekvensen, men slutt er det ikke (det vil si at det siste elementet i delsekvensen er elementet som kommer før slutt). Hvorfor det? Det er akkurat slik det er i Java. La oss demonstrere hva CharSequence er og append(CharSequence cs) og append(CharSequence cs, int start, int end) metoder.

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

Utgangen er: Vi laget to CharSequences, bundet String og StringBuilder til dem og skrev dem ut. Vi kan ikke bruke append() -metoden direkte på myStringBuilder, siden CharSequence ikke har denne metoden (hvis du ikke forstår hvorfor, må du finne ut om arv samt utvidelse og innsnevring av referansetyper). Derfor lager vi en StringBuilder med og setter sammen ved å bruke append-metoden sekvensielt med både CharSequence. På slutten la vi til vår StringBuilder med undersekvensen "is" ("i" er et 5. element i myStringBuilder og s er det 6.. Husk at i metoden er elementet spesifisert som end ekskludert fra undersekvensen.

Hva med StringBuffer append()?

StringBuffer.append har også 13 varianter av metoden og de fungerer akkurat på samme måte som StringBuilder.

• offentlig StringBuffer vedlegg​(boolsk b)
• offentlig StringBuffer vedlegg (tegn c)
• public StringBuffer append​(char[] str)
• public StringBuffer append​(char[] str, int offset, int len)
• offentlig StringBuffer vedlegg​(dobbel d)
• offentlig StringBuffer vedlegg​(float f)
• offentlig StringBuffer vedlegg (int i)
• offentlig StringBuffer vedlegg​(lang lng)
• offentlig StringBuffer vedlegg​(CharSequence s)
• public StringBuffer append​(CharSequence s, int start, int end)
• offentlig StringBuffer vedlegg​(Object obj)
• public StringBuffer append​(String str)
• offentlig StringBuffer vedlegg​(StringBuffer sb)

La oss ta et eksempel på StringBuffer.append for å koble til en delstreng. Vi tar bare StringBuilder-eksemplet og endrer alle StringBuilders i kode til 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);
   }
}

Utgangen er: Du kan gjøre det med hvert eksempel i denne artikkelen. De vil fungere!

Konklusjon

Siden StringBuilder og StringBuffer deler de fleste funksjonene, er det ingen overraskelse at begge klassene har lignende måter å bruke append()- metoden på. Det er gode nyheter for utviklere - du trenger ikke å lære separate metoder for hver klasse. Når det er sagt, med tanke på mangfoldet av måter å bruke append() på, sørg for å legge inn noen timer med å legge til representasjoner av forskjellige datatyper i en streng.