מחרוזת משנה ב-Java

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

מה זה Java Substring?

Java Substring באופן כללי הוא רצף רציף של תווים בתוך המחרוזת. זה יכול להיות חלק מהמחרוזת או גם מהמחרוזת כולה. מהי תת מחרוזת ב-Java? לשפה זו יש שיטת substring() או יותר נכון שתי שיטות, הודות לעומס יתר של שיטת Java. אתה יכול להשתמש בהם כדי לקבל מחרוזת משנה בתוכנית Java. שיטת ה-Java substring הראשונה היא String substring(firstIndex) והשנייה היא String substring (firstIndex, lastIndex) .

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

התשובה פשוטה: פשוט השתמש במחרוזת המשנה. שיטת Java substring() מחזירה חלק מהמחרוזת. ישנן שתי שיטות שבהן אתה יכול להשתמש: משימות פופולריות מאוד שעוזרות לך להבין

• כיצד להשיג מחרוזת משנה ב-Java
• כיצד למצוא את כל תת המחרוזות של מחרוזת נתונה
• כיצד למצוא את המחרוזת המשותפת הארוכה ביותר

כיצד להשיג מחרוזת משנה ב-Java (בפרט)

דוגמה ראשונה זו למחרוזת משנה של Java היא די קלה. יש לך מחרוזת ואתה צריך למצוא בה תת-מחרוזת "CodeGym". כבר ידעת איך להשיג מחרוזת משנה ב-Java. אז הנה הפתרון לבעיה הספציפית הזו:

import java.io.IOException;

public class Main {

   public static void main(String[] args) throws IOException {

       String s1 = "the best Java Core course is CourseCodeGym.  End of story";
       String myTarget = "CodeGym";
       int index1 = s1.indexOf(myTarget);

       int index2 = index1 + myTarget.length();
       System.out.println(s1.substring(index1, index2));

   }
}

הפלט הוא: CodeGym תהליך הסתיים עם קוד יציאה 0 איך למצוא את כל תת-מחרוזות של מחרוזת נתונה כאן יש לנו את הדרך הפשוטה ביותר למצוא את כל תת-מחרוזות של מחרוזת נתונה.

import java.io.IOException;
public class Main {
   public static void main(String[] args) throws IOException {
       String myTarget = "CodeGym";
       for (int i = 0; i < myTarget.length(); i++) {
           for (int j = i + 1; j <= myTarget.length(); j++) {
               System.out.println(myTarget.substring(i, j));
           }
       }
   }
}

הפלט הוא: C Co Cod Code CodeG CodeGy CodeGym o od ode odeG odeGy odeGym d de deG deGy deGym e eG eGy eGym G Gy Gym y ym m התהליך הסתיים עם קוד יציאה 0 איך למצוא את תת-המחרוזת המשותפת הארוכה ביותר הבעיה הנפוצה ביותר של תת - מחרוזת היא אחת המשימות הפופולריות ביותר במדעי המחשב. אתה יכול לפגוש את זה בראיון למפתחים ג'וניור שלך בסבירות גבוהה למדי. בכל מקרה, נסה לפתור את זה, זה תרגיל מאוד שימושי למתכנת מתחיל. בעיית המשנה הנפוצה הארוכה ביותר פירושה למצוא את המחרוזת הארוכה ביותר (או כמה מהם) שהיא תת-מחרוזת (או שהן מחרוזות משנה) של שתי מחרוזות או יותר. לדוגמה, יש לך שתי מחרוזות

String first = "CodeGym"
String second = "SomeGym"

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

public class SubStringTest {

   //  in this method we are looking for the Longest common substring of
   // first String with length = m  and the second String with length = n
   public static String longestCS(String first, String second, int m, int n) {
       // the maximal length
       int maxLength = 0;
       // the last index of the longest common substring
       int endIndex = m;

       // array stores the length of substring
       int[][] keeper = new int[m + 1][n + 1];

       for (int i = 1; i <= m; i++) {
           for (int j = 1; j <= n; j++) {
               // check if current characters of first and second strings match
               if (first.charAt(i - 1) == second.charAt(j - 1)) {
                   keeper[i][j] = keeper[i - 1][j - 1] + 1;

                   if (keeper[i][j] > maxLength) {
                       maxLength = keeper[i][j];
                       endIndex = i;
                   }
               }
           }
       }
       return first.substring(endIndex - maxLength, endIndex);
   }


   public static void main(String[] args) {
       String first = "CodeGym";
       String second = "SomeGym";
       int m = first.length(), n = second.length();
       System.out.println("The longest common substring = " + longestCS(first, second, m, n));
   }
}

הפלט הוא: המחרוזת המשותפת הארוכה ביותר = eGym

איך תת-מחרוזת עובדת ב-Java

ב-JDK 7 וגרסאות חדשות יותר, substring() כבר לא סופר את מספר התווים במערך התווים שהוא יוצר, כפי שקרה בגרסאות שקדמו ל-JDK 6 כולל, אלא פשוט יוצר מערך חדש בזיכרון (ערימה) ומתייחס אליו . הנה דוגמא:

String x = "CodeGymIsTheBest";
String y = x.substring (2,6);
String z = x.substring (0,3);

לכן, ב-JDK 7 ואילך, אובייקטים y ו- z שנוצרו כתוצאה משיטת substring() המוחלת על אובייקט x יתייחסו לשני מערכים חדשים שנוצרו (על הערימה) - {d,e, G, y} עבור y ו {ג, o} עבור z . בגרסת JDK 7+ של תת-מחרוזת השיטה, שתי השורות החדשות הללו (כלומר, שני מערכי תווים חדשים) יאוחסנו בזיכרון יחד עם המחרוזת המקורית myLongString ({C, o, d, e, G, y, m , i, s, t, h, e, b,e,s,t} בצורה של מערך) .

גרסת JDK 6 של מחרוזת משנה

אפילו היום בכמה פרויקטים גדולים אתה עשוי לפגוש בסיס קוד מדור קודם מה-JDK 6 פעמים. בשיטת JDK 6 substring() עובד בצורה שונה. כפי שאתה בוודאי יודע, String היא מחלקה בלתי ניתנת לשינוי וכדי לקבל את המחרוזת המשנה Java השתמשה באי-השינוי הזה מוקדם יותר ב-JDK 6. האובייקט מסוג String בתוך הוא רק מערך של תווים, או ליתר דיוק, מכיל מערך של תווים. בזמן JDK 6 אוחסנו שם שני משתנים נוספים: מספר התו הראשון במערך התווים וכמותם. לפיכך, ב-JDK 6, ל-String היו שלושה שדות של ערך char [] (מערך תווים), int offset (אינדקס של התו הראשון במערך), ו- int count (מספר התווים במערך). כאשר תת-מחרוזת נוצרת ב-JDK 6, מערך התווים אינו מועתק לאובייקט String החדש . במקום זאת, שני האובייקטים מאחסנים הפניה לאותו מערך תווים. עם זאת, האובייקט השני מאחסן שני משתנים נוספים, הסמל הראשון של המחרוזת המשנה והשני הוא בערך כמה סמלים יש בתת מחרוזת. שיטת JDK 6 הוחלפה בגלל בעיית דליפת זיכרון. מה זה אומר? בוא נניח שיש לנו מחרוזת x, ואנחנו יוצרים כמה מחרוזות משנה באמצעות מחרוזת משנה.

String x = "CodeGymIsTheBest";
String y = x.substring (2,6);
String z = x.substring (0,3);

כעת יש לנו אובייקט x המאוחסן באזור מיוחד של זיכרון שנקרא ערימה, ושני אובייקטים y ו- z המתייחסים לאותו אובייקט x . רק x מתייחס ליסודות מהשני עד השישי, ו- z מתייחס לאלמנטים x מאפס לשלישי. מה אם האובייקט המקורי x כבר היה בשימוש והושאר ללא הפניות כלשהן עליו? בתוכנית כל שאר האובייקטים עובדים עם y ו- z בלבד. במקרה זה אספן האשפה עלול להרוס את האובייקט x , בעוד שמערך הזיכרון נשאר, והוא משמש את y ו-z. דליפת הזיכרון מתרחשת. לכן, השיטה החדשה יותר, JDK 7 ואילך, היא די יקרה מבחינת השימוש בזיכרון. עם זאת זה מאפשר לך למנוע את דליפת הזיכרון. בנוסף, השיטה החדשה עובדת מהר יותר, שכן היא לא חייבת לחשב את מספר התווים. כדי לחזק את מה שלמדת, אנו מציעים לך לצפות בשיעור וידאו מקורס Java שלנו