Senarai Java kepada tatasusunan: menukar senarai elemen kepada tatasusunan

hello! Dalam artikel ini, kita akan melihat cara menukar senarai elemen kepada tatasusunan elemen dalam Java. Sebenarnya, tidak begitu banyak cara untuk melakukan ini, dan semuanya mudah, jadi artikel itu tidak akan menjadi rumit. Mari kita tentukan dengan segera apa yang sedang kita kerjakan. Kami akan menukar senarai kepada tatasusunan, dan lebih khusus lagi, senarai rentetan: Saya, suka, belajar, hidup, JavaRush akan ditukar menjadi tatasusunan rentetan yang sama. Tetapi pertama, sedikit bonus. Mari kita bincangkan tentang cara menulis senarai dengan cepat.

Cara cepat menulis senarai ke tatasusunan

Ingat: terdapat dua senario dalam kehidupan ini. Yang pertama adalah melankolis dan kebosanan apabila kami memulakan senarai baharu:

List<String> wordsList = new ArrayList();

Dan kemudian kami menambah nilai padanya... Satu demi satu...

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

Tidak baik. Saya terlupa mengapa senarai itu diperlukan semasa saya menciptanya! Cara kedua ialah memotong semua perkara yang tidak perlu dan mengamalkan... kelas utiliti. Sebagai contoh, kelas Arrays, yang mempunyai kaedah yang sangat mudah asList. Anda boleh memasukkan apa sahaja yang anda mahu buat senarai, dan kaedah itu akan menjadikannya senarai. Sesuatu seperti ini:

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

Kaedah ini mengambil sendiri varargs- dalam erti kata lain, tatasusunan. Saya memohon maaf kerana fakta bahawa dalam kuliah yang dipanggil senarai ke tatasusunan saya mengajar anda tatasusunan untuk menyenaraikan dahulu, tetapi keadaan memerlukannya. Nah, sekarang kepada kaedah kami untuk menukar senarai kepada tatasusunan.

Kaedah No 1. Dada

Kaedah ini sesuai untuk mereka yang suka menaip kod pada papan kekunci tanpa banyak berfikir. Sejenis meditasi. Langkah 1. Buat tatasusunan yang sama panjang dengan senarai:

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

Langkah 2. Cipta gelung dengan pembilang untuk melelaran melalui semua elemen senarai dan boleh mengakses sel tatasusunan mengikut indeks:

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

}

Langkah 3. Di dalam gelung, kami menetapkan nilai setiap elemen senarai dengan indeks i kepada sel tatasusunan dengan indeks i:

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

Keputusan:

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);
        }
    }

Kaedah No 2. Kaedah toArray

Mungkin perkara yang paling optimum untuk digunakan. Antara muka Listmempunyai dua kaedah toArrayyang mencipta tatasusunan daripada senarai semasa:

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

Kaedah pertama mengembalikan tatasusunan objek yang mengandungi semua elemen senarai semasa (dari pertama hingga terakhir):

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);
        }

    }
}

Mari jalankan kaedah maindan lihat perkara berikut:

I
love
learning
on
JavaRush

Walau bagaimanapun, kaedah ini mempunyai keanehan: ia sentiasa mengembalikan tatasusunan objek (Object[]). Oleh itu, hasil yang dikembalikan mesti dihantar ke jenis data yang dikehendaki. Dalam contoh di atas, kami menghantarnya ke tatasusunan rentetan (String[]). Tetapi kaedah ini tidak menerima hujah, yang boleh menjadi mudah dalam beberapa situasi. Kaedah kedua juga mengembalikan tatasusunan yang mengandungi semua elemen senarai semasa (dari pertama hingga terakhir). Walau bagaimanapun, tidak seperti yang pertama, kaedah kedua mengambil tatasusunan jenis tertentu sebagai hujah. Tetapi hasil kaedah kedua tidak akan menjadi tatasusunan objek, tetapi tatasusunan jenis data tertentu - sama seperti jenis data dalam kaedah tatasusunan yang diluluskan sebagai argumen.

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);
        }

    }
}

Jika kita menjalankan method main, kita akan melihat perkataan yang sama dalam output:

I
love
learning
on
JavaRush

Mari kita bercakap sedikit tentang tatasusunan yang diluluskan sebagai hujah kepada toArray. Logik kaedah bergantung pada panjang tatasusunan yang dihantar. Terdapat tiga senario yang mungkin:

1. Panjang tatasusunan yang dihantar adalah kurang daripada panjang senarai

Dalam kes ini, kaedah mencipta tatasusunan baharu dan meletakkan elemen senarai ke dalamnya. Kami menunjukkan ini dalam contoh di atas.

2. Panjang elemen yang dihantar adalah sama dengan panjang senarai

Kaedah ini akan meletakkan elemen senarai ke dalam tatasusunan yang diluluskan. Mari kita tunjukkan ini:

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);
        }

    }
}

Apabila mengeluarkan, kita akan melihat semua baris yang sama, dan ia akan menjadi jelas bahawa kaedah telah mengisi tatasusunan yang kita buat.

3. Panjang tatasusunan yang dihantar lebih besar daripada panjang senarai

Kaedah ini akan menulis semua elemen senarai ke dalam tatasusunan dan akan menulis nilai ke dalam sel bersebelahan dengan elemen tambahan yang terakhir null. Mari kita tunjukkan ini:

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);
        }

    }
}

Selepas menjalankan kaedah maindalam konsol kita akan melihat perkara berikut:

I
love
learning
on
JavaRush
null
6
7
8
9

Kaedah manakah antara ketiga-tiga yang patut anda pilih? Dalam versi awal Java, adalah optimum untuk menghantar tatasusunan dengan panjang yang sama atau lebih besar daripada panjang senarai. Walau bagaimanapun, JVM moden mempunyai pengoptimuman, dan dalam beberapa kes, JVM memberikan prestasi yang lebih pantas untuk kaedah yang lulus tatasusunan yang lebih pendek daripada panjang senarai. Jadi, jika anda menjalankan versi moden Java, hantar tatasusunan kosong kepada kaedah seperti yang kami lakukan dalam contoh pertama:

wordsList.toArray(new String[0]);

Kaedah No 3. API Strim

Kaedah ini sesuai untuk mereka yang ingin bukan sahaja menukar senarai menjadi tatasusunan, tetapi juga menyelesaikan beberapa masalah lain di sepanjang jalan. Dan juga untuk orang yang biasa dengan Java Stream API. JavaRush mempunyai artikel yang bagus mengenai topik ini . Dalam bahagian ini kita akan melihat beberapa contoh menggunakan aliran. Cara menukar senarai kepada tatasusunan menggunakan aliran:

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

         */
    }
}

Tetapi jika anda hanya perlu menghantar senarai ke tatasusunan, maka adalah lebih baik untuk melakukan ini menggunakan kaedah toArrayyang diterangkan dalam Kaedah No. 2. Tetapi jika anda bukan sahaja mahu menukar senarai kepada tatasusunan, tetapi juga untuk melakukan beberapa tindakan pada setiap elemen, maka ini adalah tempat yang sesuai untuk anda. Mari cuba tukar senarai kepada tatasusunan supaya dalam tatasusunan akhir semua baris ditulis dalam huruf besar:

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

         */
    }
}

Di sini, .map(str -> str.toUpperCase())kami telah menentukan perkara yang perlu dilakukan dengan setiap baris dalam senarai. Dalam kes ini, kami memutuskan untuk menukar setiap rentetan kepada huruf besar dan kemudian mengumpulkannya ke dalam tatasusunan. Menggunakan API Strim membolehkan anda bukan sahaja mengubah setiap nilai, tetapi juga menapisnya. Katakan kita ingin mengumpul tatasusunan daripada senarai rentetan, tetapi dengan cara yang hanya rentetan yang lebih panjang daripada dua aksara dimasukkan dalam tatasusunan:

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
         */
    }
}

Di sini dalam baris .filter(str -> str.length() > 2)kami telah mencipta penapis yang dipanggil yang akan digunakan pada setiap elemen senarai sebelum ia masuk ke dalam tatasusunan. Dalam kes ini, kaedah dipanggil untuk setiap baris length(), dan jika hasil ungkapan itu str.length() > 2benar, baris sedemikian akan berakhir dalam pemilihan yang terhasil, dan akhirnya dalam tatasusunan. Jika tidak, ia tidak akan memukul. Di sini, mungkin, patut dikatakan bahawa perkara yang sama boleh dicapai dengan hanya mengulangi elemen dan mengenakan pelbagai sekatan. Anda juga boleh melakukannya dengan cara ini. Stream API menyediakan pendekatan yang lebih berfungsi untuk menyelesaikan masalah sedemikian.

Keputusan

Dalam artikel ini, kami melihat pelbagai cara untuk menukar senarai kepada tatasusunan:

• carian mudah;
• kaedahtoArray;
• API Strim.

Pilihan terbaik ialah menggunakan kaedah toArrayyang ditakrifkan dalam antara muka List. Terdapat dua kaedah sedemikian:

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

Yang pertama tidak menerima hujah, tetapi mengembalikan tatasusunan objek, itulah sebabnya anda selalunya terpaksa menggunakan pemutus jenis eksplisit. Yang kedua mengembalikan tatasusunan jenis yang dikehendaki, tetapi mengambil tatasusunan sebagai hujah. Adalah lebih baik untuk menghantar tatasusunan kosong kepada kaedah, dan anda akan gembira. Menggunakan API Strim membolehkan anda bukan sahaja menukar senarai kepada tatasusunan, tetapi juga melakukan beberapa tindakan di sepanjang jalan, seperti menapis atau menukar elemen sebelum menambahkannya pada tatasusunan.

Kerja rumah

Cuba ulangi sendiri semua contoh daripada artikel ini, tetapi bukannya senarai rentetan asal, gunakan senarai integer dari 0 hingga 10. Sememangnya, anda perlu menyesuaikan beberapa syarat daripada contoh yang hanya terpakai pada rentetan kepada yang baharu syarat.