سلسلة فرعية في جافا

الإجراءات الأكثر شيوعًا على String في Java هي التسلسل، والحصول على حرف حسب الفهرس والحصول على سلسلة فرعية. سنخبرك في هذه المقالة عن طريقة Java الفرعية.

ما هي سلسلة جافا الفرعية؟

Java Substring بشكل عام عبارة عن تسلسل متجاور من الأحرف داخل السلسلة. يمكن أن يكون جزءًا من السلسلة أو السلسلة بأكملها أيضًا. ما هي السلسلة الفرعية في جافا؟ تحتوي هذه اللغة على طريقة substring() ، أو بالأحرى طريقتان، وذلك بفضل التحميل الزائد لطريقة Java. يمكنك استخدامها للحصول على سلسلة فرعية في برنامج Java. الطريقة الأولى لسلسلة Java الفرعية هي String substring(firstIndex) والثانية هي String substring (firstIndex, lastIndex) .

كيفية استخدام السلسلة الفرعية في جافا

الجواب بسيط: فقط استخدم السلسلة الفرعية. تقوم طريقة Java substring() بإرجاع جزء من السلسلة. هناك طريقتان يمكنك استخدامهما لهذا: المهام الشائعة جدًا التي تساعدك على الفهم

• كيفية الحصول على سلسلة فرعية في جافا
• كيفية العثور على جميع السلاسل الفرعية لسلسلة معينة
• كيفية العثور على أطول سلسلة فرعية مشتركة

كيفية الحصول على سلسلة فرعية في جافا (خاص)

هذا المثال الأول لسلسلة 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

كيف تعمل السلسلة الفرعية في جافا

في JDK 7 والإصدارات الأحدث، لم تعد السلسلة الفرعية () تحسب عدد الأحرف في مصفوفة الأحرف التي تنشئها، كما فعلت في الإصدارات السابقة لـ 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، تعمل السلسلة الفرعية () بطريقة مختلفة. كما تعلم على الأرجح، فإن String هي فئة غير قابلة للتغيير وللحصول على السلسلة الفرعية استخدمت Java هذه القابلية للتغيير سابقًا في JDK 6. الكائن من النوع String الموجود بالداخل هو مجرد مصفوفة من الأحرف، أو بالأحرى، يحتوي على مصفوفة من الأحرف. في وقت JDK 6، تم تخزين متغيرين آخرين هناك: عدد الحرف الأول في مصفوفة الأحرف وكميتها. وبالتالي، في JDK 6، تحتوي السلسلة على ثلاثة حقول بقيمة char [] (مصفوفة الأحرف)، وإزاحة int (فهرس الحرف الأول في المصفوفة)، وعدد int (عدد الأحرف في المصفوفة). عندما يتم إنشاء سلسلة فرعية في JDK 6، لا يتم نسخ مصفوفة الأحرف إلى كائن السلسلة الجديد . بدلاً من ذلك، يقوم كلا الكائنين بتخزين مرجع إلى نفس مصفوفة الأحرف. ومع ذلك، يقوم الكائن الثاني بتخزين متغيرين آخرين، الرمز الأول للسلسلة الفرعية والثاني يدور حول عدد الرموز الموجودة في السلسلة الفرعية. تم استبدال طريقة 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 الخاصة بنا