רשימת Java למערך: המרת רשימה של אלמנטים למערך

שלום! במאמר זה, נבחן כיצד להמיר רשימה של אלמנטים למערך של אלמנטים ב-Java. למעשה, אין כל כך הרבה דרכים לעשות זאת, וכולן פשוטות, כך שהמאמר לא יהיה מסובך. בואו נחליט מיד עם מה אנחנו עובדים. נמיר רשימות למערכים, וליתר דיוק, רשימה של מחרוזות: I, love, learning, on, JavaRush יומר למערך של אותן מחרוזות. אבל קודם כל בונוס קטן. בואו נדבר על איך לכתוב במהירות רשימה.

כיצד לרשום במהירות רשימה למערך

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

List<String> wordsList = new ArrayList();

ואז אנחנו מוסיפים לזה ערכים... אחד אחד...

wordsList.add("I");
wordsList.add("love");
wordsList.add("learning");
wordsList.add("on");
wordsList.add("JavaRush");

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

List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");

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

שיטה מס' 1. חָזֶה

שיטה זו מושלמת למי שאוהב להקליד קוד על המקלדת בלי הרבה מחשבה. סוג של מדיטציה. שלב 1. צור מערך באורך זהה לרשימה:

List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");
String[] wordsArray = new String[wordsList.size()];

שלב 2. צור לולאה עם מונה כדי לחזור על כל רכיבי הרשימה ולהיות מסוגלים לגשת לתאי המערך לפי אינדקס:

for (int i = 0; i < wordsList.size(); i++) {

}

שלב 3. בתוך הלולאה, אנו מקצים את הערך של כל רכיב ברשימה עם index i לתא המערך עם index i:

for (int i = 0; i < wordsList.size(); i++) {
    wordsArray[i] = wordsList.get(i);
}

תוֹצָאָה:

public static void main(String[] args) {

        List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");
        String[] wordsArray = new String[wordsList.size()];

        for (int i = 0; i < wordsList.size(); i++) {
            wordsArray[i] = wordsList.get(i);
        }
    }

שיטה מס' 2. שיטת toArray

כנראה הדבר האופטימלי ביותר לשימוש. לממשק Listיש שתי שיטות toArrayהיוצרות מערך מהרשימה הנוכחית:

Object[] toArray();
 T[] toArray(T[] a);

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

public class Main {
    public static void main(String[] args) {
        List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");
        String[] wordsArray = (String[]) wordsList.toArray();

        for (String word : wordsArray) {
            System.out.println(word);
        }

    }
}

בואו נריץ את השיטה mainונראה את הדברים הבאים:

I
love
learning
on
JavaRush

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

public class Main {
    public static void main(String[] args) {
        List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");
        String[] wordsArray = wordsList.toArray(new String[0]);

        for (String word : wordsArray) {
            System.out.println(word);
        }

    }
}

אם נריץ את השיטה main, נראה את אותן מילים בפלט:

I
love
learning
on
JavaRush

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

1. אורך המערך המשודר קטן מאורך הרשימה

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

2. אורך האלמנט המועבר שווה לאורך הרשימה

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

public class Main {
    public static void main(String[] args) {
        List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");

        // Создаем пустой массив нужной длины
        String[] array = new String[wordsList.size()];

        // Отправляем пустой массив в метод toArray
        wordsList.toArray(array);

        // Проверяем, заполнился ли наш массив. Спойлер: да
        for (String word : array) {
            System.out.println(word);
        }

    }
}

בעת הפלט, נראה את כל אותן שורות, ויתברר שהשיטה מילאה את המערך שיצרנו.

3. אורך המערך המשודר גדול מאורך הרשימה

השיטה תכתוב את כל הרכיבים של הרשימה לתוך מערך, ותכתוב את הערך בתא שליד האלמנט האחרון שנוסף null. בואו נדגים את זה:

public class Main {
    public static void main(String[] args) {
        List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");

        // Создаем пустой массив, длина которого в 2 раза больше длины списка
        String[] array = new String[wordsList.size() * 2];

        for (int i = 0; i < array.length; i++) {
            // В каждую ячейку запишем строковое представление текущего индекса
            array[i] = String.valueOf(i);
        }

        // Отправляем массив в метод toArray
        wordsList.toArray(array);

        // Проверяем, что лежит в нашем массиве
        for (String word : array) {
            System.out.println(word);
        }

    }
}

לאחר הפעלת השיטה mainבמסוף נראה את הדברים הבאים:

I
love
learning
on
JavaRush
null
6
7
8
9

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

wordsList.toArray(new String[0]);

שיטה מספר 3. Stream API

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

public class Main {
    public static void main(String[] args) {
        List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");

        String[] strings = wordsList.stream()
                .toArray(String[]::new);

        for (String s : strings) {
            System.out.println(s);
        }

        /*
        Output:
        I
        love
        learning
        on
        JavaRush

         */
    }
}

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

public class Main {
    public static void main(String[] args) {
        List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");

        String[] strings = wordsList.stream()
                .map(str -> str.toUpperCase())
                .toArray(String[]::new);

        for (String s : strings) {
            System.out.println(s);
        }

        /*
            Output:
            I
            LOVE
            LEARNING
            ON
            JAVARUSH

         */
    }
}

כאן .map(str -> str.toUpperCase())הגדרנו מה צריך לעשות עם כל שורה ברשימה. במקרה זה, החלטנו להמיר כל מחרוזת לאותיות גדולות ואז לאסוף אותה למערך. השימוש ב- Stream API מאפשר לך לא רק לשנות כל ערך, אלא גם לסנן אותם. נניח שאנו רוצים לאסוף מערך מתוך רשימה של מחרוזות, אך בצורה כזו שרק מחרוזות ארוכות משני תווים נכללות במערך:

public class Main {
    public static void main(String[] args) {
        List<String> wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");

        String[] strings = wordsList.stream()
                .filter(str -> str.length() > 2)
                .map(str -> str.toUpperCase())
                .toArray(String[]::new);

        for (String s : strings) {
            System.out.println(s);
        }

        /*
            Output:
            LOVE
            LEARNING
            JAVARUSH
         */
    }
}

כאן בשורה .filter(str -> str.length() > 2)יצרנו מה שנקרא פילטר שיוחל על כל אלמנט ברשימה לפני שהוא נכנס למערך. במקרה זה, השיטה נקראת עבור כל שורה length(), ואם תוצאת הביטוי str.length() > 2נכונה, שורה כזו תגיע לבחירה שתתקבל, ובסופו של דבר במערך. אחרת, זה לא יפגע. כאן, אולי, כדאי לומר שניתן להשיג את אותו הדבר על ידי איטרציה פשוטה על האלמנטים והטלת מגבלות שונות. אתה יכול לעשות את זה גם ככה. Stream API מספק גישה פונקציונלית יותר לפתרון בעיות כאלה.

תוצאות

במאמר זה, בדקנו דרכים שונות להמיר רשימות למערכים:

• חיפוש פשוט;
• שיטהtoArray;
• Stream API.

האפשרות הטובה ביותר היא להשתמש בשיטה toArrayהמוגדרת בממשק List. ישנן שתי שיטות כאלה:

• Object[] toArray();
• T[] toArray(T[] a);

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

שיעורי בית

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