Java >> Java tutorial >  >> Java

Sådan konverteres Array til List i Java

De to mest betydningsfulde datastrukturer i Java er Array og List. Vi lærer, hvordan man konverterer et Java-array til en liste i dette afsnit. Vi har også skrevet Java-applikationer, der bruger adskillige Java-teknikker til at omdanne et array til en liste.

Java-array til listekonvertering

Et array i Java er en beholder til flere værdier af samme datatype. Objekter og primitive typer kan begge lagres i et array. Arrayets definition bestemmer det. Arrayets værdier gemmes i den samme hukommelsesadresse, hvis arraydefinitionen er af primitiv type. Hvis en samling indeholder objektelementer, bruges heap-sektionen til at gemme dem.

En liste er en samling af grænseflader i Java, der hører til Java Collections frameworket. Den opretholder indsættelsesrækkefølgen, mens den lagrer elementer i form af objekter på en ordnet måde. Desuden gør det os i stand til at holde styr på duplikerede værdier.

Listegrænsefladen er implementeret af klasserne ArrayList, LinkedList, Vector og Stack. Følgende er de fem tilgængelige metoder i Java til at konvertere et array til en liste:

  • Native Method eller Brute Force-metoden
  • Brug af Arrays.asList()-metoden
  • Brug af metoden Collections.addAll()
  • Brug af Java 8 Stream API
  • Brug af metoden Guava Lists.newArrayList()

Ved brug af den oprindelige metode

Det er den mest ligetil måde at konvertere en Java Array til en liste. I denne teknik bygger vi først en tom liste og tilføjer derefter alle arrayets elementer til den. Lad os se på et eksempel.

 import java.util.*;   
public class ArrayToList
{   
  public static void main(String args[])   
  {   
    //creating an array   
    String languageArray[] = { "PHP", "JavaScript", "Python", "Kotlin", "Java", "C++", "Ruby", "Swift", "Go"};   
    //prints the array before conversion  
    System.out.println("Languages Array before conversion: "+ Arrays.toString(languageArray));   
    //call to the generic method responsible for  converting Array into List  
    List<String> languagesList = ArrayToListConversion(languageArray);   
    //print the Languages List   
    System.out.println("Languages Array as List: " + languagesList);   
  }       
  //call to the generic method responsible for  converting Array into List  
  public static <T> List<T> ArrayToListConversion(T array[])   
  {   
    //creating the constructor of the List class  
    List<T> langList = new ArrayList<>();   
    //using the for-each loop in  iterating throught  the array elements
    for (T t : languageArray)   
    {   
      //adding each element to the List  
      langList.add(t);   
    }   
    //returns the list converted into Array  
    return list;   
  }   
}  

Ved brug af arrays.asList()-metoden

Det er en metode i Java Arrays-klassen, som er en del af Java.util-pakken. Når vi kombinerer metoderne asList() og Collection.toArray(), har vi en bro mellem array- og samlingsbaserede API'er.

Syntaksen er som følger:

public static <T> List<T> asList(T... a)

Metoden tager et array som en parameter, som bruges til at sikkerhedskopiere langList. Det medfølgende array returneres som en serialiserbar listevisning med fast størrelse. Lad os se på et eksempel.

import java.util.*;   
public class ArrayToList
{   
  public static void main(String args[])   
  {   
    //creating an array to be converted  
    String languageArray[] = { "PHP", "JavaScript", "Python", "Kotlin", "Java", "C++", "Ruby", "Swift", "Go"};   

    //prints array before conversion  
    System.out.println("Language Array before conversion: "+ Arrays.toString(languageArray));   
    //call to the generic method responsible for  converting Array into List  
    List<String> langList = ArrayToListConversion(languageArray);   
    //prints the List  
    System.out.println("Language Array after conversion: " + langList);   
  }   
  // Generic function responsible for converting an array to a list
  public static <T> List<T> ArrayToListConversion(T arr[])   
  {   
    //invoke the method asList() and pass the array to be converted  
    List<T> langList = Arrays.asList(languageArray);   
    //returns the list  
    return langList;   
  }   
}  

Ved brug af collections.addAll()-metoden

Det er Java Collections-klassens funktion. Det er en del af Java.util-pakken. addAll() er en metode leveret af klassen. Metoden kan bruges til at transformere et array til en liste. Den udfylder den medfølgende samling med alle elementerne. Elementer kan specificeres enkeltvis eller i form af et array. Det er det samme som Arrays.asList(elements) + c.addAll(Arrays.asList(elements) + c.addAll(Arrays.asList(elements))

Det er en hurtigere implementering end den forrige.

Syntaksen er som følger:

public static <K> boolean addAll(Collection<? super K> c, K... elements)  

Det tager to parametre i betragtning:

  • c:Det er et sæt elementer, der skal tilføjes.
  • elementer:Elementerne skal placeres i c.

Hvis samlingen ændres på grund af opkaldet, returnerer den sand. Følgende undtagelser er kastet:

  • UnsupportedOperationException udløses, hvis parameteren c ikke understøtter tilføjelsesoperationen.
  • NullPointerException udløses, hvis et eller flere af de angivne matrixmedlemmer har nulværdier, og c tillader ikke null-elementer.
  • IllegalPointerException udløses, hvis et array-element forhindrer det i at blive indsat i parameteren c.

Lad os se på et eksempel.

import java.util.*;   
public class ArrayToListExample3  
{   
  public static void main(String args[])   
  {   
    //creating an Array to be converted  
    String languageArray[] = { "PHP", "JavaScript", "Python", "Kotlin", "Java", "C++", "Ruby", "Swift", "Go"};   
    //prints the Array   
    System.out.println("Languages Array before conversion: "+ Arrays.toString(languageArray));   
    //method calling  
    List<String> langList = ArrayToListConversion(languageArray);   
    //print the List   
    System.out.println("Languages Array after conversion: " + langList);   
  }       
  //call to the generic method responsible for  converting Array into List  
  public static <T> List<T> ArrayToListConversion(T arr[])   
  {   
    //creating the constructor of thr List class  
    List<T> langList = new ArrayList<>();   
    //the method adds Array to the List  
    Collections.addAll(langList, languageArray);   
    //returns the langList  
    return langList;   
  }   
}  

Brug af Stream API i Java 8

Stream API i Java 8 giver dig mulighed for at manipulere samlinger af objekter. Det er et sæt metoder, der kan kombineres for at få det ønskede resultat. Det er vigtigt at huske, at den oprindelige datastruktur ikke påvirkes. Det genererer output ved hjælp af pipelinede metoder. Du kan få strømmen på en række forskellige måder. I det følgende eksempel har vi dog brugt Arrays.stream(Object[]) til at gøre det.

I en encounter-metode returnerer Collectors.toList()-metoden en Collector, der samler inputkomponenterne til en nygenereret liste.

Syntaksen er som følger:

public static <K> Collector<K,?,List<K>> toList()  

Hvor K angiver den elementtype, vi har leveret. Metoden giver ikke garantier for type, mutabilitet, trådsikkerhed eller serialisering. Lad os bruge Stream API til at konvertere et array til en liste i et Java-program.

import java.util.*;   
import java.util.stream.Collectors;  
public class ArrayToList 
{   
  //call to the generic method responsible for  converting Array into List  
  public static <T> List<T> ArrayToListConversion(T arr[])   
  {   
    //is responsible for creating a list from the Array given and returns a corresponding List  
    return Arrays.stream(arr).collect(Collectors.toList());   
  }   
  public static void main(String args[])   
  {   
    //array creation to convert into a List  
    String languageArray[] = { "PHP", "JavaScript", "Python", "Kotlin", "Java", "C++", "Ruby", "Swift", "Go"};   
    //prints the Array before conversion  
    System.out.println("Array: "+ Arrays.toString(languageArray));   
    //call to the method created above and storing the elements into the List object  
    List<String> langList = ArrayToListConversion(languageArray);   
    //prints the langList   
    System.out.println("List: " + langList);   
  }   
}   

Brug af Guava Lists.newArrayList()

Guava-lister er en fantastisk måde at organisere dine data på. Den tilhører pakken com.google.common.collect og er en metode i klassen Lists. NewArrayList()-metoden for klassen genererer et foranderligt tomt ArrayList-objekt med elementerne i det leverede array.

Syntaksen er som følger:

public static <E> ArrayList<E> newArrayList(E... elements)

For Java 6 og tidligere versioner er metoden newArrayList() tilgængelig. Det er forældet i nyere versioner. Vi bruger ArrayList-konstruktøren direkte i stedet for ovenstående teknik.

import static com.google.common.collect.Lists.*;   
import java.util.*;   
public class ArrayToList 
{   
  public static void main(String args[])   
  {   
    //creation of an Array for conversion into a List  
    String languageArray[] = { "PHP", "JavaScript", "Python", "Kotlin", "Java", "C++", "Ruby", "Swift", "Go"};     
    //prints the Array before conversion  
    System.out.println("Array: "+ Arrays.toString(languageArray));   
    //convert the Array to List   
    List<String> langList = ArrayToListConversion(languageArray);   
    //prints the langList   
    System.out.println("List: " + langList);   
  }  
  // Generic function responsible for converting an array to a list
  public static <T> List<T> ArrayToListConversion(T arr[])   
  {   
    //creates a List from the specified Array   
    return Lists.newArrayList(languageArray);   
  }   
}  

Eksempler:Brug af Brute Force-tilgangen

// Program for converting an Array to a List

import java.util.*;
import java.util.stream.*;

class Codeunderscored {

	// Generic function responsible for converting an array to a list
	public static <T> List<T> codeConvertArrayToList(T array[])
	{

		// empty List creation
		List<T> list = new ArrayList<>();

		// Iterate through the array
		for (T t : array) {
			// Add each element into the list
			list.add(t);
		}

		// Return the converted List
		return list;
	}

	public static void main(String args[])
	{
		// Create an Array
		String laptopsArray[]= { "Chromebook", "DELL", "Apple", "HP", "Toshiba" };

		// Print the Array
		System.out.println("Array: "+ Arrays.toString(array laptopsArray

		// convert the Array to List
		List<String> laptopsList = convertArrayToList(laptopsArray);

		// Print the List
		System.out.println("List of Laptops: " + laptopsList);
	}
}

Eksempel:Brug af metoden Arrays.asList()

// Java Program to convert
// Array to List

import java.util.*;
import java.util.stream.*;

class Codeunderscode {

	// Generic function responsible for converting an array to a list
	public static <T> List<T> codeConvertArrayToList(T array[])
	{

		// pass the array
 as parameter in the constructor to create the list
		List<T> list = Arrays.asList(array);

		// Return the converted List
		return list;
	}

		public static void main(String args[])
	{
		// Create an Array
		String laptopsArray[]= { "Chromebook", "DELL", "Apple", "HP", "Toshiba" };

		// Print the Array
		System.out.println("Array: "+ Arrays.toString(array laptopsArray

		// convert the Array to List
		List<String> laptopsList = convertArrayToList(laptopsArray);

		// Print the List
		System.out.println("List of Laptops: " + laptopsList);
	}
}

Eksempel:Brug af Collections.addAll()

// Java Program to convert
// Array to List

import java.util.*;
import java.util.stream.*;

class Codeunderscored {

// Generic function responsible for converting an array to a list
	public static <T> List<T> codeConvertArrayToList(T array[])
	{

		// pass the array
 as parameter in the constructor to create the list
		List<T> list = new ArrayList<>();

		// Add the array to list
		Collections.addAll(list, array);

		// Return the converted List
		return list;
	}

		public static void main(String args[])
	{
		// Create an Array
		String laptopsArray[]= { "Chromebook", "DELL", "Apple", "HP", "Toshiba" };

		// Print the Array
		System.out.println("Array: "+ Arrays.toString(array laptopsArray

		// convert the Array to List
		List<String> laptopsList = convertArrayToList(laptopsArray);

		// Print the List
		System.out.println("List of Laptops: " + laptopsList);
	}
}

Eksempel:Brug af Java 8 Stream API

// Java Program to convert
// Array to List in Java 8

import java.util.*;
import java.util.stream.*;

class Codeunderscored {

	// Generic function responsible for converting an array to a list
	public static <T> List<T> codeConvertArrayToList(T array[])
	{
		// list creation from an array
		return Arrays.stream(array).collect(
			Collectors.toList());
	}

		public static void main(String args[])
	{
		// Creation of an Array
		String laptopsArray[]= { "Chromebook", "DELL", "Apple", "HP", "Toshiba" };

		// Print the Array
		System.out.println("Array: "+ Arrays.toString(array laptopsArray

		// convert the Array to List
		List<String> laptopsList = convertArrayToList(laptopsArray);

		// Print the List
		System.out.println("List of Laptops: " + laptopsList);
	}
}

                                                      

Eksempel:Brug af Guava Lists.newArrayList()

// Java Program to convert
// Array to List in Java 8

import static com.google.common.collect.Lists.*;

import java.util.*;
import java.util.stream.*;

class Codeunderscored {

	// Generic function responsible for converting an array to a list
	public static <K> List<K> convertArrayToList(K array[])
	{
		// creation of a list from the Array
		return Lists.newArrayList(array);
	}

		public static void main(String args[])
	{
		// Create an Array
		String laptopsArray[]= { "Chromebook", "DELL", "Apple", "HP", "Toshiba" };

		// Print the Array
		System.out.println("Array: "+ Arrays.toString(array laptopsArray

		// convert the Array to List
		List<String> laptopsList = convertArrayToList(laptopsArray);

		// Print the List
		System.out.println("List of Laptops: " + laptopsList);
	}
}

Konklusion

Et array peger på en samling af variabler med lignende type med et fælles navn. Afhængigt af arrayets definition kan den indeholde primitive datatyper og objekter. De faktiske værdier af primitive datatyper lagres i sammenhængende hukommelsesområder. De rigtige objekter gemmes i en heap-sektion for objekter i en klasse.

Samlingen har en underordnet interface kaldet List. Det er ikke kun en sorteret samling af objekter, men det kan også gemme duplikerede værdier. Derudover understøtter Listen positionsadgang og indsættelse af medlemmer, fordi indsættelsesrækkefølgen bevares. Desuden implementerer klasserne ArrayList, LinkedList, Vector og Stack List Interface.

Java Arrays-klassen har et par nyttige metoder. Arrays.asList() er en hjælpemetode, der giver os mulighed for at konvertere et array af objekter til en liste over objekter. Eksemplerne, vi har dækket i denne artikel, viser, hvordan man konverterer et array til et listeobjekt. Andre tilgange, du kan bruge, omfatter:Den oprindelige metode, ved hjælp af Collections.addAll()-metoden, brug af Java 8 Stream API og brug af Guava Lists.newArrayList()-metoden.


Java tag