מערך מחרוזות ב-Java

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

כיצד להכריז ולאתחל מערך מחרוזות

אתה יכול להכריז ולאתחל מערך מחרוזות ב-Java בדרכים שונות. למשל כמו בקוד למטה:

String[] myArray = {"value1", "value2", "value3"};

כאן אנו מכריזים תחילה על משתנה myArray מסוג String[] . לאחר מכן, אנו מאתחלים את המערך עם שלושה ערכי מחרוזת המוקפים בסוגריים מסולסלים. לחלופין, אתה יכול לקבל הצהרת מערך מחרוזת ואתחול בשורות נפרדות:

String[] myArray; // String array declaration
myArray = new String[] {"value1", "value2", "value3"}; // initialize the array

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

String[] myArray = new String[5];

כאן אתה יוצר מערך מחרוזות ומציין את הגודל של מערך מחרוזות , אבל אתה לא מספק שום ערכים ראשוניים. לאחר מכן תוכל להקצות ערכים למערך באמצעות לולאה או על ידי ציון הערכים בנפרד. שימו לב שבכל המקרים, עליכם לציין את סוג המערך (במקרה זה, String ) תוך כדי הצהרת המשתנה.

כיצד לבצע איטרציה דרך מערך ה-String

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

public class IterateStringArrayExample {
    public static void main(String[] args) {
        String[] stringArray = {"violin", "viola", "cello", "double bass"};

        // Using a for loop
        for (int i = 0; i < stringArray.length; i++) {
            String s = stringArray[i];
            System.out.print(s + " ");
        }
        System.out.println();

        // Using a foreach loop
        for (String s : stringArray) {
            System.out.print(s + " ");
        }
        System.out.println();
    }
}

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

כיצד להוסיף אלמנט חדש למערך

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

//add string Array and a new element
String[] oldArray = {"violin", "viola", "cello"};
String newElement = "double bass";
String[] newArray = Arrays.copyOf(oldArray, oldArray.length + 1);
newArray[newArray.length - 1] = newElement;

כאן השיטה Arrays.copyOf יוצרת מערך חדש בשם newArray עם אורך אחד גדול מה-oldArray. השיטה מוסיפה newElement לסוף ה- newArray על ידי הקצאתו לרכיב האחרון של newArray . למערכים ב-Java יש אורך קבוע, כך שלא ניתן להוסיף או להסיר אלמנטים ממערך לאחר שהוא נוצר. כדי להוסיף או להסיר באופן דינמי אלמנטים מאוסף, מוטב שתשתמש במבנה נתונים אחר. לדוגמה, רשימה או מפה .

כיצד למיין אלמנטים במערך מחרוזות

בטח, אם אתה מעוניין בתרגילי תכנות טובים, אתה יכול לכתוב את אלגוריתם המיון שלך עבור הליך המיון. עם זאת, במשימות עבודה אמיתיות הרבה יותר קל להשתמש בשיטת Arrays.sort() . הנה דוגמה:

import java.util.Arrays;

public class SortStringArrayExample {
    public static void main(String[] args) {
        String[] stringArray = {"violin", "viola", "cello", "double bass"};

        // Sorting the array
        Arrays.sort(stringArray);

        // Printing the sorted array
        for (String s : stringArray) {
            System.out.print(s + " ");
        }
    }
}

כאן אנו יוצרים תחילה מערך String בשם stringArray עם ארבעה אלמנטים. לאחר מכן אנו קוראים למתודה Arrays.sort() כדי למיין את האלמנטים במערך בסדר עולה. לבסוף, אנו עוברים דרך המערך הממוין באמצעות לולאה לכל לולאה ומדפיסים כל רכיב לקונסולה. הפלט של תוכנית זו הוא הבא: כפי שאתה יכול לראות, השיטה מיינתה אלמנטים ב- stringArray בסדר אלפביתי.

כיצד לחפש מחרוזת מסוימת במערך מחרוזת

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

public class SearchString {

       public static void main(String[] args) {
           String[] stringArray = {"violin", "viola", "cello", "double bass"};
           String searchString1 = "cello";
           String searchString2 = "piano";
           search(stringArray, searchString1);
           search(stringArray, searchString2);

       }
          public static boolean search (String[] myArray, String myString){

           boolean found = false;

           // Loop through the array to search for the string
           for (String s : myArray) {
               if (s.equals(myString)) {
                   found = true;
                   break;
               }
           }

           // Print the result
           if (found) {
               System.out.println(myString + " found in the array.");
           } else {
               System.out.println(myString + " not found in the array.");
           } return found;
       }
}

כאן אנו יוצרים שיטה עם שני ארגומנטים, מערך ומחרוזת שניתן למצוא. אנו יוצרים 'נמצא' בוליאני כדי לעקוב אחר האם מצאנו את המחרוזת . זה הערך שנמצא שהשיטה תחזיר. לאחר מכן אנו משתמשים בלולאה של כל אחד כדי לחזור על כל אלמנט של מערך. אנו משתמשים בשיטת equals() בלולאה כדי להשוות את האלמנט הנוכחי עם מחרוזת החיפוש. אם השיטה מוצאת התאמה, אנו מגדירים אותה כ-true ומשתמשים במשפט break כדי לצאת מוקדם מהלולאה. לבסוף, אנו מדפיסים את התוצאה בהתאם אם המציאה היא אמת או שקר. בשיטה הראשית אנו קוראים לשיטת החיפוש פעמיים, עם ה- String שנמצא במערך וזו שלא. הפלט של תוכנית זו הוא הבא:

כיצד להמיר מערך מחרוזות למחרוזת

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

String[] myArray = {"value1", "value2", "value3"};
String joinedString = String.join(", ", myArray);
System.out.println(joinedString);

הפלט הוא הבא: ראשית, אנו מכריזים על מערך מחרוזת myArray עם שלושה ערכי מחרוזת. לאחר מכן אנו משתמשים בשיטת String.join() כדי לחבר את כל רכיבי המערך למחרוזת אחת. הארגומנט הראשון של String.join() הוא המפריד שבו ברצונך להשתמש בין כל רכיב מערך. השתמשנו ב-"," (פסיק ואחריו רווח) כמפריד. הארגומנט השני הוא המערך שאליו ברצונך להצטרף. לבסוף, אנו מקצים את המחרוזת שנוצרה למשתנה joinedString ומדפיסים אותו למסוף.