שיטת Append() ב-Java: StringBuilder ו-StringBuffer

append() היא שיטת Java של מחלקות StringBuilder ו-StringBuffer שמוסיפה ערך כלשהו לרצף הנוכחי. גם אם לא ידעת מהי שיטת append() כנראה שכבר השתמשת בה באופן מרומז. זה קרה כאשר שרשרת מחרוזות ב-Java באמצעות האופרטור +. הנקודה היא ששרשור מחרוזות ב-Java מיושם באמצעות המחלקה StringBuilder או StringBuffer ושיטת append() שלהם .

בקצרה רבה על String, StringBuffer ו-StringBuilder

כפי שאתה בוודאי יודע, מחלקה מחרוזת היא סופית (אין לה כיתות ילדים) ואינה ניתנת לשינוי (לא ניתן לשנות מופעים של מחלקה זו לאחר היצירה). למעשה, בשל חוסר השינוי של המחלקה String, נוצרים מופעי מחרוזת חדשים כתוצאה מכל פעולה, וישנים נמחקים, מה שיוצר הרבה זבל. כדי להתמודד עם יצירת זבל זמני עקב שינויים באובייקט String, אתה יכול להשתמש במחלקות StringBuffer או StringBuilder. ההבדל העיקרי בין השניים האחרונים הוא ש-StringBuffer מסונכרן ואילו StringBuilder לא. לפיכך, השתמשו ב-StringBuffer עבור מחרוזות שישונו לעיתים קרובות בסביבה מרובת הליכי שרשרת וב-StringBuilder במקרה של סביבה עם חיבורים בודדים.

Append() ב-StringBuilder ו-StringBuffer

append() היא אחת השיטות המובילות של מחלקות StringBuilder ו-StringBuffer. הוא מוסיף ערך חדש לרצף הנוכחי. ישנן 13 שיטות append() עמוסות מדי הן במחלקות StringBuffer והן במחלקות StringBuilder. בואו נסתכל על שיטת ה-append עבור StringBuilder. בכל מקרה, הם עובדים בדיוק אותו הדבר במקרה של StringBuffer.

• public StringBuilder append(בוליאנית 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)
• Public StringBuilder append(double d)
• Public StringBuilder append(float f)
• Public StringBuilder append(int i)
• Public StringBuilder append(long lng)
• Public StringBuilder append(Object obj)
• public StringBuilder append(String str)
• public StringBuilder append(StringBuffer sb)

בואו נעבור על כמה מהם ונסביר בעזרת דוגמאות מה בדיוק עושה שיטת 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);

הפלט כאן יהיה: מה קרה פה? ראשית, יצרנו StringBuilder בשם s עם הערך "I love Java". לאחר מכן הוסיפו לו מספר שלם 14 באמצעות append(int) . למען האמת, הוספנו לא מספר שלם, אלא את המחרוזת "14" וקיבלנו ערך StringBuilder מעודכן ל-"I love Java 14". לפיכך, השיטה הופכת את הארגומנט לאובייקט StringBuilder, קושרת אותו לאובייקט StringBuilder קיים ומחזירה אחד מעודכן.

StringBuilder append() לדוגמה עבור Object, int, Boolean ו-String ארגומנט

אותו סיפור יהיה עם כל שאר השיטות העמוסות עם אלמנטים של מספר, מחרוזת, char או מערכים. בואו ניצור קובץ LegoBrick Class ו-Color enum כדי להדגים את שיטת StringBuilder public append(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 +
              '}';
   }
}

כעת בואו ניצור מחלקה AppendDemo שבה נציג הוספה של StringBuilder בסיסי עם String, int, LegoBrick ו-boolean. נשמע מוזר, אבל זה עובד!

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 "I love", ולאחר מכן, ראשית, הרטיבו ברצף שנוסף אליו באמצעות שיטת append() String, מספר int, ייצוג String של אובייקט ובוליאני.

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

בואו נסתכל על שיטת append() עם שלושה פרמטרים. הוא מוסיף ייצוג של תת-מערך של מערך char נתון למחרוזת. אז כאן:

• cstr הוא מערך של תווים שיש להוסיף
• הגדר לו את האינדקס של התו הראשון שיש להוסיף
• אורך הוא כמות התווים שיש להוסיף.

בדומה לשיטות append() אחרות , זו מחזירה אובייקט StringBuilder מורחב. הנה דוגמה לשימוש ב-append(char[], cstr, int set, int length) כחלק מקוד אפליקציית 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);
   }
}

הפלט הוא:

StringBuilder append() שיטות עם ארגומנט CharSequence

ייתכן ששמתם לב לשתי שיטות שהטיעונים שלהן הם CharSequence.

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

לא כל המתחילים יודעים ש-CharSequence הוא ממשק. על פי התיעוד CharSequence הוא רצף קריא של ערכי char ומספק גישה אחידה לקריאה בלבד לסוגים רבים ושונים של רצפי char. הממשק מיושם על ידי מחלקות Java כגון String, StringBuffer, StringBuilder ועוד. אז אם אתה לא יודע מה עדיף להשתמש בתוכנה שלך, String, StringBuffer או StringBuilder אתה יכול להשתמש ב-CharSequence. StringBuilder append(CharSequence cs, int start, int end) עובד כמעט כמו append(char[] cstr, int set, int length) שדיברנו עליו למעלה. עם זאת, שיטה זו מציינת את האלמנט הראשון של רצף המשנה והאחרון. חשוב לזכור שהתחלה נכללת ברצף המשנה, אבל סוף לא (כלומר, האלמנט האחרון בתת הרצף הוא האלמנט שבא לפני הסוף). למה? זה בדיוק כמו שזה ב-Java. בואו נדגים מה זה CharSequence ושיטות append(CharSequence cs) ו- 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);
       }
   }

הפלט הוא: יצרנו שני CharSequences, קשרנו אליהם String ו-StringBuilder והדפסנו אותם. אנחנו לא יכולים ליישם את השיטה append() ישירות על myStringBuilder, מכיוון של-CharSequence אין שיטה זו (אם אינך מבין מדוע, עליך להבין על ירושה וכן על הרחבה וצמצום של סוגי הפניות). לכן, אנו יוצרים StringBuilder עם ומשרשרים באמצעות שיטת append ברצף עם שני CharSequence. בסוף צירפנו את StringBuilder שלנו עם רצף המשנה "is" ("i" הוא אלמנט 5 של myStringBuilder ו-s הוא ה-6. זכור שבשיטה, האלמנט שצוין כ-end אינו נכלל ברצף המשנה.

מה לגבי StringBuffer append()?

ל-StringBuffer.append יש גם 13 גרסאות של השיטה והן פועלות בדיוק באותו אופן כמו StringBuilder.

• תוספת StringBuffer public (בוליאנית b)
• Public StringBuffer append​(char c)
• public StringBuffer append​(char[] str)
• public StringBuffer append​(char[] str, int offset, int len)
• צרף StringBuffer ציבורי (ד כפול)
• צרף StringBuffer public (float f)
• Public StringBuffer append​(int i)
• תוספת StringBuffer ציבורית (lng ארוכה)
• תוספת StringBuffer ציבורית (CharSequence s)
• Public StringBuffer append​(CharSequence s, int start, int end)
• צרף StringBuffer public (Object obj)
• Public StringBuffer append​(String str)
• Public StringBuffer append​(StringBuffer sb)

קבל דוגמה של StringBuffer.append כדי להצטרף למחרוזת משנה. אנחנו פשוט ניקח את הדוגמה של StringBuilder ונשנה את כל StringBuilders בקוד ל-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);
   }
}

הפלט הוא: אתה יכול לעשות את זה עם כל דוגמה של מאמר זה. הם יעבדו!

סיכום

מכיוון ש-StringBuilder ו-StringBuffer חולקים את רוב הפונקציות, אין זה מפתיע שלשתי המחלקות יש דרכים דומות להשתמש בשיטת append() . אלו חדשות טובות למפתחים - אינך צריך ללמוד שיטות נפרדות עבור כל כיתה. לאחר שאמרתי זאת, בהתחשב במגוון הדרכים להשתמש ב-append() , הקפד להשקיע כמה שעות של תרגול בהוספת הייצוגים של סוגי נתונים שונים למחרוזת.