Java >> Java tutorial >  >> Java

Sådan konverteres sæt til liste i Java

Java

Java.util.Collection-grænsefladen er udvidet med Java Set, som er en del af java.util-pakken. Det aktiverer ikke duplikerede elementer og kan kun indeholde en null-komponent ad gangen.

Listen er en samlings underordnede grænseflade. Det er en sorteret samling af objekter, der kan gemme duplikerede værdier. Listen understøtter endvidere positionsadgang og indsættelse af medlemmer, fordi indsættelsesrækkefølgen bevares. Klasserne ArrayList, LinkedList, Vector og Stack implementerer også List Interface.

I Java er en liste en ordnet samling af data, hvorimod et sæt er en uordnet samling. Et sæt kan ikke have duplikerede poster, mens en liste kan. Begge datastrukturer er nyttige i en række forskellige situationer. Det er nyttigt at vide, hvordan man forvandler et sæt til en liste. For eksempel kan den konvertere data, der ikke er i nogen bestemt rækkefølge, til data, altså.

Oprettelse af et nyt sæt

Lad os starte med at oprette et sæt og derefter tilføje nogle elementer til det.

import java.util.*;
 
public class Main {
 
    public static void main(String[] args)
    {
        Set<Integer> intList = new HashSet<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        intList.add(1);
        System.out.println(intList);
    }
}

HashSets add()-metode tilføjer komponenterne til sættet. Det er vigtigt at bemærke, at elementerne er forskellige. Fordi sættene er uordnede, er der ingen måde at erhverve komponenterne i den rækkefølge, de blev indsat.

Java-konvertering af et sæt til en liste

Lad os lave en liste ud af sættet. Der er flere muligheder for at gøre det. Faktisk er hver metode adskilt fra de andre. Dog er forskellene mindre.

Konstruktør af en liste med et sæt-argument

Den enkleste måde at konvertere et sæt til en liste på er at bruge sættet som et argument, når du bygger listen. Konstruktøren påkaldes på grund af dette, og konstruktøren tager sig af resten. I Java har samlinger en konstruktør, hvor det direkte sæt leveres til at producere en liste.

Algoritme:

  • Få det sæt, du har til hensigt at transformere.
  • Ved at levere sættet som et argument til konstruktøren, kan du lave en liste.
  • Returner den oprettede liste.
import java.util.*;
 
public class Main {
 
    public static void main(String[] args)
    {
        Set<Integer> intList = new HashSet<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        intList.add(1);
 
     List<Integer> arr = new ArrayList<>(intList);
     System.out.println(arr);
     System.out.println(arr.get(1));
 
    }
}

Elementerne er nu arrangeret, fordi sættet er blevet ændret til en liste. Det betyder, at vi kan hente detaljer ved at indeksere ved hjælp af get()-metoden.

Eksempel:Program til konvertering af et sæt til liste i Java
import java.util.*;
import java.util.stream.*;

class Codeunderscored {

	// Generic function to convert set to list
	public static <T> List<T> convertSetToList(Set<T> set)
	{
		// create a list from Set
		List<T> list = new ArrayList<>(set);

		// return the list
		return list;
	}

	public static void main(String args[])
	{

		// Create a Set using HashSet
		Set<String> laptopHashSet = new HashSet<String>();

		// Add elements to set
		laptopHashSet.add("Geeks");
		laptopHashSet.add("For");
		laptopHashSet.add("Geeks");
		laptopHashSet.add("Example");
		laptopHashSet.add("Set");

		// Print the Set
		System.out.println("Set: " + laptopHashSet);

		// construct a new List from Set
		List<String> list = convertSetToList(laptopHashSet);

		// Print the List
		System.out.println("List: " + list);
	}
}
Eksempel:Brug af en konstruktør
import java.util.*;
import java.util.stream.*;
  
class example {
  
    // Generic function to convert set to list
    public static <T> List<T> convertSetToList(Set<T> set)
    {
        // create a list from Set
        List<T> list = new ArrayList<>(set);
  
        // return the list
        return list;
    }
  
    public static void main(String args[])
    {
  
        // Create a Set using HashSet
        Set<String> codeSet = new HashSet<String>();
  
        // Add elements to set
        codeSet.add("Code");
        codeSet.add("Underscored");
        codeSet.add("Set");
        codeSet.add("to");
        codeSet.add("list");
        codeSet.add("example");
  
        // Print the Set
        System.out.println("Set: " + codeSet);
  
        // construct a new List from Set
        List<String> list = convertSetToList(hash_Set);
  
        // Print the List
        System.out.println("List: " + list);
    }
}

Brug af en traditionel sløjfe

For eksplicit at kopiere elementerne fra sættet til listen, kan vi bruge det gode gamle som en loop. Den brute force eller naive metode er at lave en tom liste og derefter tilføje hvert element i sættet til det.

Algoritme:

  • Få det sæt, der vil blive transformeret.
  • Lav en tom liste.
  • Udfyld listen med hvert element fra sættet.
  • Returner den resulterende liste, der er oprettet.
import java.util.*;
 
public class Main {
 
    public static void main(String[] args)
    {
        Set<Integer> intList = new HashSet<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        intList.add(1);
 
     List<Integer> arr = new ArrayList<>(intList);
        for (int i : a)
            arr.add(i);
        System.out.println(arr);
        System.out.println(arr.get(1));
    }   
}

For-løkken itererer på tværs af sættet og føjer hvert element til listen.

Eksempel:Program til konvertering af et sæt til liste i Java 8
import java.util.*;
import java.util.stream.*;

class Codeunderscored {

	// Generic function to convert set to list
	public static <T> List<T> convertSetToList(Set<T> set)
	{
		// create an empty list
		List<T> list = new ArrayList<>();

		// push each element in the set into the list
		for (T t : set)
			list.add(t);

		// return the list
		return list;
	}

	public static void main(String args[])
	{

		// Create a Set using HashSet
		Set<String> hash_Set = new HashSet<String>();

		// Add elements to set
		hash_Set.add("Code");
		hash_Set.add("For");
		hash_Set.add("Underscored");
		hash_Set.add("Python");
		hash_Set.add("Set");

		// Print the Set
		System.out.println("Set: " + hash_Set);

		// construct a new List from Set
		List<String> list = convertSetToList(hash_Set);

		// Print the List
		System.out.println("List: " + list);
	}
}
Eksempel 3:Brug af en traditionel sløjfe
import java.util.*;
import java.util.stream.*;
  
class example {
    
    // Generic function to convert set to list
    public static <T> List<T> convertSetToList(Set<T> set)
    {
        // create an empty list
        List<T> list = new ArrayList<>();
  
        // push each element in the set into the list
        for (T t : set)
            list.add(t);
  
        // return the list
        return list;
    }
    public static void main(String args[])
    {
  
        // Create a Set using HashSet
        Set<String> codeSet = new HashSet<String>();
  
        // Add elements to set
        codeSet.add("Code");
        codeSet.add("Underscored");
        codeSet.add("Set");
        codeSet.add("to");
        codeSet.add("list");
        codeSet.add("example");
  
        // Print the Set
        System.out.println("Set: " + codeSet);
  
        // construct a new List from Set
        List<String> list = convertSetToList(codeSet);
  
        // Print the List
        System.out.println("List: " + list);
    }
}

Brug addAll()-funktionen til at tilføje alle elementer til en liste.

AddAll() er en listemetode, der tilføjer flere værdier til listen på én gang. Denne handling kan være bekendt for dig fra dens brug ved sammenlægning af to lister. addAll() kan også tilføje et sæts elementer til en liste.

import java.util.*;
 
public class Main {
 
    public static void main(String[] args)
    {
        Set<Integer> intList = new HashSet<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        intList.add(1);
 
     List<Integer> arr = new ArrayList<>();
        arr.addAll(intList);
        System.out.println(arr);
        System.out.println(arr.get(1));
    }
}

}

Collect()-metoden for Stream API

Fra Java 8 understøttes Stream.collect(). Alle Stream-elementer samles til et List-objekt via ToList-samleren. I Java 8 kan du konvertere et sæt til en liste ved at bruge Set.stream() til at konvertere sættet til en sekventiel Stream og derefter bruge en Collector til at samle input-elementerne til en ny Liste.

// This is Generic method to convert a set to a list
public static <T> List<T> convertToList(Set<T> set) {
    return set.stream().collect(Collectors.toList());
}

Vi kan bruge Collectors.toCollection() til at angive den ønskede samling, fordi Collectors.toList() ikke garanterer typen af ​​den returnerede liste:

// This a Generic method to convert a set to `ArrayList`
public static <T> List<T> convertToList(T[] arr) {
    return set.stream().collect(Collectors.toCollection(ArrayList::new));
}

Algoritme:

  • Få det HashMap, der vil blive transformeret.
  • Lav en stream ud af sættet
  • Konverter sættet til en liste, og føj det til din samling.
  • Returner den liste, der blev indsamlet.
import java.util.*;
import java.util.stream.Collectors;
 
 
public class Main {
 
    public static void main(String[] args)
    {
        Set<Integer> intList = new HashSet<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        intList.add(1);
 
     List<Integer> arr;
 
        arr = intList.stream().collect(Collectors.toList());
        System.out.println(arr);
        System.out.println(arr.get(1));
    }
}

Den returnerede listes type, mutabilitet, serialiserbarhed og trådsikkerhed er ikke garanteret. Det fremgår af dokumentationen til stream.collect(). Brug toCollection(Supplier), hvis du har brug for større kontrol over den returnerede liste.

Brug toCollection(ArrayList::new) til at angive listetypen

pubimport java.util.*;
import java.util.stream.Collectors;
 
 
public class Main {
 
    public static void main(String[] args)
    {
        Set<Integer> intList = new HashSet<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        intList.add(1);
 
     List<Integer> arr;
 
  arr = intList.stream().collect(Collectors.toCollection(ArrayList::new));
        System.out.println(arr);
        System.out.println(arr.get(1));
    }
}

Eksempel:Program til at konvertere et HashMap til TreeMap i Java

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

class Codeunderscored {

	// Generic function to convert set to list
	public static <T> List<T> convertSetToList(Set<T> set)
	{
		// create a list from Set
		return set

			// Create stream from the Set
			.stream()

			// Convert the set to list and collect it
			.collect(Collectors.toList());
	}

	public static void main(String args[])
	{

		// Create a Set using HashSet
		Set<String> languageSet = new HashSet<String>();

		// Add elements to set
		languageSet.add("Java");
		languageSet.add("Python");
		languageSet.add("HTML");
		languageSet.add("JavaScript");
		languageSet.add("Kotlin");

		// Print the Set
		System.out.println("Set: " + languageSet);

		// construct a new List from Set
		List<String> list = convertSetToList(languageSet);

		// Print the List
		System.out.println("List: " + list);
	}
}

Brug af List.copyOf()-funktionen

CopyOf()-metoden er tilgængelig i Java 10 og nyere. Metoden returnerer en uforanderlig liste, der indeholder elementerne i den leverede samling i den rækkefølge, de blev gentaget. Der kan ikke være nogen null-elementer på listen. Hvis sættet inkluderer ' null ', kaster metoden en nul pointer-undtagelse.

import java.util.*;
import java.util.stream.Collectors;
 
 
public class Main {
 
    public static void main(String[] args)
    {
        Set<Integer> intList = new HashSet<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        intList.add(1);
 
     List<Integer> arr;
 
        arr = List.copyOf(intList);
        System.out.println(arr);
        System.out.println(arr.get(1));
    }
}

Forsøg på at konvertere et sæt til en liste efter tilføjelse af et nul:

import java.util.*;
import java.util.stream.Collectors;
 
public class Main {
 
    public static void main(String[] args)
    {
        Set<Integer> intList  = new HashSet<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        intList.add(1);
        intList.add(null);
 
     List<Integer> arr;
 
        arr = List.copyOf(intList);
        System.out.println(arr);
        System.out.println(arr.get(1));
    }
}

Hvis du prøver at tilføje et nyt element til en uforanderlig liste, får du en fejl, der ligner denne. For at konvertere et sæt med et null-element til en liste, skal du bruge addAll()-metoden:

import java.util.*;
import java.util.stream.Collectors;
 
 
public class Main {
 
    public static void main(String[] args)
    {
        Set<Integer> intList = new HashSet<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        intList.add(1);
        intList.add(null);
 
     List<Integer> arr = new ArrayList<>();
     arr.addAll(intList);
 
      //  arr = List.copyOf(intList);
        System.out.println(intList);
        System.out.println(arr.get(1));
    }
}

Det er værd at bemærke, at null er øverst på listen.

Eksempel:Brug af funktionen List.copyOf()

public void usingJava10ToConvertSetToList() {
    Set<Integer> positionSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
    List<Integer> targetList = List.copyOf(positionSet);
}

Brug af Guava Library List.newArrayList(set)

Lists.newArrayList(set) genererer en foranderlig ArrayList-instans ved hjælp af det leverede sæts elementer. Hvis vi skal tilføje eller fjerne elementer senere, eller hvis nogle af komponenterne er nul, er dette bedre.

// This is a Generic method to convert a set to a list
public static <T> List<T> convertToList(Set<T> set) {
    return Lists.newArrayList(set);
}

ImmutableList.copyOf er en anden mulighed, der returnerer en uforanderlig liste, der indeholder det medfølgende sæt af elementer. Når mutabilitet ikke er påkrævet, bør du bruge dette.

// This is a Generic method to convert a set to a list
public static <T> List<T> convertToList(Set<T> set) {
    return ImmutableList.copyOf(set);
}

Algoritme:

  • Få det sæt, der vil blive transformeret.
  • Opret en ny liste ved hjælp af lister.
  • Du kan oprette en array-liste ved at levere sættet som et argument til Guava-bibliotekets newArrayList()-funktion.
  • Returner den liste, der blev oprettet.
Eksempel:Program til at konvertere HashMap til TreeMap i Java
import java.util.*;
import java.util.stream.*;

class Codeunderscored {

	// Generic function to convert set to list
	public static <T> List<T> convertSetToList(Set<T> set)
	{
		// create a list from Set
		return Lists.newArrayList(set);
	}

	public static void main(String args[])
	{

		// Create a Set using HashSet
		Set<String> languageSet = new HashSet<String>();

		// Add elements to set
		languageSet.add("Java");
		languageSet.add("Python");
		languageSet.add("HTML");
		languageSet.add("JavaScript");
		languageSet.add("Kotlin");

		// Print the Set
		System.out.println("Set: " + languageSet);

		// construct a new List from Set
		List<String> list = convertSetToList(languageSet);

		// Print the List
		System.out.println("List: " + list);
	}
}
Eksempel:Konvertering ved hjælp af Guava

public void usingGuavaToConvertSetToList() {

    Set<Integer> positionList = Sets.newHashSet(0, 1, 2, 3, 4, 5);
    List<Integer> targetList = Lists.newArrayList(positionList);
}

Det minder ret meget om java-teknikken, men med mindre kodeduplikering.

Brug af Apache Commons-samlingerne

Derefter, for at konvertere mellem en liste og et sæt, bruger vi Commons Collections API:

public void usingCommonsCollectionsToConvertSetToList() {

Set<Integer> positionSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
List<Integer> targetList = new ArrayList<>(6);
CollectionUtils.addAll(targetList, positionSet);

}

Konklusion

Java.util.Collection-grænsefladen er udvidet med et Java-sæt, som er en del af java.util-pakken. Der kan ikke være duplikerede elementer i et Java-sæt, og kun ét null-element er tilladt. Yderligere er en Java-liste en samling af ting arrangeret i en bestemt rækkefølge. Faktisk kan en Java-liste, i modsætning til et Java-sæt, have duplikerede værdier.

Vi så nogle meget kreative tilgange til at konvertere et sæt til en liste. Det er afgørende at være opmærksom på hver tekniks type liste. CopyOf()-metoden opretter for eksempel en uforanderlig liste, der ikke kan indeholde null-elementer. Stream.collect() giver på den anden side ingen garantier. Ikke desto mindre er constructor- og addAll()-funktionerne de mest pålidelige af batchen.


Java tag