Java >> Java tutorial >  >> Java

Konverter List til Array i Java

Java

I Java er der adskillige tilfælde, hvor du skal transformere en liste til en matrix. For eksempel accepterer en funktion kun et array som en parameter i stedet for en samling.

Listegrænsefladen er ansvarlig for at spore samlingens ordre. Yderligere er sidstnævnte en samlings underordnede grænseflade. Det er en sorteret samling af objekter, der kan gemme duplikerede værdier. Derudover understøtter listen positionsadgang og indsættelse af medlemmer, fordi indsættelsesrækkefølgen er bevaret. Nu hvor vi har fået en liste over strenge, hvad enten det er en LinkedList eller en ArrayList, er vores mål at konvertere den til en række strenge i Java ved hjælp af forskellige metoder.

Metoder

  • ToArray()-metoden bruges
  • Get()-metoden bruges
  • Streams introduktion i Java 8

toArray()-metoden

Denne metode returnerer et objekt[]-array, hvis elementer er i samme rækkefølge som listens elementer. Når du udfører nogle handlinger, bruges casting til at angive typen af ​​hvert element.

Det er en anden teknik til at lave en række ud af en liste. Vi kan nemt konvertere en liste til et array ved at bruge toArray() metoden. Derudover returnerer toArray()-metoden et array, der indeholder alle listens elementer. Indtastningerne i det returnerede array er i samme rækkefølge som dem på listen.

Metoden toArray() er tilgængelig på List-objektet. Denne funktion tager et tomt array som en parameter og konverterer den aktuelle liste til et array, før det indsættes i det angivne array. Denne tilgang kan opdeles i to kategorier.

  • toArray()
  • toArray(T[] arr)

ToArray()-funktionen i List-grænsefladen har følgende syntaks:

public <T> T[] toArray(T[] a)

Metoden toArray() tager et array som input eller ingen og producerer et array, der indeholder alle listens medlemmer. Lad os se på et andet eksempel på at konvertere en liste til en matrix for at se, hvordan du kan bruge toArray()-metoden på listen. For at konvertere et listeobjekt til et array skal du bruge følgende kode.

  • Lav et listeobjekt ud af det.
  • Smid nogle ekstramateriale(elementer) ind.
  • Lav et tomt array til samme størrelse som den ArrayList, du lige har lavet.
  • Omgå den ovenfor oprettede matrix som input til toArray()-funktionen, når listen konverteres til en matrix.
  • Det sidste trin er at udskrive arrayets indhold.

Eksemplerne nedenfor demonstrerer konvertering af en liste over strenge og en liste over heltal til en matrix.

Konvertering af liste til array i Java (med eksempler)

import java.util.ArrayList;

public class ListToArrayConversion {
   public static void main(String args[]){
      ArrayList<String> computerList = new ArrayList<String>();
      computerList.add("HP");
      computerList.add("DELL");
      computerList.add("Chrome Book");

      System.out.println("List Contents ::"+list);
      String[] theArray = new String[list.size()];
      computerList.toArray(theArray);

      for(int i=0; i<myArray.length; i++){
         System.out.println("The item at the index "+i+" is ::"+theArray[i]);
      }
   }
}

Eksempel:Konvertering af en liste til række af strenge i Java

import java.util.ArrayList;
import java.util.List;

public class ConvertingArrayListToArray {
    public static void main(String[] args) {
        List<String> fruitsList = new ArrayList<String>();
        fruitsList.add("Mango");
        fruitsList.add("Water Melon");
        fruitsList.add("Oranges");

        String[] fruitsArray = new String[itemList.size()];
        finalArray = fruitsList.toArray(fruitsArray);

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

Vi kan konvertere en liste over heltal til en matrix af heltal ved hjælp af samme metode:

Eksempel:Konvertering af en liste til matrix af heltal i Java

import java.util.ArrayList;
import java.util.List;

public class ConvertArrayListToArray {
    public static void main(String[] args) {
        List<Integer> listOfIntegers = new ArrayList<Integer>();
        listOfIntegers.add(99);
        listOfIntegers.add(67);
        listOfIntegers.add(28);

        Integer[] arrayOfIntegers = new Integer[listOfIntegers.size()];
        finalArray = listOfIntegers.toArray(arrayOfIntegers);

        for(Integer i : finalArray)
            System.out.println(i);
    }
}

Eksempel:Oprettelse af en klasse for at konvertere en liste til en matrix

import java.io.*;  
import java.util.LinkedList;  
import java.util.List;  

class CodeConvertListToArray {  

  // The programs main() method

  public static void main(String[] args)  
  {  
    // creation of a linked list through the declaration of an object of List  
    List<String> namesList = new LinkedList<String>();  

    // using the lists's add() method to add elements in the linked list  
    namesList.add("Joan");  
    namesList.add("Brian");  
    namesList.add("Cartoon");  
    namesList.add("Mike");  
    namesList.add("Thompson");  

    // using the toArray() method for converting a list into an array  
    String[] arrayOfNames = namesList.toArray(new String[0]);  

    // printing every element in the given array  
    System.out.println("After converting List into an Array");  
    for (int j = 0; j < arrayOfNames.length; j++) {  
      System.out.println((j+1)+" arrays element  is "+arrayOfNames[j]);  
    }  
  }   
}

toArray(T[] arr)

Denne form af samme teknik accepterer et array, der allerede er defineret som en parameter.

Når arrayets størrelse er mere signifikant end eller lig med listens størrelse, tilføjes listens elementer til arrayet. Et nyt array vil blive konstrueret og udfyldt, hvis dette ikke er tilfældet. På den anden side er casting unødvendig, fordi parameterens type giver typen af ​​det returnerede array. Hvis et element på listen ikke konverteres til den givne type, produceres en ArrayStoreException.

import java.util.ArrayList;

public class ListToArray {

	public static void main(String[] args) {
    // A list of size 4 to be converted:
		ArrayList<Integer> list = new ArrayList<>();
		list.add(2);
		list.add(3);
		list.add(4);
		list.add(5);
		
    // Declaring an array of size 4:
		Integer[] arr = new Integer[4];
		
    // Passing the declared array as the parameter:
    list.toArray(arr);
		
    // Printing all elements of the array:
    System.out.println("Printing 'arr':");
		for(Integer i: arr)
      System.out.println(i);

    // Declaring another array of insufficient size:
    Integer[] arr2 = new Integer[3];

    // Passing the array as the parameter:
    Integer[] arr3 = list.toArray(arr2);

    // Printing the passed array:
    System.out.println("\n'arr2' isn't filled because it is small in size:");
    for(Integer i: arr2)
      System.out.println(i);
    
    // Printing the newly allocated array:
    System.out.println("\n'arr3' references the newly allocated array:");
    for(Integer i: arr3)
      System.out.println(i);
	}
}

En række strenge til liste

Du kan også vende tilbage fra et array til en liste. Vi bruger Arrays.asList til at opnå dette. Overvej følgende scenarie:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ConvertingArrayToList {
    public static void main(String[] args) {
        String[] subjectsArray = {"Introduction to Programming", "Data structures and algorithms", "Advanced database management system", "Computer Ethics"};
        List<String> subjectsList = new ArrayList(Arrays.asList(subjectsArray));

        for (String subjecItem : subjectsList) {
            System.out.println(subjecItem);
        }
    }
}

get() metode

Get()-metoden er en af ​​de mest ligetil processer til at konvertere en liste til en matrix. Vi kan nu få adgang til alle listeelementerne én efter én og tilføje dem til en matrix. Målet her er at bruge get() metoden. Vi kan bruge listemetoden nedenfor til at få alle elementer og indsætte dem i et array.

Returtype:Elementet på listen ved det angivne indeks.

Get()-funktionen i List-grænsefladen har følgende syntaks:

public E get(int index)

Elementet på den angivne position på listen returneres af get()-metoden. Lad os se på et eksempel på at konvertere en liste til en matrix for at se, hvordan vi kan bruge listens get()-metode.

Eksempel:Java-program til at konvertere en liste til et array

// Using get() method in a loop

// Importing required classes
import java.io.*;
import java.util.LinkedList;
import java.util.List;

// Main class
class Codeunderscored {

	// Main driver method
	public static void main(String[] args)
	{

		// Creating a LinkedList of string type by
		// declaring object of List
		List<String> listOfProgrammingLanguagues = new LinkedList<String>();

		// Adding custom element to LinkedList
		// using add() method
		listOfProgrammingLanguagues.add("PHP");
		listOfProgrammingLanguagues.add("C++");
		listOfProgrammingLanguagues.add("Python");
		listOfProgrammingLanguagues.add("Java");

		// Storing it inside array of strings
		String[] arrVal = new String[list.size()];

		// Conversion of an ArrayList to Array using the get() method
		for (int i = 0; i < listOfProgrammingLanguagues.size(); i++)
			arrVal[i] = listOfProgrammingLanguagues.get(i);

		// print the given elements of array on the console
		for (String str : arr)
			System.out.print( str + " ");
	}
}

Eksempel:Klasse for at konvertere en liste til en matrix

import java.io.*;  
    import java.util.LinkedList;  
    import java.util.List;  

    // create ListToArrayConversionExample class to convert a list into an array  
    class ListToArrayConversionExample {  
        // The programs main() method 
        public static void main(String[] args)  
        {  
             // creation of a  linked list through the declaration of an object of List  
             List<String> javaStudents = new LinkedList<String>();  
             // using the add() method of the list to add elements in the linked list  
             javaStudents.add("Ann");  
             javaStudents.add("Abraham");  
             javaStudents.add("Winny");  
             javaStudents.add("Bob");  
             javaStudents.add("Princes");  

             // get the lists' size and store it into lenOfList variable  
             int lenOfList = javaStudents.size();  
            
	 // declaration and the initialization of the array of type string to store list elements  
             String[] javaStudentsArray = new String[ lenOfList ];  
             // iterating through the list through the for loop and add all the elements into javaStudentsArray one by one to convert names list into an array  
             for (int i = 0; i < len; i++)  
                 javaStudentsArray[i] = javaStudents.get(i);  
             // print all the elements of the array  
             System.out.println("Conversion of a List into an Array");  
             for (int j = 0; j < javaStudentsArray.length; j++) {  
                 System.out.println((j+1)+" array element is : "+javaStudentsArray[j]);  
             }  
        }   
    }

Brug af Stream-klassen – introduceret i Java8

En anden fremgangsmåde er at konvertere en liste til et array ved hjælp af Stream-funktionen introduceret i Java8. ToArray()-funktionen i List-grænsefladen har følgende syntaks:

public <T> T[] toArray(T[] a)

Metoden toArray() tager enten en matrix eller ingen som et argument. Desuden returnerer den et array, der indeholder alle listens elementer. Stream.toArray()-metoden returnerer et array, der indeholder stream-posterne fra List.stream()-metoden. Der er to muligheder for at gøre det:

Brug af Streams sammen med en metodereference

List<String> languageList = Arrays.asList("Python","Kotlin", "C++","JavaScript", "Java");
String[] languageArray = languageList.stream().toArray(String[]::new);
System.out.println(Arrays.toString(languageArray));

Brug af lambda-udtryk med streams

List<String> languageList = Arrays.asList("Python","Kotlin", "C++","JavaScript", "Java");
String[] languageArray = languageList.stream().toArray(n -> new String[n]);
System.out.println(Arrays.toString(languageArray));

Lad os se på et andet eksempel på at konvertere en liste til en matrix for at se, hvordan du kan bruge toArray()-metoden på listen.

import java.io.*;  
import java.util.LinkedList;  
import java.util.List;  

//create ListToArrayConversion class to convert a list into an array  
class ListToArrayConversion {  
  // The programs main() method
  public static void main(String[] args)  
  {  
    // creation of a linked list through the declaration of an object of List  
    List<String> listOfNames = new LinkedList<String>();  
    // using the lists's add() method to add elements in the linked list  

    listOfNames.add("Jonah");  
    listOfNames.add("Mike");  
    listOfNames.add("Ann");  
    listOfNames.add("Faith");  
    listOfNames.add("Mery");  

    // using the stream() method to convert a list into an array  
    String[] arrayOfNames = listOfNames.stream().toArray(String[] ::new);  

    // print all the elements of the array  
    System.out.println("Results after converting a List into an Array");  
    for (int j = 0; j < arrayOfNames.length; j++) {  
      System.out.println((j+1)+" The array's element is: "+arrayOfNames[j]);  
    }  
  }   
}

Eksempel:Program, der demonstrerer konverteringen af ​​List til Array ved hjælp af stream

// Importing utility classes
import java.util.*;

// Main class
class CodeunderscoredStream {

	// Main driver method
	public static void main(String[] args)
	{

		// Creating an empty LinkedList of string type
		List<String> listLaptops = new LinkedList<String>();

		// Adding elements to above LinkedList
		// using add() method
		listLaptops.add("HP");
		listLaptops.add("Dell");
		listLaptops.add("Apple");
		listLaptops.add("IBM");
		listLaptops.add("Lenovo");
		listLaptops.add("Chrome Book");

		// Storing size of List
		int listSize = listLaptops.size();

		// Converting List to array via scope resolution
		// operator using streams
		String[] arrOfStreams = listLaptops.stream().toArray(String[] ::new);

		// Printing elements of array
		// using enhanced for loop
		for (String str : arrOfStreams)
			System.out.print(str + " ");
	}
}

Brug af Guava-biblioteket

Der er to varianter af brugen af ​​Guava Library som følger.

The FluentIterable-klassen i Guava-biblioteket

FluentIterable er en udvidet Iterable API, der giver lignende funktioner som Java 8s streams-bibliotek lidt anderledes. Målet er at skabe en flydende iterabel, der omslutter en iterabel liste og producerer en matrix med alle dens elementer i iterationssekvensen.

List<String> languagesList = Arrays.asList("Python","Kotlin", "C++","JavaScript", "Java");
String[] languageArray = FluentIterable.from(languagesList).toArray(String.class);
System.out.println(Arrays.toString(languageArray));

Iterables-klassen i Guava-biblioteket

ToArray()-funktionen i Guavas Iterables-klasse kopierer elementerne i en iterabel til en matrix.

List<String> languagesList = Arrays.asList("Python","Kotlin", "C++","JavaScript", "Java");
String[] languageArray = Iterables.toArray(languagesList, String.class);
System.out.println(Arrays.toString(languageArray));

Eksempel:Brug af Guava

@Test
public void givenUsingGuava() {
    Integer[] numArray = { 10, 11, 12, 13, 14, 15 };
    List<Integer> resultantList = Lists.newArrayList(numArray);
}

Brug af Commons-samlinger

Endelig vil vi bruge CollectionUtils fra Apache Commons Collections. For at udfylde elementerne i et array i en tom liste, skal du bruge addAll API:

@Test
public void usingCommonsCollections() {
    Integer[] numArray = { 10, 11, 12, 13, 14, 15 };
    List<Integer> resultantList = new ArrayList<>(6);
    CollectionUtils.addAll(resultantList, numArray);
}

Konklusion

I Java er konvertering mellem List og Array en typisk opgave. Funktionen .toArray() er den fineste og mest ligetil måde at transformere en liste til et array i Java. På samme måde kan vi bruge Arrays.asList()-metoden til at konvertere en liste tilbage til et array. Derudover kan vi også bruge stream()-metoden i Stream API til at konvertere en liste til et array i Java 8 og nyere.

I Java transformerer metoderne get() og toArray() almindeligvis en liste til et array. I sammenligning med metoderne get() og toArray() er stream()-teknikken ineffektiv.


Java tag