java list methods sort list
Denne vejledning forklarer forskellige Java-listemetoder, såsom Sort List, List Contains, List Add, List Remove, List Size, AddAll, RemoveAll, Reverse List & More:
Vi har allerede diskuteret listegrænsefladen generelt i vores tidligere vejledning. Listegrænsefladen har forskellige metoder, der bruges til at manipulere indholdet på listen. Ved hjælp af disse metoder kan du indsætte / slette, sortere og søge elementer på listen.
I denne vejledning diskuterer vi alle de metoder, der leveres af listegrænsefladen.
=> Tjek her for at se AZ af Java-træningsvejledninger her.
For at gentage listen, bruger listen grænsefladen listen iteratoren. Denne liste iterator strækker sig fra iterator interface. I vores næste vejledning vil vi udforske mere om listen iterator.
Hvad du vil lære:
- Listemetoder i Java
- Fjern duplikater fra en liste i Java
- Ofte stillede spørgsmål
- Konklusion
- Anbefalet læsning
Listemetoder i Java
Følgende tabel viser forskellige funktioner leveret af listegrænsefladen i Java.
| Liste metode | Metode Prototype | Beskrivelse |
|---|---|---|
| indeholder | boolean indeholder (Objekt o) | Kontrollerer, om det angivne element er til stede på listen, og returnerer sandt, hvis det er til stede |
| størrelse | int størrelse () | Returnerer størrelsen på listen, dvs. antallet af elementer i listen eller længden af listen. |
| klar | ugyldigt klart () | Rydder listen ved at fjerne alle elementerne på listen |
| tilføje | ugyldig tilføjelse (int-indeks, objektelement) | Føjer det givne element til listen i det givne indeks |
| boolsk tilføjelse (Objekt o) | Tilføjer det givne element i slutningen af listen | |
| tilføjAlle | boolsk addAll (samling c) | Tilføjer hele den givne samling til slutningen af listen |
| boolsk addAll (int-indeks, samling c) | Indsætter den givne samling (alle elementer) på listen i det angivne indeks | |
| indeholderAlle | boolsk indeholderAlle (samling c) | Kontrollerer, om den angivne samling (alle elementer) er en del af listen. Returnerer sandt med ja. |
| lige med | boolske lig (Objekt o) | Sammenligner det angivne objekt for ligestilling med elementer på listen |
| Få | Objekt få (int-indeks) | Returnerer elementet på listen specificeret af indekset |
| hashCode | int hashCode () | Returnerer hashkodeværdien på listen. |
| indexOf` | int indexOf (Objekt o) | Finder den første forekomst af inputelementet og returnerer dets indeks |
| er tom | boolsk isEmpty () | Kontrollerer, om listen er tom |
| lastIndexOf | int lastIndexOf (Objekt o) | Finder den sidste forekomst af inputelementet på listen og returnerer dets indeks |
| fjerne | Fjern objekt (int-indeks) | Fjerner elementet ved det angivne indeks |
| boolsk fjernelse (Objekt o) | Fjerner elementet ved dets første forekomst på listen | |
| Fjern alt | boolsk removeAll (samling c) | Fjerner alle elementer indeholdt i den angivne samling fra listen |
| bevar alle | boolean retainAll (Collection c) | Modsat af removeAll. Bevarer det element, der er angivet i inputindsamlingen på listen. |
| Sæt | Objektsæt (int-indeks, objekt-element) | Ændrer elementet ved det angivne indeks ved at indstille det til den angivne værdi |
| underliste | Liste underliste (int fraIndex, int tilIndex) | Returnerer underliste med elementer mellem fromIndex (inklusive) og toIndex (eksklusiv). |
| sortere | ugyldig sortering (komparator c) | Sorterer listeelementet i henhold til den angivne komparator for at give en ordnet liste |
| toArray | Objekt () toArray () | Returnerer arrayrepræsentation af listen |
| Objekt () toArray (Objekt () a) | Returnerer array-repræsentationen, hvis runtime-type er den samme som et specificeret array-argument | |
| iterator | Iterator iterator () | Returnerer en Iterator til listen |
| listIterator | ListIterator listIterator () | Returnerer en ListIterator til listen |
| ListIterator listIterator (int index) | Returnerer en ListIterator, der starter ved det angivne indeks på listen |
Dernæst vil vi diskutere disse funktioner sammen med deres eksempler.
størrelse
Prototype: int størrelse ()
Parametre: NIL
Returværdi: int => Antal elementer i listen eller med andre ord længden på listen.
Beskrivelse: Størrelsen () returnerer antallet af elementer eller størrelsen på listen. Det kan også kaldes længde i enkle vendinger.
klar
Prototype: ugyldigt klart ()
Parametre: NIL
Returværdi: Ingen returværdi
Beskrivelse: Rydder listen ved at fjerne alle elementerne på listen. Kaster 'UnSupportedException', hvis handlingen ikke understøttes af listen.
Nedenstående eksempel viser størrelse () og clear () -metoden.
import java.util.*; public class Main { public static void main(String() args) { List strList = new ArrayList(); // Creating a list //add items to list strList.add('Java'); strList.add('C++'); //print the size of list System.out.println('Size of list:' + strList.size()); //add more items to list strList.add('Ruby'); strList.add('Python'); strList.add('C#'); //print the size of list again System.out.println('Size of list after adding more elements:' + strList.size()); //clear method strList.clear(); System.out.println('List after calling clear() method:' + strList); } } Produktion:
tilføje
Prototype: ugyldig tilføjelse (int-indeks, objektelement)
Parametre: indeks - en position, hvor elementet skal tilføjes.
Element - det element, der skal tilføjes
Returværdi: ugyldig
Beskrivelse: Føjer det givne element til listen i det givne indeks. De efterfølgende elementer forskydes til højre.
Følgende undtagelser kastes:
IndexOutOfBoundsException: Listeindeks er uden for området
Ikke-understøttetOperationException: Tilføj handling understøttes ikke af listen.
ClassCastException: Elementet kan ikke føjes til listen på grund af klassen af specificerede elementer.
IllegalArgumentException: Det angivne element eller et eller andet aspekt er ikke korrekt.
Tilføje
Prototype: boolsk tilføjelse (Objekt o)
Parametre: o => Element, der skal føjes til listen
Returværdi: true => Element tilføjet
False => Tilføjelse lykkedes ikke
Beskrivelse: Denne metode tilføjer det givne element i slutningen af listen.
Denne handling kan give følgende undtagelser.
Ikke-understøttetOperationException: Tilføj handling, der ikke understøttes af denne liste.
ClassCastException: Det angivne element kan ikke tilføjes på grund af dets klasse
IllegalArgumentException: Det angivne element eller et eller andet aspekt er ikke korrekt.
tilføjAlle
Prototype: boolsk addAll (samling c)
Parametre: c => Samling, hvis elementer skal føjes til listen
Returværdi: true => Udførelse af metode lykkedes
Beskrivelse: Metoden addAll tager alle elementerne fra samling c og tilføjer dem til slutningen af listen ved at opretholde den rækkefølge, der blev indstillet.
Denne metode udviser uspecificeret adfærd, hvis samlingen ændres, når operationen er i gang.
Metoden kaster følgende undtagelser:
Ikke-understøttetOperationException: Tilføj handling, der ikke understøttes af denne liste.
ClassCastException: Det angivne element kan ikke tilføjes på grund af dets klasse.
IllegalArgumentException: Det angivne element eller et eller andet aspekt er ikke korrekt.
tilføjAlle
Prototype: boolsk addAll (int-indeks, samling c)
Parametre: index => Position, hvor samlingen skal indsættes.
C => Samling, der skal indsættes på listen.
Returværdi: true => Hvis indsamlingselementer er tilføjet til listen.
Beskrivelse: Metoden addAll indsætter alle elementerne i den angivne samling på listen i det angivne indeks. De efterfølgende elementer flyttes derefter til højre. Som i tilfældet med den tidligere overbelastning af addAll er adfærden ikke specificeret, hvis samlingen ændres, når operationen er i gang.
Undtagelserne ved denne metode er:
Ikke-understøttetOperationException: Tilføj handling, der ikke understøttes af denne liste.
ClassCastException: Det angivne element kan ikke tilføjes på grund af dets klasse.
IllegalArgumentException: Det angivne element eller et eller andet aspekt er ikke korrekt.
IndexOutOfBoundsException: Indeks uden for rækkevidde.
Programmet nedenfor viser demonstrationen af tilføj og tilføjAlle metoder på listen.
import java.util.*; public class Main { public static void main(String() args) { List strList = new ArrayList(); // Creating a list strList.add('Java'); strList.add('C++'); //print the list System.out.println('List after adding two elements:' + strList); List llist = new ArrayList(); // Create another list llist.add('Ruby'); llist.add('Python'); llist.add('C#'); // addAll method - add llist to strList strList.addAll(llist); System.out.println('List after addAll:'+ strList); } } Produktion:
indeholder
Prototype: boolean indeholder (Objekt o)
Parametre: o => Element, der skal søges i listen.
Returværdi: true => Hvis listen indeholder det angivne element.
Beskrivelse: Metoden 'indeholder' kontrollerer, om det angivne element er til stede på listen og returnerer en boolsk værdi sand, hvis elementet er til stede. Ellers returnerer den falsk.
indeholderAlle
Prototype: boolsk indeholderAlle (samling c)
Parametre: c => Samling, der skal søges i på listen.
Returværdi: true => Hvis alle elementer i den angivne samling er til stede på listen.
Beskrivelse: Metoden “containAll” kontrollerer, om alle elementerne i den angivne samling er til stede på listen. Hvis det er til stede, returnerer det en ægte værdi og ellers falsk.
Følgende Java-program viser brugen af 'indeholder' og 'indeholderAlle' metoder på listen.
import java.util.*; public class Main { public static void main(String() args) { //define list of strings List list = new ArrayList(); //initialize list to strings list.add('Java'); list.add('Xml'); list.add('Python'); list.add('Ruby'); list.add('JavaScript'); //contains method demo if(list.contains('C')==true) System.out.println('Given list contains string 'C''); else if(list.contains('Java')==true) System.out.println('Given list contains string 'Java' but not string 'C''); //containsAll method demo List myList = new ArrayList(); myList.add('Ruby'); myList.add('Python'); if(list.containsAll(myList)==true) System.out.println('List contains strings 'Ruby' and 'Python''); } }Produktion:
Den givne liste indeholder streng 'Java', men ikke streng 'C'
Listen indeholder strenge 'Ruby' og 'Python'
hvad er en wifi-sikkerhedsnøgle
lige med
Prototype: boolske lig (Objekt o)
Parametre: o => Objektet, der skal testes for lighed.
Returværdi: true => Hvis det givne objekt er lig med listen.
Beskrivelse: Denne metode bruges til at sammenligne det givne objekt med listen over lighed. Hvis det angivne objekt er en liste, returnerer metoden sand. Begge lister siges at være ens, hvis og kun hvis de har samme størrelse, og de tilsvarende elementer i de to lister er ens og i samme rækkefølge.
En demonstration af ligemetoden er givet nedenfor:
import java.util.LinkedList; import java.util.List; public class Main { public static void main(String() args) { //define lists List first_list= new LinkedList(); List second_list = new LinkedList(); List third_list = new LinkedList(); //initialize lists with values for (int i=0;i<11;i++){ first_list.add(i); second_list.add(i); third_list.add(i*i); } //print each list System.out.println('First list: ' + first_list); System.out.println('Second list: ' + second_list); System.out.println('Third list: ' + third_list); //use equals method to check equality with each list to other if (first_list.equals(second_list) == true) System.out.println('
first_list and second_list are equal.
'); else System.out.println('first_list and second_list are not equal.
'); if(first_list.equals(third_list)) System.out.println('first_list and third_list are equal.
'); else System.out.println('first_list and third_list are not equal.
'); if(second_list.equals(third_list)) System.out.println('second_list and third_list are equal.
'); else System.out.println('second_list and third_list are not equal.
'); } } Produktion:
Få
Prototype: Objekt få (int-indeks)
Parametre: index => Position, hvor elementet skal returneres.
Returværdi: objekt => Element på den angivne position.
Beskrivelse: Metoden get () returnerer elementet på den givne position.
Denne metode kaster 'indexOutOfBoundsException', hvis det angivne indeks er uden for listen.
Sæt
Prototype: Objektsæt (int-indeks, objekt-element)
Parametre: index => Position, hvor det nye element skal indstilles.
element => Nyt element, der skal placeres på den position, der er angivet ved indeks.
Returværdi: Objekt => Element, der blev udskiftet
Beskrivelse: Metodesættet () erstatter elementet ved det givne indeks med en anden værdi givet af elementet.
Metoden kan give følgende undtagelser:
Ikke-understøttetOperationException: Sætfunktion understøttes ikke af listen.
ClassCastException: Betjening kan ikke udføres på grund af elementets klasse
IllegalArgumentException: Argument eller et eller andet aspekt af det er ulovligt
IndexOutOfBoundsException: Indeks uden for rækkevidde.
Følgende program viser et eksempel på get () og set () metode.
import java.util.*; public class Main { public static void main(String() args) { //define list List listA = new ArrayList(); listA.add('Java'); listA.add('C++'); listA.add('Python'); //access list elements using index with get () method System.out.println('Element at index 0:' + listA.get(0)); System.out.println('Element at index 1:' + listA.get(1)); System.out.println('Element at index 2:' + listA.get(2)); //set element at index 1 to Ruby listA.set(1,'Ruby'); System.out.println('Element at index 1 changed to :' + listA.get(1) ); } } Produktion:
hashCode
Prototype: int hashCode ()
Parametre: NIL
Returværdi: int => hashCode på listen
Beskrivelse: Metoden 'hashCode ()' returnerer hashCode for listen, som er en heltalsværdi.
Eksempel:
import java.util.*; public class Main { public static void main(String() args) { // Initializing a list of type Linkedlist List mylist = new LinkedList(); mylist.add(1); mylist.add(3); mylist.add(5); mylist.add(7); //print the list System.out.println('The list:' + mylist); //use hashCode() method to find hashcode of list int hash = mylist.hashCode(); System.out.println('Hashcode for list:' + hash); } } Produktion:
er tom
Prototype: boolsk isEmpty ()
Parametre: NIL
Returværdi: true => Listen er tom
Beskrivelse: Metoden 'isEmpty ()' kontrollerer, om listen er tom. IsEmpty-metoden bruges til at kontrollere, om listen har nogen elementer, inden du begynder at behandle disse elementer.
indeks af
Prototype: int indexOf (Objekt o)
Parametre: o => element at søge efter på listen
Returværdi: int => indekset eller placeringen af den første forekomst af det givne element på listen. Returnerer -1, hvis elementet ikke er til stede.
Beskrivelse: Metoden 'indexOf ()' returnerer indekset for den første forekomst af det givne element o på listen. Hvis elementet ikke findes, returnerer det -1.
lastIndexOf
Prototype: int lastIndexOf (Objekt o)
Parametre: o => Objekt, hvis indeks skal søges
Returværdi: int => Indeks for den sidste forekomst af det givne element i listen, -1 ellers.
Beskrivelse: Metoden 'lastIndexOf ()' returnerer indekset for den sidste forekomst af element o på listen. Hvis elementet ikke findes, returnerer metoden -1.
Java-programmet nedenfor viser brugen af indexOf og lastIndexOf-metoder på listen.
import java.util.*; public class Main { public static void main(String() args) { // define an integer array List intList = new ArrayList(5); //add elements to the list intList.add(10); intList.add(20); intList.add(30); intList.add(10); intList.add(20); //print the list System.out.println('The list of integers:' + intList); // Use indexOf() and lastIndexOf() methods of list to find first and last index System.out.println('first index of 20:' + intList.indexOf(20)); System.out.println('last index of 10:' + intList.lastIndexOf(10)); } } Produktion:
fjerne
Prototype: Fjern objekt (int-indeks)
Parametre: indeks => Indeks eller position på listen, hvor elementet skal fjernes
Returværdi: Objekt => Element fjernet
Beskrivelse: Metoden 'remove ()' fjerner elementet på den givne position fra listen. Efter sletning flyttes elementerne ved siden af det slettede element til venstre.
Denne metode kan give følgende undtagelser:
Ikke-understøttetOperationException: Fjern understøttes ikke af listen.
IndexOutOfBoundsException: Det angivne indeks er uden for området
fjerne
Prototype: boolsk fjernelse (Objekt o)
Parametre: o => Element, der skal fjernes fra listen
Returværdi: true => Elementet blev fjernet.
Beskrivelse: Denne overbelastede version af metoden remove () fjerner den første forekomst af et givet element o fra listen. Hvis det givne element ikke er til stede på listen, forbliver det uændret.
Denne metode kan have følgende undtagelse:
Ikke-understøttetOperationException: Fjern understøttes ikke af listen.
Fjern alt
Prototype: boolsk removeAll (samling c)
Parametre: c => En samling, der indeholder elementer, der fjernes fra listen.
Returværdi: true => Hvis metoden kaldes vellykket, og alle de elementer, der er angivet i samlingen c, fjernes fra listen.
Beskrivelse: Metoden 'removeAll ()' bruges til at fjerne alle de elementer fra listen, der er specificeret i samling c, der sendes som et argument.
Denne metode kan have følgende undtagelse:
Ikke-understøttetOperationException: removeAll understøttes ikke af listen.
Lad os se et eksempel på fjerne og fjerne alle metoder.
import java.util.*; public class Main { public static void main(String() args) { // Creating a list List oddList = new ArrayList(); //add elements to the list oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); oddList.add(11); //print the original list System.out.println('Original List:' + oddList); // Removes element from index 1 oddList.remove(1); System.out.println('Oddlist after removing element at index 1:' + oddList); //removeAll method List c1 = new ArrayList(); c1.add(1); c1.add(5); c1.add(11); oddList.removeAll(c1); System.out.println('Oddlist after removing elements {1,5,11}}:' + oddList); } } Produktion:
bevar alle
Prototype: boolean retainAll (Collection c)
Parametre: c => Samling, der indeholder elementer, der skal bevares på listen.
Returværdi: true => Hvis metodekaldet ændrede listen.
Beskrivelse: Denne metode fjerner alle elementerne fra listen undtagen dem, der findes i samlingen c. Med andre ord bevarer denne metode alle de elementer på listen, der er til stede i samling c og fjerner de andre elementer.
Denne metode kan have følgende undtagelse:
Ikke-understøttetOperationException: retainAll understøttes ikke af listen.
import java.util.*; public class Main { public static void main(String() args) { // Creating a list List oddList = new ArrayList(); //add elements to the list oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); oddList.add(11); //print the original list System.out.println('Original List:' + oddList); //retainAll method List c1 = new ArrayList(); c1.add(1); c1.add(5); c1.add(11); oddList.retainAll(c1); System.out.println('Oddlist after call to retainAll (1,5,11):' + oddList); } } Produktion:
underliste
Prototype: Liste underliste (int fraIndex, int tilIndex)
Parametre: fromIndex => Lavere indeks på listen (inklusive)
toIndex => Højere indeks på listen (eksklusiv)
Returværdi: Liste => En underliste over den givne liste
Beskrivelse: Metodens underliste () returnerer den delvise visning af listen, også kendt som underliste fra 'fromIndex' til 'toIndex'. Den returnerede underliste er kun en visning af forældrelisten, og derfor ændres ændringer, der foretages på en liste, overalt.
Tilsvarende fungerer alle operationer på listen også på en underliste.
Metoden kan kaste følgende undtagelse:
IndexOutOfBoundsException: Ulovlig toIndex-værdi.
Et eksempel på et program til sublistemetoden er angivet nedenfor.
import java.util.*; public class Main { public static void main(String() args) { // define a string list List strList = new ArrayList(5); //add elements to the list strList.add('Java'); strList.add('Tutorials'); strList.add('Collection'); strList.add('Framework'); strList.add('Series'); //print the original list System.out.println('The original list=>strList: ' + strList); //define another list List subList = new ArrayList(); // take a sublist of elements from 2 to 4 from strList subList = strList.subList(2, 4); //print the sublist System.out.println('The sublist of strList:' + subList); } } Produktion:
sorteringsliste
Prototype: ugyldig sortering (komparator c)
Parametre: c => Komparator på baggrund af hvilken listen er sorteret.
Returværdi: NIL
Beskrivelse: 'Sort ()' metode bruges til at sortere listen. Metoden bruger den specificerede komparator til at sortere listen.
Lad os se et eksempel på sorteringsmetoden . Vi har sammenlignet det med Collections.sort-metoden, der sorterer elementerne i en naturlig sekvens. Programmets output er en ordnet liste.
import java.util.Collections; import java.util.ArrayList; import java.util.List; import java.util.Random; public class Main { public static void main(String() args) { //define list List intArray = new ArrayList(); Random random = new Random(); //populate the list with random numbers <20 for (int i = 0; i {return (o2-o1);}); //comparator to sort in reverse System.out.println('Reverse List sorted using comparator:
'+intArray); } }Produktion:
toArray
Prototype: Objekt () toArray ()
Parametre: NIL
Returværdi: Objekt () => Arrayrepræsentation af listen
Beskrivelse: Method toArray () returnerer array-repræsentationen af listen i en korrekt sekvens.
toArray
Prototype: Objekt () toArray (Objekt () a)
Parametre: a => Arraytype, der skal matches med listeelementtyper, mens du konverterer listen til en matrix.
Returværdi: Objekt () => Arrayrepræsentation af listen.
Beskrivelse: Denne overbelastning af metoden toArray () returnerer det array, der indeholder elementer på listen, der har den samme runtime-type som arrayet a.
Denne metode kan have følgende undtagelse:
ArrayStoreException: Runtime-typen af hvert element på listen er ikke en undertype af runtime-typen for hvert element i denne liste.
Følgende er et eksempel på implementeringen af toArray-metoden.
import java.util.*; public class Main { public static void main(String() args) { // create list ArrayList colorsList = new ArrayList(7); // add colors to colorsList colorsList.add('Violet'); colorsList.add('Indigo'); colorsList.add('Blue'); colorsList.add('Green'); colorsList.add('Yellow'); colorsList.add('Orange'); colorsList.add('Red'); System.out.println('Size of the colorsList: ' + colorsList.size()); // Print the colors in the list System.out.println('Contents of colorsList:'); for (String value : colorsList){ System.out.print(value + ' '); } // Create an array from the list using toArray method String colorsArray() = new String(colorsList.size()); colorsArray = colorsList.toArray(colorsArray); // Display the contents of the array System.out.println('
Printing elements of colorsArray:' + Arrays.toString(colorsArray)); } }Produktion:
Iterator
Prototype: Iterator iterator ()
beta test er den sidste fase af testprocessen.
Parametre: NIL
Returværdi: Iterator => Iterator for at gentage elementerne på listen
Beskrivelse: Denne metode returnerer iteratoren, der gentager sig over elementerne på listen.
Java-program til demonstration ved hjælp af iterator.
import java.util.*; public class Main { public static void main(String() args) { // create list ArrayList colorsList = new ArrayList(7); // add colors to colorsList colorsList.add('Violet'); colorsList.add('Indigo'); colorsList.add('Blue'); colorsList.add('Green'); colorsList.add('Yellow'); colorsList.add('Orange'); colorsList.add('Red'); System.out.println('ColorList using iterator:'); //define iterator for colorsList Iterator iterator = colorsList.iterator(); //iterate through colorsList using iterator and print each item while(iterator.hasNext()){ System.out.print(iterator.next() + ' '); } } } Produktion:
listIterator
Prototype: ListIterator listIterator ()
Parametre: NIL
Returværdi: ListIterator => Listiterator af elementerne i listen.
Beskrivelse: Method listIterator () returnerer ListIterator-objektet for elementerne på listen. Denne iterator starter fra begyndelsen af listen, dvs. indeks 0.
listIterator
Prototype: ListIterator listIterator (int index)
Parametre: index => Position, hvor listenIterator starter.
Returværdi: ListIterator => ListIterator-objekt ved specificeret indeks på listen.
Beskrivelse: Overbelastningen af metoden listIterator () returnerer en listIterator, der starter ved den givne position på listen. Det givne indeks angiver, at det vil være det første element, der returneres ved det første opkald til nextElement () -metoden i ListIterator.
Metoden kan muligvis kaste IndexOutOfBoundsException for den ugyldige værdi af indekset.
Følgende eksempel viser listIterator-brug.
import java.util.*; public class Main { public static void main(String() args) { //define list & add items to list List nameList = new LinkedList(); nameList.add('Java'); nameList.add('C++'); nameList.add('Python'); // get listIterator for the list ListIterator namesIterator = nameList.listIterator(); // Traverse list using listiterator and print each item System.out.println('Contents of list using listIterator:'); while(namesIterator.hasNext()){ System.out.print(namesIterator.next() + ' '); } } } Produktion:
Vi vil diskutere ListIterator i detaljer senere.
Lad os nu diskutere nogle af de forskellige operationer, der kan udføres på lister, men metoder, for hvilke der ikke findes i listegrænsefladen.
Kopier liste i Java
For at kopiere elementer fra en liste til en anden liste skal du bruge metoden copy (), der leveres af Collections-rammen.
Metoden Collections.copy () kopierer alle elementerne på listen, der er angivet som det andet argument, til listen, der er angivet som det første argument. Bemærk, at listen, som indholdet af en anden liste kopieres til, skal være stor nok til at rumme de kopierede elementer.
Hvis listen ikke er stor nok, kaster kopimetoden 'indexOutOfBoundsEexception'.
Følgende program kopierer indholdet af en liste til en anden.
import java.util.*; public class Main { public static void main(String() args) { //create first ArrayList object List aList_1 = new ArrayList(); //Add elements to first ArrayList aList_1.add('R'); aList_1.add('G'); aList_1.add('B'); //print the List System.out.println('The first list:' + aList_1); //create second ArrayList object List aList_2 = new ArrayList(); //Add elements to second Arraylist aList_2.add('Red'); aList_2.add('Green'); aList_2.add('Blue'); aList_2.add('Yellow'); aList_2.add('Brown'); System.out.println('The second list: ' + aList_2); //use Collections.copy() method to copy elements of first list to second list. Collections.copy(aList_2,aList_1); //print the resultant second Arraylist System.out.println('
The second list after copying first list to second list: ' + aList_2); } } Produktion:
Fjern duplikater fra en liste i Java
En given liste kan eller ikke have gentagne elementer eller duplikater. Hvis listen, du arbejder med, har duplikatelementer, og du vil have alle forskellige elementer på listen, er der to metoder til at fjerne duplikater fra listen, der understøttes i Java.
Brug af Java 8 stream
Den første metode til at fjerne dubletter fra listen er ved hjælp af den forskellige () metode, der leveres af Java 8 stream. Her påkalder listen, der indeholder dubletter, stream () .distinct-metoden, og derefter konverteres returværdien til en ny liste, der kun har de forskellige elementer.
Det følgende program viser brugen af den forskellige () metode.
import java.util.*; import java.util.stream.Collectors; class Main { public static void main(String() args) { // original list List intlist = new ArrayList( Arrays.asList(1, 1, 1, 2, 2, 3, 3, 3, 4, 5, 5,6,5,3,4)); // Print the list System.out.println('Original ArrayList: ' + intlist); // using distinct() method of Java 8 stream remove duplicates from original List //and generate a new list without duplicates List distinct_list = intlist.stream().distinct() .collect(Collectors.toList()); // Print the new list System.out.println('ArrayList after removing duplicates: ' + distinct_list); } } Produktion:
Ved hjælp af Iterator-tilgang
Fjernelse af dubletter fra listen ved hjælp af iteratoren er en langvarig og primitiv tilgang. I denne tilgang skal du krydse listen og placere den første forekomst af hvert element på en ny liste. Hvert efterfølgende element kontrolleres, hvis det er en duplikat.
Programmet nedenfor opnår dette.
import java.util.*; public class Main { public static void main(String args()) { // create original list ArrayList aList = new ArrayList( Arrays.asList(1, 1, 1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 5, 3, 4)); // Print the original list System.out.println('Original List: '+ aList); // Create a new list ArrayList new_List = new ArrayList(); // Traverse through the original list to remove duplicates for (Integer element : aList) { // check if element is present in new_List, else add it if (!new_List.contains(element)) { new_List.add(element); } } // Print the new list without duplicates System.out.println('List after removing duplicates: '+ new_List); } } Produktion:
Ofte stillede spørgsmål
Q # 1) Hvad er get-metoden på listen i Java?
Svar: Get-metoden på listen bruges til at hente et bestemt element på listen baseret på indekset. Du sender det krævede indeks til get-metoden, og get-metoden returnerer elementværdien ved det indeks.
Q # 2) Hvad er toArray-metoden i Java?
Svar: Metoden toArray () bruges til at få matrixrepræsentationen af listen.
Spørgsmål nr. 3) Hvordan sorterer du en liste i Java?
Svar: I Java kan en liste sorteres ved hjælp af listens sorteringsmetode. Du kan videregive dine egne sorteringskriterier ved hjælp af komparatorgrænsefladen, der sendes til sorteringsmetoden som parameter.
Du kan også bruge samlinger. Sorter metode til at sortere listen. Denne metode sorterer listen efter naturlig bestilling.
Q # 4) Hvad er Arrays.asList () i Java?
Svar: Metoden 'asList' for array returnerer listen over elementer, der bakkes op af en array.
Konklusion
I denne vejledning har vi lært alle de metoder, som en liste giver. Java-listen indeholder forskellige metoder, hvor du kan manipulere og behandle lister, herunder søgning, sortering osv. Vi har forklaret hver metode med passende programmeringseksempler her.
I vores kommende vejledning vil vi diskutere ListIterator i detaljer.
=> Udforsk Simple Java Training Series her.
Anbefalet læsning
- Java List - Sådan oprettes, initialiseres og bruges listen i Java
- Skjult liste til matrix og andre samlinger i Java
- Python Advanced List Tutorial (List Sort, Reverse, Index, Copy, Join, Sum)
- Python-liste - Opret, adgang, udskær, tilføj eller slet elementer
- Java-tråde med metoder og livscyklus
- Fjern / slet et element fra en matrix i Java
- Java String Tutorial | Java strengmetoder med eksempler
- Standard router IP-adresseliste til almindelige trådløse routermærker