జావాలో అనుబంధం() పద్ధతి: స్ట్రింగ్‌బిల్డర్ మరియు స్ట్రింగ్‌బఫర్

append() అనేది StringBuilder మరియు StringBuffer తరగతుల జావా పద్ధతి, ఇది ప్రస్తుత క్రమానికి కొంత విలువను జోడిస్తుంది. append() పద్ధతి అంటే ఏమిటో మీకు తెలియక పోయినప్పటికీ , మీరు దీన్ని ఇప్పటికే పరోక్షంగా ఉపయోగించారు. మీరు + ఆపరేటర్‌ని ఉపయోగించి జావాలో స్ట్రింగ్‌లను సంగ్రహించినప్పుడు ఇది జరిగింది. విషయం ఏమిటంటే, జావాలో స్ట్రింగ్ సంయోగం StringBuilder లేదా StringBuffer తరగతి మరియు వాటి అనుబంధం() పద్ధతిని ఉపయోగించి అమలు చేయబడుతుంది.

స్ట్రింగ్, స్ట్రింగ్‌బఫర్ మరియు స్ట్రింగ్‌బిల్డర్ గురించి చాలా క్లుప్తంగా

మీకు బహుశా తెలిసినట్లుగా, స్ట్రింగ్ క్లాస్ ఫైనల్ (దీనికి చైల్డ్ క్లాస్‌లు లేవు) మరియు మార్పులేనివి (ఈ తరగతి యొక్క ఉదంతాలు సృష్టించిన తర్వాత సవరించబడవు). వాస్తవానికి, స్ట్రింగ్ క్లాస్ యొక్క మార్పులేని కారణంగా, ప్రతి ఆపరేషన్ ఫలితంగా కొత్త స్ట్రింగ్ సందర్భాలు సృష్టించబడతాయి మరియు పాతవి విస్మరించబడతాయి, చాలా చెత్తను ఉత్పత్తి చేస్తుంది. స్ట్రింగ్ ఆబ్జెక్ట్‌కు మార్పుల కారణంగా తాత్కాలిక చెత్త ఉత్పత్తిని ఎదుర్కోవటానికి, మీరు స్ట్రింగ్‌బఫర్ లేదా స్ట్రింగ్‌బిల్డర్ తరగతులను ఉపయోగించవచ్చు. తరువాతి రెండింటి మధ్య ప్రధాన వ్యత్యాసం ఏమిటంటే, StringBuilder సమకాలీకరించబడనప్పుడు StringBuffer సమకాలీకరించబడింది. అందువల్ల, స్ట్రింగ్‌బఫర్‌ని బహుళ-థ్రెడ్ వాతావరణంలో తరచుగా సవరించబడే స్ట్రింగ్‌ల కోసం మరియు సింగిల్-థ్రెడ్ ఎన్విరాన్‌మెంట్ విషయంలో స్ట్రింగ్‌బిల్డర్‌ని ఉపయోగించండి.

StringBuilder మరియు StringBufferలో అనుబంధం().

append() అనేది StringBuilder మరియు StringBuffer తరగతుల యొక్క అగ్ర పద్ధతులలో ఒకటి. ఇది ప్రస్తుత క్రమానికి కొత్త విలువను జోడిస్తుంది. StringBuffer మరియు StringBuilder తరగతులు రెండింటిలోనూ 13 వివిధ ఓవర్‌లోడ్ చేయబడిన append() పద్ధతులు ఉన్నాయి . StringBuilder కోసం అనుబంధ పద్ధతిని చూద్దాం. ఏది ఏమైనప్పటికీ, అవి స్ట్రింగ్‌బఫర్ విషయంలో సరిగ్గా అదే పని చేస్తాయి.

• పబ్లిక్ స్ట్రింగ్‌బిల్డర్ అనుబంధం (బూలియన్ బి)
• పబ్లిక్ స్ట్రింగ్‌బిల్డర్ అనుబంధం(చార్ సి)
• పబ్లిక్ స్ట్రింగ్‌బిల్డర్ అనుబంధం(చార్[] str)
• పబ్లిక్ స్ట్రింగ్‌బిల్డర్ అనుబంధం(చార్[] str, int ఆఫ్‌సెట్, int len)
• పబ్లిక్ స్ట్రింగ్‌బిల్డర్ అనుబంధం (చార్‌సీక్వెన్స్ సిఎస్)
• పబ్లిక్ స్ట్రింగ్‌బిల్డర్ అనుబంధం (చార్‌సీక్వెన్స్ cs, పూర్ణాంక ప్రారంభం, పూర్ణాంక ముగింపు)
• పబ్లిక్ స్ట్రింగ్‌బిల్డర్ అనుబంధం(డబుల్ డి)
• పబ్లిక్ స్ట్రింగ్‌బిల్డర్ అనుబంధం(ఫ్లోట్ ఎఫ్)
• పబ్లిక్ స్ట్రింగ్‌బిల్డర్ అనుబంధం(int i)
• పబ్లిక్ స్ట్రింగ్‌బిల్డర్ అనుబంధం (పొడవైన ఎల్‌ఎన్‌జి)
• పబ్లిక్ స్ట్రింగ్‌బిల్డర్ అనుబంధం (ఆబ్జెక్ట్ ఆబ్జెక్ట్)
• పబ్లిక్ స్ట్రింగ్‌బిల్డర్ అనుబంధం (స్ట్రింగ్ స్ట్రింగ్)
• పబ్లిక్ స్ట్రింగ్‌బిల్డర్ అనుబంధం (స్ట్రింగ్‌బఫర్ ఎస్‌బి)

వాటిలో కొన్నింటికి వెళ్లి, append() పద్ధతి సరిగ్గా ఏమి చేస్తుందో ఉదాహరణలతో వివరిస్తాము.

Java.lang.StringBuilder.append(int i)

java.lang.StringBuilder.append(int i) అనేది ఇప్పటికే ఉన్న StringBuilder ఆబ్జెక్ట్‌కు పూర్ణాంకాన్ని జోడించడానికి అనుమతించే పద్ధతి. 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);

ఇక్కడ అవుట్‌పుట్ ఇలా ఉంటుంది: ఇక్కడ ఏమి జరిగింది? ముందుగా, మేము "ఐ లవ్ జావా" విలువతో s పేరుతో StringBuilderని సృష్టించాము. అప్పుడు దానికి append(int)ని ఉపయోగించి పూర్ణాంకం 14 జోడించబడింది . ఖచ్చితంగా చెప్పాలంటే, మేము పూర్ణాంకాన్ని కాదు, "14" స్ట్రింగ్‌ని జోడించాము మరియు "I love Java 14"కి StringBuilder విలువను నవీకరించాము. ఈ విధంగా, పద్ధతి వాదనను స్ట్రింగ్‌బిల్డర్ ఆబ్జెక్ట్‌గా మారుస్తుంది, దానిని ఇప్పటికే ఉన్న స్ట్రింగ్‌బిల్డర్ ఆబ్జెక్ట్‌కి బంధిస్తుంది మరియు నవీకరించబడిన దాన్ని అందిస్తుంది.

StringBuilder append() ఉదాహరణకు Object, int, boolean మరియు String argument

నంబర్, స్ట్రింగ్, చార్ లేదా శ్రేణుల మూలకాలతో ఇతర ఓవర్‌లోడ్ చేయబడిన అన్ని పద్ధతులతో ఒకే కథనం ఉంటుంది. పబ్లిక్ StringBuilder append(Object obj) పద్ధతిని ప్రదర్శించడానికి LegoBrick Class మరియు Color enumని క్రియేట్ చేద్దాం .

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

ఇప్పుడు AppendDemo క్లాస్‌ని క్రియేట్ చేద్దాం, ఇక్కడ మేము String, int, LegoBrick మరియు booleanతో ప్రాథమిక StringBuilder యొక్క అనుబంధాన్ని చూపుతాము. విచిత్రంగా అనిపిస్తుంది, కానీ ఇది పనిచేస్తుంది!

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

అవుట్‌పుట్: మొదట, మేము StringBuilder "ఐ లవ్"ని సృష్టించాము మరియు ప్రదర్శించాము, ఆపై ముందుగా, అనుబంధం() పద్ధతిని ఉపయోగించి దానికి క్రమానుగతంగా జోడించాము, స్ట్రింగ్, పూర్ణాంక సంఖ్య, ఆబ్జెక్ట్ మరియు బూలియన్ యొక్క స్ట్రింగ్ ప్రాతినిధ్యం.

StringBuilder append(char[] cstr, int set, int పొడవు)

మూడు పారామితులతో అనుబంధం() పద్ధతిని చూద్దాం . ఇది స్ట్రింగ్‌కు ఇచ్చిన చార్ శ్రేణి యొక్క సబ్‌రే యొక్క ప్రాతినిధ్యాన్ని జోడిస్తుంది. కాబట్టి ఇక్కడ:

• cstr అనేది జోడించవలసిన అక్షరాల శ్రేణి
• అనుబంధించవలసిన మొదటి అక్షరం యొక్క సూచికను సెట్ చేయండి
• పొడవు అనేది జోడించాల్సిన అక్షరాల పరిమాణం.

అదే విధంగా ఇతర append() పద్ధతులకు, ఇది విస్తరించిన StringBuilder వస్తువును అందిస్తుంది. Java యాప్ కోడ్‌లో భాగంగా append(char[], cstr, int set, int length)ని ఉపయోగించే ఉదాహరణ ఇక్కడ ఉంది .

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

అవుట్‌పుట్:

CharSequence వాదనతో StringBuilder append() పద్ధతులు

CharSequenceని వారి వాదనలుగా కలిగి ఉన్న రెండు పద్ధతులను మీరు గమనించి ఉండవచ్చు.

• పబ్లిక్ స్ట్రింగ్‌బిల్డర్ అనుబంధం (చార్‌సీక్వెన్స్ సిఎస్)
• పబ్లిక్ స్ట్రింగ్‌బిల్డర్ అనుబంధం (చార్‌సీక్వెన్స్ cs, పూర్ణాంక ప్రారంభం, పూర్ణాంక ముగింపు)

చార్‌సీక్వెన్స్ ఇంటర్‌ఫేస్ అని అన్ని ప్రారంభకులకు తెలియదు. డాక్యుమెంటేషన్ ప్రకారం CharSequence అనేది చార్ విలువల యొక్క రీడబుల్ సీక్వెన్స్ మరియు అనేక రకాల చార్ సీక్వెన్స్‌లకు ఏకరీతి, రీడ్-ఓన్లీ యాక్సెస్‌ను అందిస్తుంది. స్ట్రింగ్, స్ట్రింగ్‌బఫర్, స్ట్రింగ్‌బిల్డర్ మరియు మరిన్ని వంటి జావా క్లాస్‌ల ద్వారా ఇంటర్‌ఫేస్ అమలు చేయబడుతుంది. కాబట్టి మీ ప్రోగ్రామ్, స్ట్రింగ్, స్ట్రింగ్‌బఫర్ లేదా స్ట్రింగ్‌బిల్డర్‌లో ఏది ఉత్తమమో మీకు తెలియకపోతే మీరు చార్‌సీక్వెన్స్‌ని ఉపయోగించవచ్చు. StringBuilder append(CharSequence cs, int start, int end) దాదాపు append(char[] cstr, int set, int పొడవు) వలె పనిచేస్తుందిమేము పైన చర్చించాము. అయితే, ఈ పద్ధతి తదుపరి మరియు చివరి మూలకం యొక్క మొదటి మూలకాన్ని నిర్దేశిస్తుంది. స్టార్ట్ అనేది సీక్వెన్స్‌లో చేర్చబడిందని గుర్తుంచుకోవడం ముఖ్యం, కానీ ముగింపు కాదు (అంటే, ముగింపుకు ముందు వచ్చే మూలకం తదుపరిది). అది ఎందుకు? ఇది జావాలో ఉన్న విధంగానే ఉంది. చార్‌సీక్వెన్స్ అంటే ఏమిటో మరియు అనుబంధం (చార్‌సీక్వెన్స్ సిఎస్) మరియు అనుబంధం (చార్‌సీక్వెన్స్ సిఎస్, ఇంట్ స్టార్ట్, ఇంట్ ఎండ్) పద్ధతులను ప్రదర్శిస్తాము .

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

అవుట్‌పుట్: మేము రెండు చార్‌సీక్వెన్స్‌లను సృష్టించాము, వాటికి స్ట్రింగ్ మరియు స్ట్రింగ్‌బిల్డర్‌ని కట్టుబడి మరియు వాటిని ముద్రించాము. మేము నేరుగా myStringBuilderకి append() పద్ధతిని వర్తింపజేయలేము , ఎందుకంటే CharSequenceకి ఈ పద్ధతి లేదు (మీకు ఎందుకు అర్థం కాకపోతే, మీరు వారసత్వం గురించి అలాగే సూచన రకాలను విస్తరించడం మరియు తగ్గించడం గురించి తెలుసుకోవాలి). అందువల్ల, మేము చార్‌సీక్వెన్స్ రెండింటితో వరుసగా అనుబంధ పద్ధతిని ఉపయోగించి స్ట్రింగ్‌బిల్డర్‌ను సృష్టిస్తాము మరియు సంగ్రహిస్తాము. చివర్లో మేము మా StringBuilderని “is” (“i” అనేది myStringBuilder యొక్క 5వ మూలకం మరియు s 6వ మూలకంతో జతచేయబడింది. పద్ధతిలో, ముగింపుగా పేర్కొనబడిన మూలకం తదుపరి భాగం నుండి మినహాయించబడిందని గుర్తుంచుకోండి.

StringBuffer append() గురించి ఏమిటి?

StringBuffer.append పద్ధతి యొక్క 13 వేరియంట్‌లను కలిగి ఉంది మరియు అవి StringBuilder వలె సరిగ్గా పని చేస్తాయి.

• పబ్లిక్ స్ట్రింగ్‌బఫర్ అనుబంధం (బూలియన్ బి)
• పబ్లిక్ స్ట్రింగ్‌బఫర్ అనుబంధం (చార్ సి)
• పబ్లిక్ స్ట్రింగ్‌బఫర్ అనుబంధం (చార్[] str)
• పబ్లిక్ స్ట్రింగ్‌బఫర్ అనుబంధం (char[] str, int ఆఫ్‌సెట్, int len)
• పబ్లిక్ స్ట్రింగ్‌బఫర్ అనుబంధం (డబుల్ డి)
• పబ్లిక్ స్ట్రింగ్‌బఫర్ అనుబంధం (ఫ్లోట్ ఎఫ్)
• పబ్లిక్ స్ట్రింగ్‌బఫర్ అనుబంధం (int i)
• పబ్లిక్ స్ట్రింగ్‌బఫర్ అనుబంధం (పొడవైన ఎల్‌ఎన్‌జి)
• పబ్లిక్ స్ట్రింగ్‌బఫర్ అనుబంధం (చార్‌సీక్వెన్స్)
• పబ్లిక్ స్ట్రింగ్‌బఫర్ అనుబంధం (CharSequence s, int start, int end)
• పబ్లిక్ స్ట్రింగ్‌బఫర్ అనుబంధం (ఆబ్జెక్ట్ ఆబ్జెక్ట్)
• పబ్లిక్ స్ట్రింగ్‌బఫర్ అనుబంధం (స్ట్రింగ్ స్ట్రింగ్)
• పబ్లిక్ స్ట్రింగ్‌బఫర్ అనుబంధం (స్ట్రింగ్‌బఫర్ ఎస్‌బి)

సబ్‌స్ట్రింగ్‌లో చేరడానికి StringBuffer.append యొక్క ఉదాహరణను చూద్దాం . మేము స్ట్రింగ్‌బిల్డర్ ఉదాహరణను తీసుకుంటాము మరియు కోడ్‌లోని అన్ని స్ట్రింగ్‌బిల్డర్‌లను స్ట్రింగ్‌బఫర్‌లుగా మారుస్తాము.

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

అవుట్‌పుట్: మీరు ఈ వ్యాసం యొక్క ప్రతి ఉదాహరణతో దీన్ని చేయవచ్చు. వారు పని చేస్తారు!

ముగింపు

StringBuilder మరియు StringBuffer చాలా ఫంక్షన్లను పంచుకున్నందున, append() పద్ధతిని ఉపయోగించడానికి రెండు తరగతులు ఒకే విధమైన మార్గాలను కలిగి ఉండటంలో ఆశ్చర్యం లేదు . డెవలపర్‌లకు ఇది శుభవార్త — మీరు ప్రతి తరగతికి వేర్వేరు పద్ధతులను నేర్చుకోవాల్సిన అవసరం లేదు. అనుబంధం()ని ఉపయోగించే వివిధ మార్గాలను పరిగణనలోకి తీసుకుని , స్ట్రింగ్‌కు వివిధ డేటా రకాల ప్రాతినిధ్యాలను జోడించడం ద్వారా కొన్ని గంటల ప్రాక్టీస్‌లో ఉంచినట్లు నిర్ధారించుకోండి.