زیر رشته در جاوا

محبوب ترین اقدامات در String در جاوا عبارتند از الحاق، گرفتن یک کاراکتر بر اساس شاخص و گرفتن یک رشته فرعی. در این مقاله قصد داریم در مورد روش زیر رشته جاوا به شما بگوییم.

زیر رشته جاوا چیست؟

زیر رشته جاوا به طور کلی دنباله ای از کاراکترهای به هم پیوسته در داخل رشته است. این می تواند بخشی از رشته یا کل رشته نیز باشد. زیر رشته در جاوا چیست؟ این زبان به لطف بارگذاری بیش از حد متد جاوا، یک متد ()substring یا بهتر بگوییم دو روش دارد . می توانید از آنها برای دریافت زیر رشته در برنامه جاوا استفاده کنید. روش اول زیر رشته جاوا String substring (firstIndex) و روش دوم String substring (firstIndex, lastIndex) است .

نحوه استفاده از زیر رشته در جاوا

پاسخ ساده است: فقط از رشته فرعی استفاده کنید. متد ()substring جاوا بخشی از رشته را برمی گرداند. برای این کار می توانید از دو روش استفاده کنید: کارهای بسیار محبوبی که به شما در درک آن کمک می کند

• نحوه دریافت زیر رشته در جاوا
• چگونه تمام زیر رشته های یک رشته معین را پیدا کنیم
• چگونه طولانی ترین زیررشته مشترک را پیدا کنیم

نحوه دریافت زیر رشته در جاوا (به ویژه)

این اولین مثال زیر رشته جاوا بسیار آسان است. شما یک رشته دارید و باید یک زیررشته "CodeGym" را در آن پیدا کنید. شما قبلاً می دانستید که چگونه یک زیر رشته در جاوا دریافت کنید. بنابراین راه حل این مشکل خاص در اینجا آمده است:

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 Cod CodeG CodeGy CodeGym o od odeG odeGy odeGym d de deG deGy deGym 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

زیر رشته در جاوا چگونه کار می کند

در JDK 7 و نسخه‌های جدیدتر، substring () دیگر تعداد کاراکترها را در آرایه کاراکتری که ایجاد می‌کند، مانند نسخه‌های قبل از JDK 6 شمارش نمی‌کند، بلکه به سادگی یک آرایه جدید در حافظه ایجاد می‌کند (heap) و به آن ارجاع می‌دهد. . به عنوان مثال:

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 زیر رشته

حتی امروز در برخی از پروژه های بزرگ ممکن است 6 بار با پایه کدهای قدیمی از JDK ملاقات کنید. در متد JDK 6 substring() به روشی متفاوت کار می کند. همانطور که احتمالاً می دانید، String یک کلاس تغییرناپذیر است و برای دریافت زیررشته، جاوا از این تغییر ناپذیری قبلاً در JDK 6 استفاده کرده است. Object از نوع String در داخل فقط یک آرایه از کاراکترها است، یا بهتر است بگوییم، حاوی آرایه ای از کاراکترها است. در زمان JDK 6، دو متغیر دیگر در آنجا ذخیره شد: تعداد اولین کاراکتر در آرایه کاراکتر و کمیت آنها. بنابراین، در JDK 6، رشته دارای سه فیلد با مقدار char [] (آرایه کاراکتر)، int offset (شاخص اولین کاراکتر در آرایه)، و تعداد int (تعداد کاراکترهای آرایه) بود. هنگامی که یک رشته فرعی در JDK 6 ایجاد می شود، آرایه کاراکترها در شی String جدید کپی نمی شوند . به جای این، هر دو شی یک مرجع به یک آرایه کاراکتر ذخیره می کنند. با این حال شی دوم دو متغیر دیگر را ذخیره می کند، نماد اول زیر رشته و دومی در مورد تعداد نمادها در زیر رشته است. روش JDK 6 به دلیل مشکل نشت حافظه جایگزین شد. چه مفهومی داره؟ بیایید فرض کنیم یک رشته داریم xو با استفاده از رشته فرعی چند زیر رشته ایجاد می کنیم.

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

اکنون یک شی x داریم که در ناحیه خاصی از حافظه به نام heap ذخیره شده است و دو شی y و z به همان شی x اشاره دارند . فقط x به عناصر از دوم تا ششم اشاره دارد و z به عناصر x از صفر تا سوم اشاره دارد. اگر شی اصلی x قبلاً استفاده شده باشد و بدون هیچ ارجاعی روی آن باقی مانده باشد، چه؟ در یک برنامه همه اشیاء دیگر فقط با y و z کار می کنند. در این حالت، جمع‌آورنده زباله ممکن است شی x را از بین ببرد ، در حالی که آرایه حافظه باقی می‌ماند، و توسط y و z استفاده می‌شود. نشت حافظه اتفاق می افتد. بنابراین، روش جدیدتر، JDK 7 و نسخه بعدی، از نظر استفاده از حافظه بسیار پرهزینه است. با این حال به شما امکان می دهد از نشت حافظه جلوگیری کنید. علاوه بر این، روش جدید سریعتر کار می کند، زیرا نیازی به محاسبه تعداد کاراکترها نیست. برای تقویت آموخته هایتان، پیشنهاد می کنیم یک درس ویدیویی از دوره جاوا ما تماشا کنید