รายการ 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- ในแง่หนึ่งคืออาร์เรย์ ฉันขอโทษสำหรับความจริงที่ว่าในการบรรยายที่เรียกว่า list to array ฉันสอนคุณให้ array แสดงรายการก่อน แต่สถานการณ์จำเป็น ตอนนี้ถึงวิธีการของเราในการแปลงรายการเป็นอาร์เรย์

วิธีที่ 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 ภายในลูป เรากำหนดค่าของแต่ละองค์ประกอบรายการด้วยดัชนี i ให้กับเซลล์อาร์เรย์ที่มีดัชนี 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);
        }

    }
}

ถ้าเรารัน method 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 สตรีม 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;
• สตรีม API

ตัวเลือกที่ดีที่สุดคือการใช้วิธีการtoArrayที่กำหนดไว้ในอินเทอร์เฟListซ มีสองวิธีดังกล่าว:

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

อันแรกไม่ยอมรับอาร์กิวเมนต์ แต่จะส่งคืนอาร์เรย์ของอ็อบเจ็กต์ ซึ่งเป็นเหตุผลว่าทำไมคุณจึงมักจะต้องใช้การคัดเลือกประเภทที่ชัดเจน ส่วนที่สองส่งคืนอาร์เรย์ของประเภทที่ต้องการ แต่รับอาร์เรย์เป็นอาร์กิวเมนต์ วิธีที่ดีที่สุดคือส่งอาร์เรย์ว่างให้กับเมธอด แล้วคุณจะพอใจ การใช้ Stream API ช่วยให้คุณไม่เพียงแต่แปลงรายการเป็นอาร์เรย์เท่านั้น แต่ยังดำเนินการบางอย่างไปพร้อมกัน เช่น การกรองหรือการแปลงองค์ประกอบก่อนที่จะเพิ่มลงในอาร์เรย์

การบ้าน

พยายามทำซ้ำตัวอย่างทั้งหมดจากบทความนี้ด้วยตัวเอง แต่แทนที่จะใช้รายการสตริงดั้งเดิม ให้ใช้รายการจำนวนเต็มตั้งแต่ 0 ถึง 10 โดยปกติแล้ว คุณจะต้องปรับเงื่อนไขบางอย่างจากตัวอย่างที่ใช้กับสตริงเป็นค่าใหม่เท่านั้น เงื่อนไข.