สตริงย่อยใน Java

การกระทำที่นิยมมากที่สุดในสตริงในภาษาจาวาคือ การต่อข้อมูล การรับอักขระตามดัชนี และการรับสตริงย่อย ในบทความนี้เราจะบอกคุณเกี่ยวกับวิธีย่อยของ Java

Java Substring คืออะไร?

Java Substring โดยทั่วไปคือลำดับที่ต่อเนื่องกันของอักขระภายในสตริง อาจเป็นส่วนหนึ่งของสตริงหรือทั้งสตริงก็ได้ สตริงย่อยใน Java คืออะไร ภาษานี้มี เมธอด substring()หรือมากกว่าสองเมธอด ขอบคุณเมธอด Java ที่โอเวอร์โหลด คุณสามารถใช้เพื่อรับสตริงย่อยในโปรแกรม Java วิธีการย่อย Java แรกคือ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 วิธีค้นหาสตริงย่อยทั่วไปที่ยาวที่สุด ปัญหาสตริงย่อยทั่วไปที่ ยาว ที่สุด เป็นหนึ่งในงานที่ได้รับความนิยมมากที่สุดในวิทยาการคอมพิวเตอร์ คุณสามารถพบสิ่งนี้ได้ในการสัมภาษณ์ Junior Developer ซึ่งมีความเป็นไปได้สูงทีเดียว ยังไงก็ลองแก้ดู มันเป็นแบบฝึกหัดที่มีประโยชน์มากสำหรับโปรแกรมเมอร์มือใหม่ ปัญหาสตริงย่อยทั่วไปที่ยาวที่สุดหมายถึงการค้นหาสตริงที่ยาวที่สุด (หรือสองสามสตริง) ที่เป็นสตริงย่อย (หรือเป็นสตริงย่อย) ของสตริงตั้งแต่สองสตริงขึ้นไป ตัวอย่างเช่น คุณมีสองสตริง

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และ{C, 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 method substring()ทำงานในวิธีที่ต่างออกไป อย่างที่คุณคงทราบกันดีว่าStringเป็นคลาสที่ไม่เปลี่ยนรูป และเพื่อรับสตริงย่อย Java ได้ใช้การไม่เปลี่ยนรูปนี้ก่อนหน้านี้ใน JDK 6 Object ประเภทStringภายในเป็นเพียงอาร์เรย์ของอักขระ หรือมากกว่านั้น ประกอบด้วยอาร์เรย์ของอักขระ ในช่วงเวลาของ JDK 6 ตัวแปรอีกสองตัวถูกเก็บไว้ที่นั่น: จำนวนอักขระตัวแรกในอาร์เรย์อักขระและจำนวน ดังนั้นใน JDK 6 สตริงจึงมีสามฟิลด์ของค่าถ่าน [] (อาร์เรย์อักขระ), int offset (ดัชนีของอักขระตัวแรกในอาร์เรย์) และจำนวน int(จำนวนอักขระในอาร์เรย์) เมื่อสตริงย่อยถูกสร้างขึ้นใน JDK 6 อาร์เรย์ของอักขระจะไม่ถูกคัดลอกไปยังอ็อบเจกต์สตริง ใหม่ แทนที่จะเป็นเช่นนี้ วัตถุทั้งสองจะเก็บการอ้างอิงไปยัง Character Array เดียวกัน อย่างไรก็ตาม ออบเจกต์ที่สองเก็บตัวแปรอีกสองตัว สัญลักษณ์แรกของสตริงย่อย และตัวที่สองเป็นเรื่องเกี่ยวกับจำนวนสัญลักษณ์ที่อยู่ในสตริงย่อย วิธี JDK 6 ถูกแทนที่เนื่องจากปัญหาหน่วยความจำรั่ว มันหมายความว่าอะไร? สมมติว่าเรามีสตริงxและเราสร้างสตริงย่อยสองสามรายการโดยใช้สตริงย่อย

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

ตอนนี้เรามีวัตถุx เก็บไว้ในพื้นที่หน่วยความจำพิเศษที่ เรียกว่าฮีป และวัตถุ 2 ชิ้นyและzอ้างอิงถึงวัตถุเดียวกันx เฉพาะxหมายถึงองค์ประกอบตั้งแต่วินาทีถึงหก และzหมายถึง องค์ประกอบ xตั้งแต่ศูนย์ถึงสาม จะเกิดอะไรขึ้นถ้าวัตถุดั้งเดิมxถูกใช้ไปแล้วและถูกทิ้งไว้โดยไม่มีการอ้างอิงใดๆ ในโปรแกรม วัตถุอื่นทั้งหมดทำงานกับyและzเท่านั้น ในกรณีนี้ตัวรวบรวมขยะอาจทำลายวัตถุxในขณะที่อาร์เรย์หน่วยความจำยังคงอยู่ และถูกใช้โดย y และ z หน่วยความจำรั่วเกิดขึ้น ดังนั้น วิธีการที่ใหม่กว่า JDK 7 และใหม่กว่านั้นค่อนข้างแพงในแง่ของการใช้หน่วยความจำ อย่างไรก็ตาม จะช่วยให้คุณป้องกันการรั่วไหลของหน่วยความจำได้ นอกจากนี้ วิธีการใหม่ยังทำงานได้เร็วขึ้น เนื่องจากไม่ต้องคำนวณจำนวนอักขระ เพื่อเสริมสิ่งที่คุณได้เรียนรู้ เราขอแนะนำให้คุณดูบทเรียนวิดีโอจากหลักสูตร Java ของเรา