Java Collection tillhandahåller en arkitektur för att hantera gruppen av objekt. Samlingen innebär en enda enhet av föremål. Det tillåter oss att lagra och manipulera gruppen av objekt som en enda enhet.

Vi kan enkelt utföra många operationer som sökning, sortering, infogning, radering och manipulering på en grupp av objekt med hjälp av samlingsramverket.

Java Collection-ramverket tillhandahåller flera gränssnitt och klasser. Gränssnitten innehåller Uppsättning, Lista , Kö, Deque , och klasser innehåller ArrayList , Vektor , Länkad lista , HashSet , Träduppsättning , LinkedHashSet , och Prioritetskö .

sida ner tangentbordet

I det här avsnittet kommer vi att skilja på två delar av Samlingsram , som är List och ArrayList. Listan är ett gränssnitt och ArrayList är en klass.

Listgränssnitt

Listan är ett underordnat gränssnitt för samlingsramverket som gör att vi kan behålla den ordnade samlingen av objekten. Vi kan lagra dubblettvärdena och nollelement med hjälp av List. Den tillhandahåller en indexbaserad metod för att utföra infogning, radering, sökning och uppdatering av objekten.

Listgränssnittet sker i paketet java.util. Den implementerar klasserna ArrayList, LinkedList, Stack och Vector. Det är också en bas av ListIterator-klasser med hjälp av vilka vi kan iterera listan i riktningar framåt och bakåt.

Listgränssnitt ger positionell åtkomst och infogning av element och bevarar insättningsordningen. Förekomsten av listan kan skapas med hjälp av implementeringsklasserna.

Implementering av listan:

Vi kan implementera List-gränssnittet genom att använda ArrayList, LinkedList, Vector och Stack klasser .

För att instansiera listgränssnittet kan vi använda följande syntaxer:

 List list1= new ArrayList(); List list2 = new LinkedList(); List list3 = new Vector(); List list4 = new Stack(); 

Tänk på följande exempel på Lista:

 import java.util.*; public class JavaListExample { public static void main(String[] args) { List l = new ArrayList(); //Implementation of List l using ArrayList class l.add('Hello'); //adding objects l.add('Java'); l.add('Tpoint'); System.out.println(l); } } 

Produktion:

lyssna port

 [Hello, Java, Tpoint] 

ArrayList klass

ArrayList-klassen använder en dynamisk array för att lagra elementen. Klassen ArrayList fungerar som en array, men det finns ingen storleksbegränsning i den. Vi kan lägga till eller ta bort elementen när vi vill. Vi kan lagra dubblettelementet med klassen ArrayList. Den hanterar införingsordningen internt.

Klassen ArrayList är mycket mer flexibel än den traditionella arrayen. Den implementerar listgränssnittet för att använda alla metoder för listgränssnitt. Det tog plats i Java .util-paketet.

Klassen ArrayList ärver klassen AbstractList och implementerar listgränssnittet. Elementen i den kan nås slumpmässigt. Det kan inte användas för primitiva typer som int, char, etc.; för dessa datatyper behöver vi en omslagsklass.

Implementering av ArrayList:

En ArrayList-klass ärver alla metoder i klassen AbstractList och implementerar List-gränssnittet.

ArrayList-klassen kan deklareras enligt följande:

 public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, Serializable 

ArrayList kan definieras enligt följande:

 ArrayList myList = new ArrayList(); 

Tänk på nedanstående exempel på ArrayList:

 import java.util.*; public class JavaAL { public static void main(String[] args) { ArrayList l = new ArrayList(); //implementation of ArrayList l.add('Hello'); //adding objects l.add('Java'); l.add('Tpoint'); System.out.println(l); } } 

Produktion:

 [Hello, Java, Tpoint] 

Några viktiga skillnader mellan List Interface och ArrayList Class

Några stora skillnader mellan List och ArrayList är följande:

• En av de stora skillnaderna är det List är ett gränssnitt och ArrayList är en klass av Java Collection-ramverket.
• De List utökar samlingsramen , jämförelsevis ArrayList utökar klassen AbstractList och implementerar List-gränssnittet .
• Namnutrymmet för List och ArrayList är System.Collection.Generic respektive System Collection.
• List lagrar element i en sekvens och identifieras av det individuella indexnumret. Jämförelsevis lagrar ArrayList elementen i en dynamisk array; det kan växa när det behövs.

När vi definierar listan enligt följande:

 List myList = new ArrayList(); 

Det betyder att vi bara kan anropa metoderna och referensmedlemmarna från List-gränssnittet.

Om vi ​​definierar ArrayList enligt följande:

sortera arraylist i java

 ArrayList myList = new ArrayList(); 

Det betyder att vi kan åberopa tillgängliga metoder i ArrayList och använda dess medlemmar utöver listan.

Betrakta tabellen nedan för några huvudjämförelser mellan List och ArrayList:

Slutsats

Listan är ett gränssnitt och ArrayList är en klass av Java Collection-ramverk. Listan skapar en statisk array och ArrayList skapar en dynamisk array för att lagra objekten. Så listan kan inte utökas när den väl har skapats, men med hjälp av ArrayList kan vi utöka arrayen när det behövs.

Det är bättre att använda listgränssnittet om du vill dra fördel av polymorfismen. I framtiden, om vi måste implementera gränssnittet, behöver vi inte ändra programmet.