Listahan ng Java sa array: i-convert ang isang listahan ng mga elemento sa isang array

Kamusta! Sa artikulong ito, titingnan natin kung paano i-convert ang isang listahan ng mga elemento sa isang hanay ng mga elemento sa Java. Sa totoo lang, walang napakaraming paraan para gawin ito, at lahat sila ay simple, kaya hindi magiging kumplikado ang artikulo. Magpasya agad tayo kung ano ang ginagawa natin. Iko-convert namin ang mga listahan sa mga array, at mas partikular, isang listahan ng mga string: I, love, learning, on, JavaRush will be convert into an array of the same strings. Ngunit una, isang maliit na bonus. Pag-usapan natin kung paano mabilis na magsulat ng isang listahan.

Paano mabilis na isulat ang isang listahan sa array

Tandaan: may dalawang senaryo sa buhay na ito. Ang una ay lubos na mapanglaw at pagkabagot kapag nagpasimula tayo ng bagong listahan:

List<String> wordsList = new ArrayList();

At pagkatapos ay nagdaragdag kami ng mga halaga dito... Isa-isa...

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

Hindi mabuti. Nakalimutan ko kung bakit kailangan ang listahan habang ginagawa ko ito! Ang ikalawang paraan ay upang putulin ang lahat ng mga hindi kinakailangang bagay at magpatibay ng... utility classes. Halimbawa, ang klase Arrays, na may isang hindi kapani-paniwalang maginhawang paraan asList. Maaari mong ipasa dito ang anumang nais mong gumawa ng isang listahan, at ang pamamaraan ay gagawin itong isang listahan. Isang bagay na tulad nito:

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

Ang pamamaraang ito ay tumatagal sa sarili nito varargs- sa isang kahulugan, isang array. Humihingi ako ng paumanhin sa katotohanan na sa lecture na tinatawag na list to array, tinuruan kita ng array to list muna, ngunit kinakailangan ito ng mga pangyayari. Well, ngayon sa aming mga pamamaraan para sa pag-convert ng mga listahan sa mga array.

Paraan numero 1. Bust

Ang pamamaraang ito ay perpekto para sa mga gustong mag-type ng code sa keyboard nang hindi gaanong iniisip. Isang uri ng pagmumuni-muni. Hakbang 1. Lumikha ng array na kapareho ng haba ng listahan:

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

Hakbang 2. Gumawa ng loop na may counter para umulit sa lahat ng elemento ng listahan at ma-access ang array cell sa pamamagitan ng index:

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

}

Hakbang 3. Sa loob ng loop, itinalaga namin ang halaga ng bawat elemento ng listahan na may index i sa array cell na may index i:

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

Resulta:

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

Paraan Blg. 2. toArray Method

Marahil ang pinakamainam na bagay na gagamitin. Ang interface Listay may dalawang pamamaraan toArrayna lumikha ng isang array mula sa kasalukuyang listahan:

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

Ang unang paraan ay nagbabalik ng isang hanay ng mga bagay na naglalaman ng lahat ng mga elemento ng kasalukuyang listahan (mula sa una hanggang sa huli):

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

    }
}

Patakbuhin natin ang pamamaraan mainat tingnan ang sumusunod:

I
love
learning
on
JavaRush

Gayunpaman, ang pamamaraang ito ay may kakaiba: palagi itong nagbabalik ng hanay ng mga bagay (Object[]). Samakatuwid, ang ibinalik na resulta ay dapat i-cast sa nais na uri ng data. Sa halimbawa sa itaas ay inihagis namin ito sa isang hanay ng mga string (String[]). Ngunit ang pamamaraang ito ay hindi tumatanggap ng mga argumento, na maaaring maging maginhawa sa ilang mga sitwasyon. Ang pangalawang paraan ay nagbabalik din ng array na naglalaman ng lahat ng elemento ng kasalukuyang listahan (mula sa una hanggang sa huli). Gayunpaman, hindi tulad ng una, ang pangalawang pamamaraan ay tumatagal ng isang hanay ng isang tiyak na uri bilang isang argumento. Ngunit ang resulta ng pangalawang pamamaraan ay hindi isang hanay ng mga bagay, ngunit isang hanay ng isang tiyak na uri ng data - kapareho ng uri ng data sa paraan ng array na ipinasa bilang mga argumento.

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

    }
}

Kung patakbuhin natin ang method main, makikita natin ang parehong mga salita sa output:

I
love
learning
on
JavaRush

Pag-usapan natin ng kaunti ang tungkol sa array na ipinasa bilang argumento sa toArray. Ang lohika ng pamamaraan ay nakasalalay sa haba ng ipinadalang array. May tatlong posibleng senaryo:

1. Ang haba ng ipinadalang array ay mas mababa kaysa sa haba ng listahan

Sa kasong ito, ang pamamaraan ay lumilikha ng isang bagong array at inilalagay ang mga elemento ng listahan dito. Ipinakita namin ito sa halimbawa sa itaas.

2. Ang haba ng elementong ipinapasa ay katumbas ng haba ng listahan

Ilalagay ng pamamaraan ang mga elemento ng listahan sa naipasa na array. Ipakita natin ito:

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

    }
}

Kapag nag-output, makikita natin ang lahat ng parehong linya, at magiging malinaw na napuno ng pamamaraan ang array na ginawa natin.

3. Ang haba ng ipinadalang array ay mas malaki kaysa sa haba ng listahan

Isusulat ng pamamaraan ang lahat ng elemento ng listahan sa isang array, at isusulat ang halaga sa cell sa tabi ng huling idinagdag na elemento null. Ipakita natin ito:

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

    }
}

Pagkatapos patakbuhin ang pamamaraan mainsa console makikita natin ang sumusunod:

I
love
learning
on
JavaRush
null
6
7
8
9

Aling paraan sa tatlo ang dapat mong piliin? Sa mga unang bersyon ng Java, pinakamainam na magpasa ng array na may haba na katumbas o mas malaki kaysa sa haba ng listahan. Gayunpaman, ang mga modernong JVM ay may mga pag-optimize, at sa ilang mga kaso ay nagbibigay sila ng mas mabilis na pagganap para sa isang paraan na pumasa sa isang hanay ng mas maikling haba kaysa sa haba ng listahan. Kaya kung nagpapatakbo ka ng modernong bersyon ng Java, ipasa ang isang walang laman na array sa pamamaraan tulad ng ginawa namin sa unang halimbawa:

wordsList.toArray(new String[0]);

Paraan Blg. 3. Stream API

Ang pamamaraang ito ay angkop para sa mga nais hindi lamang mag-convert ng isang listahan sa isang array, ngunit malutas din ang ilang iba pang mga problema sa daan. At para din sa mga taong pamilyar sa Java Stream API. Ang JavaRush ay may magandang artikulo sa paksang ito . Sa seksyong ito titingnan natin ang ilang mga halimbawa gamit ang mga stream. Paano i-convert ang isang listahan sa isang array gamit ang mga stream:

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

         */
    }
}

Ngunit kung kailangan mo lang maglagay ng isang listahan sa isang array, mas mainam na gawin ito gamit ang pamamaraang toArrayinilarawan sa Paraan Blg. 2. Ngunit kung nais mong hindi lamang i-convert ang isang listahan sa isang array, ngunit din upang magsagawa ng ilang aksyon sa bawat elemento, kung gayon ito ang tamang lugar para sa iyo. Subukan nating i-convert ang listahan sa isang array upang sa huling hanay ang lahat ng mga linya ay nakasulat sa malalaking titik:

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

         */
    }
}

Dito ay .map(str -> str.toUpperCase())tinukoy namin kung ano ang kailangang gawin sa bawat linya sa listahan. Sa kasong ito, nagpasya kaming i-convert ang bawat string sa upper case at pagkatapos ay kolektahin ito sa isang array. Ang paggamit ng Stream API ay nagbibigay-daan sa iyo na hindi lamang baguhin ang bawat halaga, ngunit i-filter din ang mga ito. Ipagpalagay na gusto naming mangolekta ng array mula sa isang listahan ng mga string, ngunit sa paraang mga string lang na mas mahaba kaysa sa dalawang character ang kasama sa array:

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

Dito sa linya .filter(str -> str.length() > 2)gumawa kami ng tinatawag na filter na ilalapat sa bawat elemento ng listahan bago ito mapunta sa array. Sa kasong ito, ang pamamaraan ay tinatawag para sa bawat row length(), at kung ang resulta ng expression str.length() > 2ay totoo, ang naturang row ay mapupunta sa resultang pagpili, at sa huli ay sa array. Kung hindi, hindi ito tatama. Dito, marahil, nararapat na sabihin na ang parehong ay maaaring makamit sa pamamagitan lamang ng pag-ulit sa mga elemento at pagpapataw ng iba't ibang mga paghihigpit. Magagawa mo rin ito sa ganitong paraan. Nagbibigay ang Stream API ng isang mas functional na diskarte upang malutas ang mga naturang problema.

Mga resulta

Sa artikulong ito, tumingin kami sa iba't ibang paraan upang i-convert ang mga listahan sa mga array:

• simpleng paghahanap;
• paraantoArray;
• Stream API.

Ang pinakamagandang opsyon ay ang gamitin ang paraan toArrayna tinukoy sa interface List. Mayroong dalawang gayong mga pamamaraan:

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

Ang una ay hindi tumatanggap ng mga argumento, ngunit nagbabalik ng isang hanay ng mga bagay, kung kaya't madalas mong kailangang gumamit ng tahasang uri ng paghahagis. Ang pangalawa ay nagbabalik ng array ng gustong uri, ngunit kumukuha ng array bilang argumento. Pinakamainam na ipasa ang isang walang laman na hanay sa pamamaraan, at ikaw ay magiging masaya. Ang paggamit ng Stream API ay nagbibigay-daan sa iyo hindi lamang na mag-convert ng isang listahan sa isang array, ngunit gayundin upang magsagawa ng ilang mga aksyon sa daan, tulad ng pag-filter o pag-convert ng mga elemento bago idagdag ang mga ito sa array.

Takdang aralin

Subukang ulitin ang lahat ng mga halimbawa mula sa artikulong ito sa iyong sarili, ngunit sa halip na ang orihinal na listahan ng mga string, gumamit ng isang listahan ng mga integer mula 0 hanggang 10. Naturally, kailangan mong iakma ang ilang mga kundisyon mula sa mga halimbawa na nalalapat lamang sa mga string sa bagong kundisyon.