covert list array
W tym samouczku wyjaśniono, jak przekonwertować listę Java na tablicę i inne kolekcje. Zawiera przykłady konwersji listy na tablicę, ciąg, zestaw i odwrotnie:
W naszych wcześniejszych samouczkach omawialiśmy szczegóły kolekcji list. Widzieliśmy różne operacje na liście, iteratory itp. Mając listę, możemy przekonwertować tę listę na dowolne inne kolekcje lub struktury danych, takie jak łańcuchy, tablice, ArrayList, set itp.
=> Odwiedź tutaj ekskluzywną serię samouczków szkoleniowych Java.
Czego się nauczysz:
Lista konwersji
W rzeczywistości przenosimy elementy z jednej kolekcji / struktury do innej, a robiąc to, zmieniamy układ elementów, ponieważ każda kolekcja lub struktura danych ma swój własny układ.
W tym samouczku omówimy kilka konwersji z listy na inne struktury danych i na odwrót.
Konwertuj listę na ciąg
Możesz łatwo przekonwertować listę elementów na jej reprezentację łańcuchową. Zwykle będziesz chciał przekonwertować listę ciągów lub znaków na reprezentację ciągu.
Istnieje wiele metod konwersji listy na łańcuch. Najpopularniejsze z nich omówiono poniżej.
# 1) Korzystanie z metody toString
Jest to najprostsza metoda konwersji listy na łańcuch. W tej metodzie po prostu używasz metody „toString” na liście, która konwertuje listę na ciąg znaków.
Poniższy program przedstawia implementację metody toString.
import java.util.Arrays; import java.util.List; // Convert List of Characters to String in Java class Main { public static void main(String() args) { // create and initialize a character list List strList = Arrays.asList('H', 'e', 'l', 'l', 'o'); //convert list to string using toString method System.out.println('List converted to string representation:
' + strList.toString()); //replace comma between characters with blanks String string = strList.toString() .substring(1, 3 * strList.size() - 1) .replaceAll(', ', ''); // print string System.out.println('String representation by removing delimiters:
' + string); } } Wynik:
W tym programie można zobaczyć, że po przekonwertowaniu listy znaków na reprezentację w postaci łańcucha, ciąg jest dalej udoskonalany poprzez usunięcie z niego znaków ograniczających i przedstawienie go jako pojedynczego słowa.
# 2) Korzystanie z klasy Collectors
Począwszy od języka Java 8, można używać strumieniowych interfejsów API z klasą „Collectors”, aby przekonwertować listę na ciąg.
Przykład:
import java.util.stream.Collectors; import java.util.Arrays; import java.util.List; class Main { public static void main(String() args) { // create and initialize list List strList = Arrays.asList('W', 'o', 'r', 'l','d'); // convert list to string using collect and joining() method String string= strList.stream().map(String::valueOf).collect(Collectors.joining()); // print string System.out.println('List converted to string:' + string); } } Wynik:
W powyższym programie korzystamy ze strumieniowych API, mapujemy wartości, a następnie wykorzystujemy metodę joining () klasy Collectors i konwertujemy listę na string.
# 3) Korzystanie z klasy StringBuilder
Trzecią metodą konwersji listy na ciąg jest użycie obiektu StringBuilder. Tutaj każdy element na liście jest dołączany do obiektu StringBuilder przy użyciu pętli. Następnie obiekt StringBuilder jest konwertowany na jego reprezentację w postaci ciągu przy użyciu metody toString.
Sprawdź poniższy program do demonstracji.
import java.util.Arrays; import java.util.List; class Main { public static void main(String() args) { // create and initialize the list List strList = Arrays.asList('I', 'n', 'd', 'i', 'a'); // object of stringBuilder StringBuilder sb = new StringBuilder(); // use append method to append list element to StringBuilder object for (Character ch : strList) { sb.append(ch); } // convert StringBuilder object to string using toString() String string = sb.toString(); // print string System.out.println('List converted to string: ' + string); } } Wynik:
Powyższy program pokazuje użycie obiektu StringBuilder, do którego dołączane są elementy z listy. Następnie obiekt jest konwertowany na łańcuch.
Konwertowanie listy na tablicę
Mając listę elementów, musisz przekonwertować tę listę na tablicę. Aby to zrobić, możesz użyć dowolnej z metod opisanych poniżej.
# 1) Korzystanie z toArray
Najprostszym sposobem konwersji listy na tablicę jest użycie metody listy „toArray”.
Poniższy program przedstawia tę implementację metody toArray.
import java.util.*; public class Main { public static void main(String() args) { //create and initialize list List strList = new LinkedList(); strList.add('This'); strList.add('is'); strList.add('Java'); strList.add('Tutorial'); System.out.println('The given list:' + strList); //use toArray method to convert list to array String() strArray = strList.toArray(new String(0)); //print the array System.out.println('The Array from List: '); for (String val : strArray) System.out.print(val + ' '); } } Wynik:
W powyższym programie przekonwertowaliśmy listę ciągów na tablicę ciągów przy użyciu metody „toArray”.
# 2) Korzystanie ze strumienia Java 8
najlepsze oprogramowanie do odzyskiwania danych dla systemu Windows
Następną metodą konwersji listy na tablicę jest użycie strumieniowych interfejsów API języka Java 8. W tym przypadku lista jest najpierw konwertowana na strumień, a następnie za pomocą funkcji stream (). ToArray jest konwertowana na tablicę.
Poniższy program Java przedstawia tę konwersję.
import java.util.*; class Main { public static void main (String()args) { //create and initialize the list List l_list = new LinkedList (); l_list.add ('Software'); l_list.add ('Testing'); l_list.add ('Help'); l_list.add ('Tutorial'); System.out.println('The given list:' + l_list); //Convert list to array using stream and toArray methods String() str_array = l_list.stream ().toArray (String()::new); //print the array System.out.println('The Array converted from list : '); for (String val:str_array) System.out.print (val + ' '); } } Wynik:
Powyższy program wykorzystuje strumieniowe API Java 8 i konwertuje listę na tablicę. Tablica jest następnie drukowana przy użyciu dla każdej pętli.
# 3) Korzystanie z metody get
To jest kolejna metoda konwersji listy na tablicę. W tym celu używamy metody get () listy, której można użyć do pobrania poszczególnych elementów listy.
Program konwertujący listę na tablicę za pomocą metody get () pokazano poniżej.
import java.io.*; import java.util.List; import java.util.LinkedList; class Main { public static void main (String() args) { List colors_list = new LinkedList(); colors_list.add('Red'); colors_list.add('Green'); colors_list.add('Blue'); colors_list.add('Yellow'); System.out.println('Given list: ' + colors_list); //define the array String() colors_array = new String(colors_list.size()); // get list elements into the array for (int i =0; i Wynik:
W powyższym programie stworzyliśmy tablicę o takim samym rozmiarze jak lista. Następnie w pętli elementy listy są pobierane za pomocą metody get () i przypisywane do tablicy.
Konwertuj tablicę na listę
Ponieważ możesz przekonwertować listę na tablicę, możesz również przekonwertować tablicę na listę w Javie. Poniżej podano kilka metod, za pomocą których można przekonwertować tablicę na listę.
# 1) Używanie zwykłego kodu Java
Jest to tradycyjna metoda konwersji tablicy na listę. Tutaj dodajesz każdy element tablicy do listy jeden po drugim, używając pętli. W tym celu używana jest metoda dodawania listy.
Poniższy program implementuje tradycyjną metodę konwersji tablicy na listę.
import java.util.*; import java.util.stream.*; class Main { public static void main(String args()) { // Create and initialize an Array String strArray() = { 'Java', 'Python', 'C++', 'SQL', 'Perl' }; // Print the Array System.out.println('Array: ' + Arrays.toString(strArray)); // Create a List List strlist = new ArrayList(); // Iterate through the array and add each element to the list for (String val : strArray) { strlist.add(val); } // Print the List System.out.println('
List obtained from array: ' + strlist); } } Wynik:
# 2) Korzystanie z metody asList ()
Następną metodą konwersji tablicy na listę jest użycie metody asList () klasy Arrays. Tutaj możesz przekazać Array jako argument do metody asList () i zwraca ona otrzymaną listę.
Pokazuje to poniższy program.
import java.util.*; import java.util.stream.*; class Main { public static void main(String args()) { //create and intialize array Integer() oddArray = { 1,3,5,7,9,11 }; //declare a list and use asList method to assign the array to list List oddList = Arrays.asList(oddArray); // Print the List System.out.println('List from array: ' + oddList); } } Wynik:
W powyższym programie mamy tablicę liczb nieparzystych. Następnie tworzymy listę liczb całkowitych i przypisujemy ją do wyniku metody asList, która jest listą.
# 3) Korzystanie z metody Collection.addAll ()
Możesz także użyć metody addAll () klasy Collections, ponieważ zarówno tablica, jak i lista są częściami struktury kolekcji w Javie.
Poniższy program przedstawia użycie metody Collections.addAll () do konwersji tablicy na listę.
import java.util.*; import java.util.stream.*; class Main { public static void main(String args()) { // Create and initialize an Array String strArray() = { 'Java', 'C++', 'C', 'Perl', 'Python' }; // Print the Array System.out.println('Array: ' + Arrays.toString(strArray)); // create a string list List myList = new ArrayList(); // Add array to list using Collections addAll method Collections.addAll(myList, strArray); // Print the List System.out.println('List obtained from array: ' + myList); } } Wynik:
Tutaj zainicjowaliśmy tablicę. Stworzyliśmy pustą listę. Następnie metoda Collections.addAll () jest używana do przekazywania list i tablicy jako argumentu. Pomyślne wykonanie tej metody spowoduje wypełnienie listy elementami tablicy.
# 4) Korzystanie ze strumieni Java 8
Następnym podejściem do konwersji tablicy na listę jest użycie Java 8 Stream API i klasy Collectors. Tutaj tablica jest najpierw konwertowana na stream, a następnie elementy są zbierane do listy przy użyciu stream. Zbieraj metodę. Lista jest ostatecznie zwracana.
Poniższy program przedstawia implementację, która konwertuje tablicę na listę przy użyciu Stream API.
import java.util.*; import java.util.stream.*; class Main { public static void main(String args()) { // Create and initialize an Array String colorsArray() = { 'Red', 'Green', 'Blue', 'Yellow', 'Magenta' }; // Print the Array System.out.println('Array: ' + Arrays.toString(colorsArray)); // convert the Array to List using stream () and Collectors class List colorslist = Arrays .stream(colorsArray) .collect(Collectors.toList()); // Print the List System.out.println('List from Array: ' + colorslist); } } Wynik:
W powyższym programie tworzona jest tablica kolorów. Następnie tworzona jest pusta lista, a następnie przypisywana jest lista uzyskana z tablicy za pomocą interfejsu API strumienia.
Konwertuj listę na zestaw
Zestaw to nieuporządkowana kolekcja elementów, która nie pozwala na zduplikowane wartości. Zestaw jest częścią struktury kolekcji Java. Możesz przekonwertować listę na zestaw i odwrotnie, jeśli zajdzie taka potrzeba.
W tej sekcji przyjrzyjmy się niektórym metodom, które są używane do konwersji listy do zestawu.
1) Korzystanie z metody tradycyjnej
Możesz przekonwertować listę na zestaw przy użyciu tradycyjnego kodu Java. W tym celu możesz utworzyć HashSet lub treeSet. Następnie za pomocą metody add dodaj każdy element listy do zestawu w pętli.
Ta implementacja jest pokazana poniżej.
import java.util.*; class Main { public static void main(String() args) { // Creating a list of strings List strList = Arrays.asList('Java', 'Perl', 'Python', 'C++', 'C'); //print the list System.out.println('The list : ' + strList); //create a set Set hashSet = new HashSet(); //add list elements to hashset for (String ele : strList) hashSet.add(ele); //print the set System.out.println('HashSet from list:'); for (String val : hashSet) System.out.print(val + ' '); } } Wynik:
W powyższym programie widać, że utworzyliśmy obiekt HashSet typu string. Następnie za pomocą pętli rozszerzonej for każdy element listy jest dodawany do zestawu. Na koniec komplet jest drukowany.
Zalecana lektura = >> HashSet w Javie
# 2) Korzystanie z HashSet lub treeet Constructor
Następną metodą jest użycie konstruktora zestawu. Tutaj tworzymy konstruktor zestawu (treeSet lub HashSet). Lista jest przekazywana do tego konstruktora jako argument. Z tej listy konstruowany jest zestaw.
Sprawdź poniższy program dla tej realizacji.
import java.util.*; class Main { public static void main(String() args) { // Create a list of strings List strList = Arrays.asList('Red', 'Green', 'Blue', 'Yellow', 'Cyan', 'Magenta'); System.out.println('Original List:' + strList); // Creating a hash set using constructor and pass list to the constructor Set hashSet = new HashSet(strList); System.out.println('
HashSet created from list:'); //print the hashSet for (String val : hashSet) System.out.print(val + ' '); //Create a treeset using constructor and pass list to the constructor Set treeSet = new TreeSet(strList); System.out.println('
TreeSet from list: '); //print the treeset for (String x : treeSet) System.out.print(x + ' '); } } Wynik:
W powyższym programie tworzymy zarówno HashSet, jak i treeSet, przekazując listę jako argument. Na koniec wyświetlana jest zawartość zarówno HashSet, jak i treeset.
# 3) Korzystanie z metody addAll
To jest to samo, co metoda addAll kolekcji, którą widzieliśmy wcześniej. Tutaj metoda addAll służy do kopiowania zawartości listy do zestawu.
Poniższy program przedstawia użycie metody addAll.
import java.util.*; class Main { public static void main(String() args) { // Creating a list of strings List intList = Arrays.asList(1,3,5,7,9,11,13); System.out.println('Original List: ' + intList); //create a hashset Set hashSet = new HashSet(); //add elements of list to hashSet using addAll method hashSet.addAll(intList); System.out.println('HashSet created from list: '); //print the hashSet for (Integer val : hashSet) System.out.print(val + ' '); } } Wynik:
Ten program tworzy obiekt HashSet. Następnie metoda addAll jest wywoływana na obiekcie HashSet z listą jako parametrem. Ta metoda kopiuje zawartość listy do zestawu.
# 4) Korzystanie ze strumieni Java 8
Jak już widzieliśmy, możesz również użyć strumieni Java 8, aby przekonwertować listę na dowolną inną kolekcję, w tym zestaw. Aby to zrobić, musisz użyć metody stream (). Collect.
Poniższy program przedstawia tę realizację.
import java.util.*; import java.util.stream.*; class Main { public static void main(String() args) { // Create a list of strings List colorsList = Arrays.asList('Red', 'Green', 'Blue', 'Cyan', 'Magenta', 'Yellow'); System.out.println('Original List:' + colorsList); // Convert to set using stream and Collectors class toSet() method Set colorsSet = colorsList.stream().collect(Collectors.toSet()); System.out.println('The set from list:'); //print the set for (String x : colorsSet) System.out.print(x + ' '); } Wynik:
Powyższy program jest podobny do tego pokazanego w przypadku konwersji z listy na tablicę. Najpierw lista jest konwertowana na stream, a następnie metoda collect zbiera elementy stream i konwertuje do set.
Teraz, gdy widzieliśmy różne metody, które wykonują konwersję z listy do zestawu, zobaczmy metody, które są używane do konwersji zestawu na listę.
Konwertuj zestaw na listę
Podobnie do sposobu, w jaki konwertujesz listę na zestaw, możesz również konwertować zestaw na listę. Możesz użyć tych samych metod, które opisano powyżej dla tej konwersji. Jedyna różnica polega na tym, że zmieniasz miejsca na liście i ustawiasz w programie.
Poniżej podano przykłady konwersji ze zbioru na listę dla każdej metody.
# 1) Używanie zwykłej Javy
importjava.util.*; class Main { public static void main(String() args) { // Create a set(hashset) and initialize it Set hashSet = new HashSet(); hashSet.add('Red'); hashSet.add('Green'); hashSet.add('Blue'); hashSet.add('Cyan'); hashSet.add('Magenta'); hashSet.add('Yellow'); //print the set System.out.println('The set elements:'); for (String x : hashSet) System.out.print(x + ' '); //create a list (ArrayList) List strList = new ArrayList(hashSet.size()); //traverse the set and add its elements to the list for (String x : hashSet) strList.add(x); //print the list System.out.println('
Created ArrayList:' + strList); } } Wynik:
Powyższy program deklaruje i inicjalizuje zestaw. Następnie tworzy listę i dodaje każdy element zestawu do listy. Wreszcie drukuje listę.
# 2) Korzystanie z konstruktorów
import java.util.*; class Main { public static void main(String() args) { // Create a set(hashset) of strings & initialize it Set hashSet = new HashSet(); hashSet.add('Delhi'); hashSet.add('Mumbai'); hashSet.add('Chennai'); hashSet.add('Kolkata'); //print the Set System.out.println('The set :'); for(String str: hashSet) System.out.print(str + ' '); //pass hashset to linkedlist constructor List l_List = new LinkedList(hashSet); //print the linked list System.out.println ('
LinkedList from set: ' + l_List); } } Wynik:
Tutaj możesz użyć konstruktora listy z ustawionym obiektem jako argumentem. Powoduje to skopiowanie wszystkich elementów zestawu do obiektu listy.
# 3) Korzystanie z metody addAll
import java.util.*; class Main { public static void main(String() args) { // Create a set(hashset) of strings & initialize it Set hashSet = new HashSet(); hashSet.add('Red'); hashSet.add('Green'); hashSet.add('Blue'); hashSet.add('Cyan'); hashSet.add('Magenta'); hashSet.add('Yellow'); //print the Set System.out.println('The set: '); for(String x:hashSet) System.out.print(x + ' '); //create a list(ArrayList) List colorList = new ArrayList(); //use addAll method to add elements from set colorList.addAll(hashSet); //print the list System.out.println('
The ArrayList from set: ' + colorList); } } Wynik:
W tym programie tworzony jest obiekt listy. Następnie za pomocą metody Collections.addAll () elementy zestawu są dodawane do listy.
# 4) Korzystanie ze strumienia Java 8
import java.util.*; import java.util.stream.*; class Main { public static void main(String() args) { // Create a set(hashset) of strings & initialize the set Set hashSet = new HashSet(); hashSet.add('Yellow'); hashSet.add('Magenta'); hashSet.add('Cyan'); hashSet.add('Red'); hashSet.add('Green'); hashSet.add('Blue'); //print the Set System.out.println('The set:'); for(String str : hashSet) System.out.print(str + ' '); //create a list and assign it elements of set through stream and Collectors class List strList = hashSet.stream().collect(Collectors.toList()); //print the list System.out.println('
List obtained from set: ' + strList); } } Wynik:
Możesz także użyć strumieni Java 8 i metody collect, aby przekonwertować zestaw na listę, jak pokazano w powyższym programie.
Lista macierzy kontra
Omówmy niektóre różnice między tablicą a listą.
Szyk Lista Tablica to podstawowa struktura danych w Javie. Lista jest interfejsem, który jest częścią struktury kolekcji w Javie, z której można rozszerzyć wiele klas, takich jak LinkedList, ArrayList itp. Ma stały rozmiar Rozmiar listy jest dynamiczny. Dostęp do elementów tablicy można uzyskać za pomocą (). Dostęp do członków listy uzyskuje się za pomocą metod. Tablica może zawierać typy pierwotne, a także obiekty jako jej elementy. Listy mogą zawierać tylko obiekty. Tablice mogą używać operatorów ze swoimi elementami. Listy nie mogą używać operatorów. Zamiast tego zawiera listę metod. Tablice nie mogą współpracować z rodzajami, aby zapewnić bezpieczeństwo typów. Listy mogą być ogólne.
Często Zadawane Pytania
P # 1) Jak przekonwertować listę na tablicę w Javie?
Odpowiedź: Podstawową metodą konwersji listy na tablicę w Javie jest użycie metody „toArray ()” interfejsu List.
Poniższe proste wywołanie konwertuje listę na tablicę.
Object() array = list.toArray();Istnieją również inne metody konwersji listy na tablicę, jak omówiono powyżej.
Pytanie 2) Czy tablica jest listą w Javie?
Odpowiedź: Nie. Tablica to podstawowa struktura w Javie o ustalonej długości. Nie wychodzi z interfejsu listy. Struktura, która rozciąga się od interfejsu listy i podobna do tablicy, to ArrayList.
P # 3) Jak przekonwertować tablicę na listę w Javie?
Odpowiedź: Jedną z podstawowych metod konwersji tablicy na listę w Javie jest użycie metody asList () klasy Arrays.
List aList = Arrays.asList (myarray);Oprócz tego istnieje więcej metod, które konwertują tablicę na listę, jak omówiono wcześniej w tym samouczku.
Pytanie 4) Który zestaw lub lista jest szybsza w Javie?
Odpowiedź: To zależy od przechowywanych danych. Jeśli dane są unikalne, lista jest lepsza i szybsza. Jeśli masz duży zestaw danych, idź po zestawy. Struktura zestawu zwykle wymaga 10 razy więcej pamięci niż listy.
P # 5) Jaka jest różnica między ArrayList a zestawem?
Odpowiedź: Lista jest zbiorem uporządkowanych elementów, podczas gdy zestaw jest zbiorem nieuporządkowanych elementów. Lista może zawierać zduplikowane elementy, ale zestaw nie może zawierać zduplikowanych elementów.
Wniosek
W tym samouczku widzieliśmy różne konwersje list na tablicę, zestaw i odwrotnie. Widzieliśmy również główne różnice między tablicą a listą.
W następnym samouczku szczegółowo omówimy klasy list, takie jak ArrayList, LinkedList itp.
=> Sprawdź idealny przewodnik szkoleniowy języka Java tutaj.
rekomendowane lektury
- Java Copy Array: Jak skopiować / sklonować tablicę w Javie
- Tablica Java - jak wydrukować elementy tablicy w języku Java?
- Lista Java - jak tworzyć, inicjować i używać listy w Javie
- Typy danych tablic - int Array, Double array, Array of Strings itp.
- Java Array - Deklaruj, twórz i inicjuj tablicę w Javie
- Jak przekazać / zwrócić tablicę w Javie
- Samouczek JAVA dla początkujących: ponad 100 praktycznych samouczków wideo Java
- Samouczek dotyczący długości tablicy w języku Java z przykładami kodu
