Java >> Java tutorial >  >> Java

Java-lister (med eksempler)

Listeklassen i Java giver dig mulighed for at holde en ordnet samling. Det har indeksbaserede teknikker til at indsætte, opdatere, slette og søge i elementer. Det kan også indeholde overflødige elementer. Null-elementerne kan også gemmes i listen.

Samling-grænsefladen er nedarvet af List-grænsefladen, der er placeret i java.util-pakken. Det er en ListIterator-grænsefladefabrik. Vi kan iterere listen frem og tilbage ved hjælp af ListIterator. ArrayList, LinkedList, Stack og Vector er List-grænsefladen, implementeringsklasser. I Java-programmering bruges ArrayList og LinkedList almindeligvis. Siden Java 5 er Vector-klassen blevet forældet.

Grænsefladeerklæringer i en liste

public interface List extends Collection

List metoder i Java

  • void add(int index, E element) -hjælper med at indsætte det specificerede element på den givne position i en liste.
  • boolean add(E e)- Det bruges til at tilføje det angivne element i slutningen af ​​en liste.
  • boolean addAll(Collection c) – Det bruges til at tilføje alle elementer i den givne samling til listens ende.
  • boolean addAll(int idx, Collection c) – Det bruges til at tilføje alle elementerne i den specificerede samling, startende ved den angivne position på listen.
  • void clear()- Den bruges til at fjerne alle elementer fra denne liste.
  • boolean equals(Object o)- Det bruges til at sammenligne det angivne objekt med elementerne i en liste.
  • int hashcode() – Det returnerer hashkodeværdien for en liste.
  • E get(int index)- Det bruges til at hente elementet fra den særlige position på listen.
  • boolean isEmpty()- Den returnerer sand, hvis listen er tom, ellers falsk.
  • int lastIndexOf(Object o)- Det bruges til at returnere indekset i denne liste over den sidste forekomst af det angivne element, eller -1, hvis listen ikke indeholder dette element.
  • Object[] toArray()- Det bruges til at returnere et array, der indeholder alle elementerne på denne liste i den rigtige rækkefølge.
  • T[] toArray(T[] a)- Det bruges til at returnere et array, der indeholder alle elementerne på denne liste i den rigtige rækkefølge.
  • boolean contains(Object o)- Det returnerer sand, hvis listen indeholder det angivne element.
  • boolean containsAll(Collection c)- Den returnerer sand, hvis listen indeholder alle de angivne elementer.
  • int indexOf(Object o) – Det bruges til at returnere indekset i denne liste over den første forekomst af det angivne element, eller -1, hvis listen ikke indeholder dette element.
  • E remove(int index)- Det fjerner elementet, der findes på den angivne position på listen.
  • boolean remove(Object o)- Det bruges til at fjerne den første forekomst af det angivne element.
  • boolean removeAll(Collection c)- Den bruges til at fjerne alle elementer fra listen.
  • void replaceAll(UnaryOperator-operator)- Den erstatter alle elementer fra listen med det angivne element.
  • void retainAll(Collection c)- Den bruges til at beholde alle elementerne på listen, der findes i den specificerede samling.
  • E set(int index, E element) bruges til at erstatte det angivne element på listen, der findes på den angivne position.
  • void sort(Comparator c) – Den bruges til at sortere elementerne i listen baseret på en specificeret komparator.
  • Spliterator spliterator() bruges til at oprette en splitter over elementerne i en liste.
  • List subList(int fromIndex, int toIndex) – Den bruges til at hente alle elementer inden for det givne interval.
  • int size()- Det returnerer antallet af elementer på listen.

ArrayList vs. Java List

ArrayList er implementeringsklassen af ​​List, som er en grænseflade.

Sådan laver man en liste

Lad os gennemgå, hvordan man laver objekter eller forekomster i en listeklasse. Objekter af typen listen kan ikke oprettes, da List er en grænseflade. Vi kræver altid en klasse, der implementerer denne liste for at bygge et objekt. Siden introduktionen af ​​Generics i Java 1.5, er det desuden også muligt at begrænse objektet, der er sat i en liste. Listen er en 'grænseflade' implementeret af ArrayList-klassen, foruddefineret i java.util-pakken, ligesom flere andre brugerdefinerede 'grænseflader' implementeret af brugerdefinerede 'klasser'.

List-grænsefladen implementeres af klasserne ArrayList og LinkedList. Lad os undersøge nogle få tilfælde af, hvordan man laver en liste:

// Making use of ArrayList to create a List of type String
List stringList=new ArrayList();

//using ArrayList in creation of a List of type Integer
List integerList=new ArrayList();

//Creating a List of type Employee using ArrayList
List employeeList=new ArrayList();

//Creation of String a List using LinkedList
List linkedList=new LinkedList();

I en nøddeskal kan du lave en hvilken som helst liste. Typerne er specificeret ved hjælp af klasserne ArrayList og LinkedList. Bogstavet T står for type.

Eksempel på en Java-liste

Lad os se på et simpelt List-eksempel, der bruger ArrayList-klassen som implementering.

ublic static void main(String args[]){
  
//Creating a List
List programmingLanguages=new ArrayList();
  
//Adding elements in the List
programmingLanguages.add("Java");
programmingLanguages.add("Python");
programmingLanguages.add("JavaScript");
programmingLanguages.add("Angular");
  
//Iterating the List element using for-each loop
for(String languages:programmingLanguages)
System.out.println(languages);
  
}
}

Hvordan kan du ændre et array til en liste?

Ved at krydse arrayet og tilføje hvert element til listen et efter et, kan vi transformere arrayet til en liste.
add() er en metode til at tilføje elementer til en liste. Lad os se på et eksempel på konvertering af array-elementer til List.

import java.util.*;

public class exampleArrayToList{
  
  public static void main(String args[]){
    
    //Creating Array
  	String[] programmingLanguages={"Java","JavaScript","Kotlin","Scala"};
  	System.out.println("Printing Array: "+Arrays.toString(programmingLanguages));
    
    // Array to List Conversion
    List languagesList=new ArrayList();
    for(String lang:programmingLanguages){
    languagesList.add(lang);
}
System.out.println("Programming Languages List: "+languagesList);
    
}
}

Hvordan kan jeg lave en liste til en matrix?

List.toArray()-metoden konverterer en liste til et array. Lad os se på et hurtigt eksempel på at konvertere listeelementer til arrays.

import java.util.*;

public class exampleListToArray{
  
  static void main(String args[]){
  List companiesList = new ArrayList<>();
  companiesList.add("Microsoft");
  companiesList.add("Google");
  companiesList.add("Apple");
  companiesList.add("HP");
    
  // ArrayList to Array Conversion
String[] companiesArray = companiesList.toArray(new String[companiesList .size()]);
System.out.println("Array of Companies: "+Arrays.toString(companiesArray));
System.out.println("List of Companies: "+companiesList);
}
}

Lad os nu bruge listegrænsefladen til at udføre forskellige operationer for at forstå det bedre. Vi vil diskutere operationerne nedenfor og derefter implementere dem ved hjælp af ren Java-kode.

Handlinger på en listegrænseflade

Fordi List er en grænseflade, bruges den med en klasse, der implementerer den. Lad os se på at bruge listen til at udføre nogle få daglige handlinger.

  • Operation 1:Brug af add()-funktionen til at tilføje poster til List-klassen
  • Handling 2:Brug af funktionen set() til at opdatere medlemmer i Liste-klassen
  • Handling 3:Brug af funktionen remove() til at slette elementer

Lad os nu nedbryde hver operation og se, hvordan vi kan implementere den i koden for at forstå den bedre.

Brug af add()-funktionen til at tilføje poster til List-klassen

Add()-metoden tilføjer et nyt element til listen. Sidstnævnte metode er overbelastet med evnen til at udføre flere operationer baseret på forskellige argumenter.

Parametre

Det kræver to parametre som følger:

  • add(Object):Denne metode tilføjer et nyt element til listens slutning.
  • add(int index, Object):Denne metode tilføjer et element til listen ved et givet indeks.
// Java Program that Adds Elements to a List
// Importing all utility classes

import java.util.*;

// Main class
class listIntefaceClass {

public static void main(String args[])
{
    // Creation of an object of List interface, implemented by ArrayList class
    List<String> codeLanguages = new ArrayList<>();

    // Adding elements to object of List interface
    // Custom elements
    codeLanguages.add("Django");
    codeLanguages.add("Flask");
    codeLanguages.add(1, "Bottle");

    // Printing every elements inside the List interface object
    System.out.println(codeLanguages);
}
}

Opdatering af elementer

Fordi List er indekseret, refereres det element, vi ønsker at ændre, af elementets indeks. Som et resultat kræver det, at et indeks og det modificerede element indsættes ved det indeks. Hvis vi ønsker at opdatere et element efter det er blevet tilføjet, kan vi bruge set() metoden.

// Java Program for Updating List Elements

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

// Main class
class listIntefaceClass {

	// Main driver method
	public static void main(String args[])
	{
		// Creating an object of List interface
		List<String> codeLanguages = new ArrayList<>();

		// Adding elements to object of List class
		codeLanguages.add("Django");
		codeLanguages.add("Flask");
		codeLanguages.add(1, "Bottle");

		// Display theinitial elements in List
		System.out.println("Initial ArrayList " + al);

		//  use set() to update element at 1st index
		codeLanguages.set(1, "Python");

		// finally Print and display the new updated List
		System.out.println("Updated ArrayList is : " + codeLanguages);
	}
}

Fjernelse af elementer

Remove()-funktionen er ansvarlig for at slette et element fra en liste. Denne metode er overbelastet med evnen til at udføre flere operationer baseret på forskellige argumenter. De er som følger:

Parametre:

remove(Object):Metoden remove(Object) bruges til at slette et objekt fra en liste. Hvis der er adskillige forekomster af det samme emne, elimineres den første.

Fordi en liste er indekseret, tager remove(int index) en heltalsværdi, der eliminerer elementet ved det præcise indeks i listen. Efter at have fjernet et element, flyttes alle andre elementer til venstre for at dække rummet, og objektindekserne opdateres.

// Java Program for Removing Items from a List

// Importing List and ArrayList classes
// from java.util package
import java.util.ArrayList;
import java.util.List;

// Main class
class listIntefaceClass {

	public static void main(String args[])
	{

		// Creating List class object
		List<String> codeLanguages = new ArrayList<>();

		// Adding elements to the object
		// Custom inputs
		codeLanguages.add("Django");
		codeLanguages.add("Django");
		codeLanguages.add(1, "Bottle");

		// Adding For at 1st indexes
		codeLanguages.add(1, "Python");

		// Printing the initial ArrayList
		System.out.println("The Initial ArrayList is: " + codeLanguages);

		// remove  theelement from the above list that is present at 1st index
		codeLanguages.remove(1);

		// Print the List after removal of the element
		System.out.println("After the Index Removal: " + codeLanguages);

		// Now remove the current object from the updated
		// List
		codeLanguages.remove("Django");

		// Finally, print the updated List now
		System.out.println("After the Object Removal "+ codeLanguages);
	}
}

Hent og indstil listeelement

Get()-metoden henter elementet ved det angivne indeks, hvorimod set()-metoden ændrer eller erstatter det.

import java.util.*;
 
public class exampleGetSetList{  
 public static void main(String args[]){  
 // List  Creation
 List<String> subjectList=new ArrayList<String>();  

 //Addition of elements to the List  
 subjectList.add("Databases");  
 subjectList.add("Machine Learning");  
 subjectList.add("Data Structures & Algorithms");  
 subjectList.add("Operating Systems");  

 //illustrating how to access an element    
 System.out.println("Returning element: "+subjectList .get(1));//it will return the 2nd element, because index starts from 0  

 //illustrating how to change the element  
 subjectList.set(1,"Dates");  

 //Iterating the Subject List elements using for-each loop  
 for(String subjects:subjectList)  
  System.out.println(subjects);  
  
 }  
}

Sortering af en liste

Der er forskellige metoder til at sortere en liste; i dette tilfælde vil vi bruge metoden Collections.sort() til at sortere listeelementet. Collections er en hjælpeklasse i java.util-pakken, der har den statiske metode sort(). Vi kan hurtigt sortere enhver liste med Collections.sort()-funktionen.

import java.util.*;  
class exampleSortingArrayList{  
 public static void main(String args[]){  

  //Creation of a list containing subjects for students to choose from  
  List<String> subjectList=new ArrayList<String>();  
  subjectList.add("Data Structures & Algorithms");  
  subjectList.add("Databases");  
  subjectList.add("Machine Learning");  
  subjectList.add("Introduction to computers");  

  // illustrating sorting the subjects list  
  Collections.sort(subjectList);  

   //illustrating traversing the subject list using for-each loop  
  for(String subj:subjectList)  
    System.out.println(subj);  
      
 System.out.println("Demonstrating how to sorting numbers");  

  //Creating a list of numbers  
  List<Integer> numberList=new ArrayList<Integer>();  
  numberList.add(59);  
  numberList.add(12);  
  numberList.add(98);  
  numberList.add(33);  

  //illustrating sorting the number list  
  Collections.sort(numberList);  

   // illustrating subject traversal using the for-each loop  
  for(Integer num:numberList)  
    System.out.println(num);  
 }  
   
}  

Grænseflade til en Java ListIterator

ListIterator-grænsefladen bruges til at krydse elementet frem og tilbage.

Erklæring af ListIterator-grænsefladen

public interface ListIterator extends Iterator

ListIterator-grænseflademetoder i Java

  • void add(E e) – Denne metode indsætter det angivne element i listen.
  • boolean hasNext()- Den returnerer sand, hvis listeiteratoren har flere elementer, mens den krydser listen i fremadgående retning.
  • E next() – Denne metode returnerer det næste element på listen og flytter markørens position frem.
  • int nextIndex()- Denne metode returnerer indekset for det element, der ville blive returneret ved et efterfølgende kald til next()
  • boolean hasPrevious()- Denne metode returnerer sand, hvis iteratoren har flere elementer, mens den krydser listen i den modsatte retning.
  • E previous()- Denne metode returnerer det sidste element på listen og flytter markørens position bagud.
  • E previousIndex()- Denne metode returnerer indekset for elementet, der returneres af et efterfølgende kald til previous().
  • void remove() – Denne metode fjerner det sidste element fra listen, der blev returneret af metoderne next() eller previous()
  • void set(E e) – Denne metode erstatter det sidste element, der returneres af metoderne next() eller previous() med det angivne element.

Eksempel på ListIterator-grænseflade

import java.util.*;  

public class exampleListIterator{  
public static void main(String args[]){  

List<String> citiesList =new ArrayList<String>();    
        citiesList.add("New York");    
        citiesList.add("London");    
        citiesList.add("Los Angeles");    
        citiesList.add("Daka");    

        ListIterator<String> listIterator=al.listIterator();    
        System.out.println("Elements Traversal in forward direction");    
        while(listIterator .hasNext()){    
              
        System.out.println("index is:"+listIterator .nextIndex()+" value is:"+listIterator .next());    
        }    
        System.out.println("Elements Traversal in backward direction");    
        while(listIterator .hasPrevious()){    
          
        System.out.println("index is:"+listIterator .previousIndex()+" value:"+listIterator .previous());    
        }    
}  
}  

Medarbejder som eksempel på en liste

Lad os se på et eksempel på en liste, hvor vi tilføjer medarbejdere.

import java.util.*;  
class Employee {  
int id;  
String firstname,lastname,gender;  
int age;  
public Employee(int id, String firstname, String lastname, String gender, int age) {  
    this.id = id;  
    this. firstname = firstname;  
    this. lastname = lastname;  
    this. gender = gender;  
    this. age = age;  
}  
}  
public class exampleLis {  
public static void main(String[] args) {  
    //Creating list of Employees  
    List<Employee> employeesList=new ArrayList<Employee>();  

    //Creating Employees  
    Employee empOne=new Employee(10,"Thompson","Yale","Male",18);  
    Employee empTwo=new Employee(20,"Ann","Forouz","Female",14);  
    Employee empThree=new Employee(30,"Jerry ","Tom","Male",16);  

    //Adding Employee to list  

    employeesList.add(empOne);  
    employeesList.add(empTwo);  
    employeesList.add(empThree);  

    //Employee List Traversal  
    for(Employee emp:employeesList){  
    System.out.println(emp.id+" "+emp.name+" "+emp.author+" "+emp.publisher+" "+emp.quantity);  
    }  
}  
}  

Konklusion

Listegrænsefladen bruges til at holde styr på samlingens rækkefølge. Det er en samlings børnegrænseflade. Derudover er det en sorteret samling af objekter, der kan gemme duplikerede værdier. Listen understøtter positionsadgang og indsættelse af medlemmer, fordi indsættelsesrækkefølgen bevares.


Java tag