למד כיצד לחבר מחרוזות ב-Java

הרבה קידוד כרוך במניפולציה של טקסט, מתרגום שפה ועד פשוט חיבור מילים יחד. ל-Java, כמו לרוב השפות האחרות, יש תמיכה מובנית מעולה כדי לעזור לך לעבוד עם מחרוזות.

Java תומכת במקרה הפשוט של הצטרפות - או שרשור - מחרוזות טוב מאוד. למעשה, יש מספיק דרכים שונות להצטרף לטקסט כדי שתרצה לדעת את ההבדלים ביניהם ומדוע אתה עשוי להשתמש בכל גישה.

השתמש בסימן +

מכל הדברים שכדאי לדעת על Strings ב-Java, שרשור בסיסי באמצעות ה + מפעיל הוא אחד הבסיסיים ביותר. כאשר יש לך שתי מחרוזות או יותר, תוכל להשתמש בסימן + כדי לחבר אותן יחד.

כך תוכל לעשות זאת:

פּוּמְבֵּימעמדStringConcat_Java{
פּוּמְבֵּיסטָטִיבָּטֵלרָאשִׁי(מחרוזת[] args)
 {
 String var1 = "שלום,";
 String var2 = "שמי הוא";
 String var3 = "Advait";
System.out.println (var1 + " " + var2 + " " + var3);
 }
}

הפלט הסופי הוא כדלקמן:

בקוד שלמעלה, יש לך ערכי מחרוזת בשלושה משתנים שונים (var1, var2 ו- var3), שאותם אתה מצטרף עם הסימן +.

המירכאות הריקות מקיפות רווחים, שאליהם אתה יכול להתייחס בתור המפריד. במקרה זה, הם פועלים כרווחים בין מילים במשפט האחרון. ה println הפונקציה מדפיסה את הפלט הסופי כשלב האחרון.

שרשרת שורות מרובות של מחרוזות עם הסימן +

אתה יכול לחבר כמה מחרוזות יחד גם אם הן מפוזרות על פני קווים שונים. לשם כך, פשוט השתמש ב-a + סימן בין כל מחרוזת:

פּוּמְבֵּימעמדStringConcat_Java{
פּוּמְבֵּיסטָטִיבָּטֵלרָאשִׁי(מחרוזת[] args)
 {
 String var1 = "שלום, " +
 "שמי אדוואיט." +
 " " +
 "אני סופר ב-MUO.";
System.out.println (var1);
 }
}

הנה הפלט של הקוד לעיל:

כאשר אתה מפעיל את הקוד שלמעלה, הוא מחבר את כל המחרוזות יחדיו כדי ליצור פיסת טקסט אחת בודדת.

השתמש ב-StringBuilder

אתה יכול גם להשתמש במחלקה StringBuilder כדי לשרשר מחרוזות ב-Java.

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

אתה יכול להשתמש ב לְצַרֵף שיטה להוספת מחרוזת לסוף התוכן הנוכחי של StringBuilder.

פּוּמְבֵּימעמדStringConcat_Java{
פּוּמְבֵּיסטָטִיבָּטֵלרָאשִׁי(מחרוזת[] args)
 {
 StringBuilder strn_builder = חָדָשׁ StringBuilder();
strn_builder.append("שלום,"); 
 strn_builder.append("אני");
 strn_builder.append("Advait Singh"); 
System.out.println (strn_builder.toString());
 }
}

כך נראה הפלט:

כפי שהשם מרמז, הפונקציה append() מצטרפת ערכים לקצה המחרוזת הפנימית של StringBuilder.

למד להשתמש בפונקציה Concat() ב-Java

פונקציה זו פשוטה ועושה את העבודה ללא טרחה. לפני שתתחיל להשתמש בפונקציה זו, עליך לשים לב לדברים הבאים:

• אתה יכול להשתמש בפונקציה concat עם מחרוזות בלבד.
• אתה יכול רק לחבר שתי מחרוזות באמצעות פונקציה זו. עם זאת, אתה יכול לשרשר את השיטה מכיוון שהיא מחזירה מחרוזת, אז קוד כמו str1.concat (str2).concat (str3) יעבוד כפי שהיית מצפה.

כך תוכל להשתמש בפונקציה concat() ב- Java:

פּוּמְבֵּימעמדStringconcat_Java{
פּוּמְבֵּיסטָטִיבָּטֵלרָאשִׁי(מחרוזת[] args)
 {
// הגדר את ערכי המחרוזת ב- var1 ו- var2
 String var1 = "שלום, ";
 String var2 = "שמי הוא Advait Singh";
// var3 מכיל את הערך המשורשר, שבו var1 מצטרף עם var2
 מחרוזת var3 = var1.concat (var2); 
// הדפס את הגרסה הסופית המאוחסנת ב- var3
 System.out.println (var3);
 }
}

המשתנים var1 ו-var2 מאחסנים את המחרוזות בעוד var3 מאחסן את התוצאה של ההצטרפות ביניהם. שיטת ה-concat מצטרפת למשתנה השני, var2, ל-var1. הקוד מקצה את התוצאה מ-concat למשתנה השלישי, var3, ומדפיס אותה:

שימוש בפונקציית הפורמט ב-Java

שיטה נוספת היא פוּרמָט פונקציה, שהיא די מועילה לשרשור מחרוזות. זוהי פונקציה נפוצה, זמינה בשפות תכנות רבות. שיטת הפורמט של Python, למשל, מאוד דומה.

התחביר הבסיסי עבור פונקציה זו הוא string.format(), ואחריו מפרט הפורמט (למשל. %s) וערכי המחרוזת/אובייקטים.

פּוּמְבֵּימעמדStringconcat_Java{
פּוּמְבֵּיסטָטִיבָּטֵלרָאשִׁי(מחרוזת[] args)
 {
// הגדר את ערכי המחרוזת במשתנה הראשון והשני
 String var1 = "שלום, ";
 String var2 = "שמי הוא Advait Singh";
// השתמש בפונקציית הפורמט כדי לשרשר מחרוזות
 String var3 = String.format("%s%s", var1, var2); 
// הדפס את הפלט המאוחסן ב-var3
 System.out.println (var3);
 }
}

דוגמה זו משתמשת במפרט הפורמט %s אשר פועל כמציין מיקום עבור מחרוזת. מכיוון שהארגומנט הפורמט כולל שתי מחרוזות, עליך לעקוב אחריו עם שני ארגומנטים של מחרוזת בדיוק: var1 ו- var2 במקרה זה. התוצאה היא המחרוזת המעוצבת שהקוד מדפיס למסוף:

שימוש בשיטת String.join()

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

אתה לא מוגבל לשרשור רק שתי מחרוזות בשיטת הצטרפות. אתה יכול להעביר כל מספר של פרמטרים של מחרוזת והצטרפות תשלב את כולם באמצעות הפרמטר הראשון, המפריד:

פּוּמְבֵּימעמדStringconcat_Java{
פּוּמְבֵּיסטָטִיבָּטֵלרָאשִׁי(מחרוזת[] args)
 {
// צור מחרוזות חדשות ואחסן אותן במשתני var1 ו- var2
 String var1 = "שלום,";
 String var2 = "שמי הוא Advait";
// השתמש בשיטת String.join כדי לשלב את המחרוזות
 String var3 = String.join(" ", var1, var2); 
System.out.println (var3);
 }
}

קוד זה משלב שני מילולי מחרוזת, מאחסן את התוצאה ב-var3, ואז מדפיס אותה למסוף:

פונקציות שרשור מחרוזות רב-פנים של Java

הפונקציות המעשיות של Java נותנות לך אפשרויות רבות לשקול בעת ביצוע המשימה הפשוטה של ​​צירוף מחרוזות. מומלץ לתרגל את השימוש בגישות האלטרנטיביות הללו כדי להבין כיצד הן פועלות ומה ההבדלים ביניהן.

יש קווי דמיון רבים בין שרשרת מחרוזות ב-Java לבין ביצוע כך ב-Python. לעתים קרובות אתה יכול להעביר ידע על שרשור מחרוזות בין שפות. דוגמה טובה היא התחביר של מפרטי פורמטים שבהם משתמש String.format. שפות כמו Python, C ו-PHP משתמשות מחדש במושג הזה ולפחות בחלק מהפרטים שלו.