Mikä tahansa yksittäisten objektien ryhmä, joka on esitetty yhtenä yksikkönä, tunnetaan Java-objektien kokoelmana. Javassa erillinen kehys nimeltä Collection Framework on määritelty JDK 1.2:ssa, joka sisältää kaikki Java-kokoelmaluokat ja käyttöliittymän.
Javassa Collection-käyttöliittymä ( java.util.Collection ) ja karttaliittymä ( java.util.Map ) ovat Java-kokoelmaluokkien kaksi pääjuuriliitäntää.
Mitä sinun pitäisi oppia Java-kokoelmista?
- Luettelon käyttöliittymä
- Abstract List Class
- Abstract Sequential List Class
- Array List
- Vektoriluokka
- Pinoluokka
- LinkedList-luokka
- Jonon käyttöliittymä
- Estojonon käyttöliittymä
- AbstractQueue-luokka
- PriorityQueue Class
- PriorityBlockingQueue Class
- ConcurrentLinkedQueue-luokka
- ArrayBlockingQueue-luokka
- DelayQueue-luokka
- LinkedBlockingQueue Class
- LinkedTransferQueue
- Ja käyttöliittymä
- BlockingDeque-liitäntä
- ConcurrentLinkedDeque-luokka
- ArrayDeque-luokka
- Aseta käyttöliittymä
- Abstract Set Class
- CopyOnWriteArraySet-luokka
- EnumSet-luokka
- Samanaikainen HashMap-luokka
- HashSet-luokka
- LinkedHashSet-luokka
- SortedSet-käyttöliittymä
- NavigableSet-käyttöliittymä
- TreeSet
- ConcurrentSkipListSet-luokka
- Karttakäyttöliittymä
- Lajiteltu kartta käyttöliittymä
- NavigableMap-käyttöliittymä
- ConcurrentMap Interface
- TreeMap-luokka
- AbstractMap-luokka
- Samanaikainen HashMap-luokka
- EnumMap-luokka
- HashMap-luokka
- IdentityHashMap-luokka
- LinkedHashMap-luokka
- HashTable-luokka
- Ominaisuudet luokka
- Muita tärkeitä käsitteitä
- Kuinka muuntaa HashMap ArrayListiksi
- Valitse kohteet satunnaisesti luettelosta
- Kuinka lisätä kaikki kohteet kokoelmasta ArrayList-luetteloon
- Java-karttojen muuntaminen listaksi
- Array to ArrayList -muunnos
- ArrayList to Array -muunnos
- Erot Arrayn ja ArrayListin välillä
Mikä on kehys Javassa?
Kehys on joukko luokkia ja rajapintoja, jotka tarjoavat valmiin arkkitehtuurin. Uuden ominaisuuden tai luokan toteuttamiseksi ei tarvitse määritellä viitekehystä. Optimaalinen oliosuunnittelu sisältää kuitenkin aina kehyksen, jossa on joukko luokkia siten, että kaikki luokat suorittavat samanlaisen tehtävän.
Tarve erilliselle kokoelmakehykselle Javassa
Ennen Collection Frameworkin (tai ennen JDK 1.2:n) käyttöönottoa Java-objektien (tai kokoelmien) ryhmittelyn vakiomenetelmät olivat Taulukot tai Vektorit , tai Hashtables . Kaikilla näillä kokoelmilla ei ollut yhteistä käyttöliittymää. Siksi, vaikka kaikkien kokoelmien päätavoite on sama, kaikkien näiden kokoelmien toteutus määriteltiin itsenäisesti, eikä niillä ollut korrelaatiota niiden välillä. Ja myös, käyttäjien on erittäin vaikea muistaa kaikkea menetelmiä , syntaksi ja rakentajat jokaisessa kokoelmaluokassa.
Ymmärretään tämä esimerkillä elementin lisäämisestä hash-taulukkoon ja vektoriin.
vektorin koko c++
Esimerkki:
Java
// Java program to demonstrate> // why collection framework was needed> import> java.io.*;> import> java.util.*;> class> CollectionDemo {> >public> static> void> main(String[] args)> >{> >// Creating instances of the array,> >// vector and hashtable> >int> arr[] =>new> int>[] {>1>,>2>,>3>,>4> };> >Vector v =>new> Vector();> >Hashtable h =>new> Hashtable();> >// Adding the elements into the> >// vector> >v.addElement(>1>);> >v.addElement(>2>);> >// Adding the element into the> >// hashtable> >h.put(>1>,>'geeks'>);> >h.put(>2>,>'4geeks'>);> >// Array instance creation requires [],> >// while Vector and hastable require ()> >// Vector element insertion requires addElement(),> >// but hashtable element insertion requires put()> >// Accessing the first element of the> >// array, vector and hashtable> >System.out.println(arr[>0>]);> >System.out.println(v.elementAt(>0>));> >System.out.println(h.get(>1>));> >// Array elements are accessed using [],> >// vector elements using elementAt()> >// and hashtable elements using get()> >}> }> |
>
>Lähtö
1 1 geeks>
Kuten voimme havaita, mikään näistä kokoelmista (Array, Vector tai Hashtable) ei toteuta tavallista jäsenkäyttöliittymää, joten ohjelmoijien oli erittäin vaikeaa kirjoittaa algoritmeja, jotka voivat toimia kaikenlaisissa kokoelmissa. Toinen haittapuoli on, että suurin osa 'Vektori'-menetelmistä on lopullisia, mikä tarkoittaa, että emme voi laajentaa 'Vektori'-luokkaa toteuttamaan samanlaista kokoelmaa. Siksi Java-kehittäjät päättivät keksiä yhteisen käyttöliittymän edellä mainittujen ongelmien ratkaisemiseksi ja esittelivät Collection Frameworkin JDK 1.2 -julkaisussa, joka sekä vanhat vektorit että hashtables muokattiin kokoelmakehyksen mukaisiksi.
Java Collection Frameworkin edut
Koska keräyskehyksen puuttuminen aiheutti edellä mainitut haitat, seuraavat ovat keräyskehyksen edut.
- Johdonmukainen API: API:lla on perusjoukko rajapintoja, kuten Kokoelma , Aseta , Lista , tai Kartta , kaikilla luokilla (ArrayList, LinkedList, Vector jne), jotka toteuttavat nämä rajapinnat, on jonkin verran yhteinen menetelmäsarja.
- Vähentää ohjelmointityötä: Ohjelmoijan ei tarvitse huolehtia kokoelman suunnittelusta, vaan hän voi keskittyä sen parhaaseen käyttöön ohjelmassaan. Siksi olio-ohjelmoinnin (eli abstraktion) peruskonsepti on onnistuneesti toteutettu.
- Lisää ohjelman nopeutta ja laatua: Lisää suorituskykyä tarjoamalla tehokkaita toteutuksia hyödyllisistä tietorakenteista ja algoritmeista, koska tässä tapauksessa ohjelmoijan ei tarvitse ajatella tietyn tietorakenteen parasta toteutusta. Hän voi yksinkertaisesti käyttää parasta toteutusta parantaakseen merkittävästi algoritminsa/ohjelmansa suorituskykyä.
Kokoelmakehyksen hierarkia Javassa
Apuohjelmapaketti (java.util) sisältää kaikki kokoelmakehyksen vaatimat luokat ja rajapinnat. Kokoelmakehys sisältää käyttöliittymän, jonka nimi on iteroitava käyttöliittymä, joka tarjoaa iteraattorin kaikkien kokoelmien iterointiin. Tätä käyttöliittymää laajentaa pääkokoelmaliittymä, joka toimii kokoelmakehyksen juurina. Kaikki kokoelmat laajentavat tätä kokoelmarajapintaa laajentaen siten iteraattorin ominaisuuksia ja tämän rajapinnan menetelmiä. Seuraava kuva havainnollistaa kokoelmakehyksen hierarkiaa.
Ennen kuin ymmärrät yllä olevan kehyksen eri komponentteja, ymmärrämme ensin luokan ja käyttöliittymän.
- Luokka : Luokka on käyttäjän määrittelemä suunnitelma tai prototyyppi, josta objektit luodaan. Se edustaa joukkoa ominaisuuksia tai menetelmiä, jotka ovat yhteisiä kaikille samantyyppisille objekteille.
- Käyttöliittymä : Kuten luokassa, myös käyttöliittymässä voi olla menetelmiä ja muuttujia, mutta rajapinnassa ilmoitetut menetelmät ovat oletuksena abstrakteja (vain menetelmän allekirjoitus, ei kukaan). Liitännät määrittelevät, mitä luokan on tehtävä, ei miten. Se on luokan suunnitelma.
Keräysliittymän menetelmät
Tämä käyttöliittymä sisältää erilaisia menetelmiä, joita voivat suoraan käyttää kaikki tämän käyttöliittymän toteuttavat kokoelmat. He ovat:
| Menetelmä | Kuvaus |
|---|---|
| lisää (objekti) | Tätä menetelmää käytetään objektin lisäämiseen kokoelmaan. |
| lisää kaikki (kokoelma c) | Tämä menetelmä lisää kaikki tietyn kokoelman elementit tähän kokoelmaan. |
| asia selvä() | Tämä menetelmä poistaa kaikki elementit tästä kokoelmasta. |
| sisältää (objekti o) | Tämä menetelmä palauttaa tosi, jos kokoelma sisältää määritetyn elementin. |
| sisältääKaikki (kokoelma c) | Tämä menetelmä palauttaa tosi, jos kokoelma sisältää kaikki tietyn kokoelman elementit. |
| yhtä suuri (objekti o) | Tämä menetelmä vertaa määritettyä objektia tähän kokoelmaan tasa-arvoa varten. |
| hash koodin() | Tätä menetelmää käytetään tämän kokoelman hash-koodin arvon palauttamiseen. |
| on tyhjä() | Tämä menetelmä palauttaa tosi, jos tämä kokoelma ei sisällä elementtejä. |
| iteraattori() | Tämä menetelmä palauttaa iteraattorin tämän kokoelman elementtien päälle. |
| max() | Tätä menetelmää käytetään palauttamaan kokoelmassa oleva enimmäisarvo. |
| parallelStream() | Tämä menetelmä palauttaa rinnakkaisen virran, jonka lähteenä on tämä kokoelma. |
| poista (objekti o) | Tätä menetelmää käytetään tietyn objektin poistamiseen kokoelmasta. Jos arvot ovat päällekkäisiä, tämä menetelmä poistaa objektin ensimmäisen esiintymisen. |
| poista kaikki (kokoelma c) | Tätä menetelmää käytetään poistamaan kaikki tietyssä kokoelmassa mainitut objektit kokoelmasta. |
| removeIf (predikaattisuodatin) | Tätä menetelmää käytetään poistamaan kaikki tämän kokoelman elementit, jotka täyttävät annetun predikaatti . |
| säilyttää kaikki (kokoelma c) | Tätä menetelmää käytetään säilyttämään vain tämän kokoelman elementit, jotka sisältyvät määritettyyn kokoelmaan. |
| koko() | Tätä menetelmää käytetään palauttamaan kokoelman elementtien lukumäärä. |
| splitter() | Tätä menetelmää käytetään luomaan a Jakaja tämän kokoelman elementtien päälle. |
| stream() | Tätä menetelmää käytetään peräkkäisen streamin palauttamiseen, jonka lähteenä on tämä kokoelma. |
| toArray() | Tätä menetelmää käytetään palauttamaan taulukko, joka sisältää kaikki tämän kokoelman elementit. |
Liitännät, jotka laajentavat Java-kokoelman käyttöliittymää
Keräyskehys sisältää useita rajapintoja, joissa jokaista rajapintaa käytetään tietyntyyppisen tiedon tallentamiseen. Seuraavat ovat viitekehyksessä olevat rajapinnat.
1. Iteroitava käyttöliittymä
Tämä on juurikäyttöliittymä koko kokoelmakehykselle. Kokoelman käyttöliittymä laajentaa iteroitavaa käyttöliittymää. Siksi kaikki rajapinnat ja luokat toteuttavat tämän rajapinnan luonnostaan. Tämän käyttöliittymän päätoiminto on tarjota kokoelmille iteraattori. Siksi tämä käyttöliittymä sisältää vain yhden abstraktin menetelmän, joka on iteraattori. Se palauttaa
Iterator iterator();>
2. Kokoelman käyttöliittymä
Tämä käyttöliittymä laajentaa iteroitavaa käyttöliittymää, ja sen toteuttavat kaikki kokoelmakehyksen luokat. Tämä käyttöliittymä sisältää kaikki perusmenetelmät, joita jokaisessa kokoelmassa on, kuten tietojen lisääminen kokoelmaan, tietojen poistaminen, tietojen tyhjennys jne. Kaikki nämä menetelmät on toteutettu tässä käyttöliittymässä, koska nämä menetelmät toteutetaan kaikissa luokissa niiden tyylistä riippumatta. täytäntöönpanosta. Ja myös näiden menetelmien käyttö tässä käyttöliittymässä varmistaa, että menetelmien nimet ovat yleisiä kaikille kokoelmille. Siksi lyhyesti voidaan sanoa, että tämä käyttöliittymä rakentaa perustan, jolle kokoelmaluokat toteutetaan.
3. Luettelon käyttöliittymä
Tämä on kokoelman käyttöliittymän lapsikäyttöliittymä. Tämä käyttöliittymä on omistettu listatyyppisille tiedoille, joihin voimme tallentaa kaikki objektien järjestetyt kokoelmat. Tämä mahdollistaa myös päällekkäisten tietojen esiintymisen siinä. Tämä listarajapinta on toteutettu eri luokilla, kuten ArrayList, Vector, Stack jne. Koska kaikki alaluokat toteuttavat listan, voimme instantoida listaobjektin millä tahansa näistä luokista.
Esimerkiksi:
List al = new ArrayList (); List ll = new LinkedList (); List v = new Vector (); Where T is the type of the object>
Luokat, jotka toteuttavat List-rajapinnan, ovat seuraavat:
i). ArrayList
ArrayList tarjoaa meille dynaamisia taulukoita Javassa. Se voi kuitenkin olla hitaampi kuin tavalliset taulukot, mutta siitä voi olla apua ohjelmissa, joissa taulukkoa tarvitaan paljon. ArrayListin koko kasvaa automaattisesti, jos kokoelma kasvaa tai pienenee, jos objektit poistetaan kokoelmasta. Java ArrayList antaa meille mahdollisuuden käyttää luetteloa satunnaisesti. ArrayListiä ei voi käyttää kääreluokka tällaisiin tapauksiin.
Ymmärretään ArrayList seuraavalla esimerkillä:
Java
// Java program to demonstrate the> // working of ArrayList> import> java.io.*;> import> java.util.*;> class> GFG {> >// Main Method> >public> static> void> main(String[] args)> >{> >// Declaring the ArrayList with> >// initial size n> >ArrayList al =>new> ArrayList();> >// Appending new elements at> >// the end of the list> >for> (>int> i =>1>; i <=>5>; i++)> >al.add(i);> >// Printing elements> >System.out.println(al);> >// Remove element at index 3> >al.remove(>3>);> >// Displaying the ArrayList> >// after deletion> >System.out.println(al);> >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(al.get(i) + ' '); } }> |
>
>Lähtö
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
ii). LinkedList
LinkedList-luokka on toteutus Ymmärretään LinkedList seuraavalla esimerkillä:
Java
// Java program to demonstrate the> // working of LinkedList> import> java.io.*;> import> java.util.*;> class> GFG {> >// Main Method> >public> static> void> main(String[] args)> >{> >// Declaring the LinkedList> >LinkedList ll =>new> LinkedList();> >// Appending new elements at> >// the end of the list> >for> (>int> i =>1>; i <=>5>; i++)> >ll.add(i);> >// Printing elements> >System.out.println(ll);> >// Remove element at index 3> >ll.remove(>3>);> >// Displaying the List> >// after deletion> >System.out.println(ll);> >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(ll.get(i) + ' '); } }> |
>
>Lähtö
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
iii). Vektori
Vektori tarjoaa meille dynaamisia taulukoita Javassa. Se voi kuitenkin olla hitaampi kuin tavalliset taulukot, mutta siitä voi olla apua ohjelmissa, joissa taulukkoa tarvitaan paljon. Tämä on toteutuksen suhteen identtinen ArrayListin kanssa. Ensisijainen ero vektorin ja ArrayListin välillä on kuitenkin se, että vektori on synkronoitu ja ArrayList ei-synkronoitu.
Ymmärretään vektoria esimerkillä:
Java
// Java program to demonstrate the> // working of Vector> import> java.io.*;> import> java.util.*;> class> GFG {> >// Main Method> >public> static> void> main(String[] args)> >{> >// Declaring the Vector> >Vector v =>new> Vector();> >// Appending new elements at> >// the end of the list> >for> (>int> i =>1>; i <=>5>; i++)> >v.add(i);> >// Printing elements> >System.out.println(v);> >// Remove element at index 3> >v.remove(>3>);> >// Displaying the Vector> >// after deletion> >System.out.println(v);> >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(v.get(i) + ' '); } }> |
>
>Lähtö
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
iv). Pino
Pinoa luokan mallit ja toteuttaaviimeisenä sisään ensimmäisenä ulos. Perus push- ja pop-toimintojen lisäksi luokassa on kolme muuta toimintoa tyhjä, haku ja kurkistus. Luokkaan voidaan kutsua myös Vectorin alaluokka.
Ymmärretään pino esimerkin avulla:
Java
// Java program to demonstrate the> // working of a stack> import> java.util.*;> public> class> GFG {> >// Main Method> >public> static> void> main(String args[])> >{> >Stack stack =>new> Stack();> >stack.push(>'Geeks'>);> >stack.push(>'For'>);> >stack.push(>'Geeks'>);> >stack.push(>'Geeks'>);> >// Iterator for the stack> >Iterator itr = stack.iterator();> >// Printing the stack> >while> (itr.hasNext()) {> >System.out.print(itr.next() +>' '>);> >}> >System.out.println();> >stack.pop();> >// Iterator for the stack> >itr = stack.iterator();> >// Printing the stack> >while> (itr.hasNext()) {> >System.out.print(itr.next() +>' '>);> >}> >}> }> |
>
>Lähtö
Geeks For Geeks Geeks Geeks For Geeks>
Huomautus: Stack on Vectorin ja vanhan luokan alaluokka. Se on lankaturvallinen, mikä saattaa olla yläpuolella ympäristössä, jossa lankaturvallisuutta ei tarvita. Vaihtoehto Stackille on käyttää ArrayDequeue joka ei ole säikeen turvallinen ja jolla on nopeampi taulukkototeutus.
4. Jonon käyttöliittymä
Kuten nimestä voi päätellä, jonorajapinta ylläpitää FIFO-järjestystä (First In First Out), joka on samanlainen kuin todellinen jonorivi. Tämä käyttöliittymä on omistettu kaikkien elementtien tallentamiseen, missä elementtien järjestyksellä on väliä. Esimerkiksi aina kun yritämme varata lippua, liput myydään saapumisjärjestyksessä. Siksi henkilö, jonka pyyntö saapuu ensimmäisenä jonoon, saa lipun. On olemassa erilaisia luokkia, kuten PriorityQueue , ArrayDeque , jne. Koska kaikki nämä alaluokat toteuttavat jonon, voimme luoda jonoobjektin millä tahansa näistä luokista.
Esimerkiksi:
Queue pq = new PriorityQueue (); Queue ad = new ArrayDeque (); Where T is the type of the object.>
Yleisimmin käytetty jonorajapinnan toteutus on PriorityQueue.
Prioriteettijono
PriorityQueuea käytetään, kun objektit on tarkoitus käsitellä prioriteetin perusteella. Tiedetään, että jono noudattaa First-In-First-Out-algoritmia, mutta joskus jonon elementit joudutaan käsittelemään prioriteetin mukaan ja näissä tapauksissa käytetään tätä luokkaa. PriorityQueue perustuu prioriteettikekoon. Prioriteettijonon elementit järjestetään luonnollisen järjestyksen mukaan tai a Vertailija tarjotaan jonon rakennusaikana käytetystä rakentajasta riippuen.
Ymmärretään prioriteettijono esimerkin avulla:
Java
// Java program to demonstrate the working of> // priority queue in Java> import> java.util.*;> class> GfG {> >// Main Method> >public> static> void> main(String args[])> >{> >// Creating empty priority queue> >PriorityQueue pQueue> >=>new> PriorityQueue();> >// Adding items to the pQueue using add()> >pQueue.add(>10>);> >pQueue.add(>20>);> >pQueue.add(>15>);> >// Printing the top element of PriorityQueue> >System.out.println(pQueue.peek());> >// Printing the top element and removing it> >// from the PriorityQueue container> >System.out.println(pQueue.poll());> >// Printing the top element again> >System.out.println(pQueue.peek());> >}> }> |
>
>Lähtö
10 10 15>
5. Ja käyttöliittymä
Tämä on hyvin pieni muunnelma Esimerkiksi:
Deque ad = new ArrayDeque (); Where T is the type of the object.>
Deque-rajapinnan toteuttava luokka on ArrayDeque.
ArrayDeque
ArrayDeque-luokka, joka on toteutettu kokoelmakehyksessä, tarjoaa meille tavan käyttää muutettavaa taulukkoa. Tämä on erityinen taulukko, joka kasvaa ja antaa käyttäjille mahdollisuuden lisätä tai poistaa elementin jonon molemmilta puolilta. Array dequeillä ei ole kapasiteettirajoituksia ja ne kasvavat tarpeen mukaan tukeakseen käyttöä.
Ymmärretään ArrayDeque esimerkillä:
Java
// Java program to demonstrate the> // ArrayDeque class in Java> import> java.util.*;> public> class> ArrayDequeDemo {> >public> static> void> main(String[] args)> >{> >// Initializing an deque> >ArrayDeque de_que> >=>new> ArrayDeque(>10>);> >// add() method to insert> >de_que.add(>10>);> >de_que.add(>20>);> >de_que.add(>30>);> >de_que.add(>40>);> >de_que.add(>50>);> >System.out.println(de_que);> >// clear() method> >de_que.clear();> >// addFirst() method to insert the> >// elements at the head> >de_que.addFirst(>564>);> >de_que.addFirst(>291>);> >// addLast() method to insert the> >// elements at the tail> >de_que.addLast(>24>);> >de_que.addLast(>14>);> >System.out.println(de_que);> >}> }> |
>
>Lähtö
[10, 20, 30, 40, 50] [291, 564, 24, 14]>
6. Aseta käyttöliittymä
Joukko on kohteiden järjestämätön kokoelma, johon ei voida tallentaa päällekkäisiä arvoja. Tätä kokoelmaa käytetään, kun haluamme välttää objektien päällekkäisyyden ja tallentaa vain yksilölliset objektit. Tämä joukkorajapinta on toteutettu eri luokilla, kuten HashSet, TreeSet, LinkedHashSet jne. Koska kaikki alaluokat toteuttavat joukon, voimme instantioida joukkoobjektin millä tahansa näistä luokista.
Esimerkiksi:
Set hs = new HashSet (); Set lhs = new LinkedHashSet (); Set ts = new TreeSet (); Where T is the type of the object.>
Seuraavat ovat luokat, jotka toteuttavat Set-liittymän:
i). HashSet
HashSet-luokka on hajautustaulukon tietorakenteen sisäinen toteutus. HashSetiin lisäämämme objektit eivät takaa, että ne lisätään samassa järjestyksessä. Objektit lisätään niiden hash-koodin perusteella. Tämä luokka sallii myös NULL-elementtien lisäämisen. Ymmärretään HashSet esimerkillä:
Java
// Java program to demonstrate the> // working of a HashSet> import> java.util.*;> public> class> HashSetDemo {> >// Main Method> >public> static> void> main(String args[])> >{> >// Creating HashSet and> >// adding elements> >HashSet hs =>new> HashSet();> >hs.add(>'Geeks'>);> >hs.add(>'For'>);> >hs.add(>'Geeks'>);> >hs.add(>'Is'>);> >hs.add(>'Very helpful'>);> >// Traversing elements> >Iterator itr = hs.iterator();> >while> (itr.hasNext()) {> >System.out.println(itr.next());> >}> >}> }> |
>
>Lähtö
Very helpful Geeks For Is>
ii). LinkedHashSet
LinkedHashSet on hyvin samanlainen kuin HashSet. Erona on, että tämä käyttää kaksoislinkitettyä luetteloa tietojen tallentamiseen ja säilyttää elementtien järjestyksen.
Ymmärretään LinkedHashSet esimerkillä:
Java
// Java program to demonstrate the> // working of a LinkedHashSet> import> java.util.*;> public> class> LinkedHashSetDemo {> >// Main Method> >public> static> void> main(String args[])> >{> >// Creating LinkedHashSet and> >// adding elements> >LinkedHashSet lhs> >=>new> LinkedHashSet();> >lhs.add(>'Geeks'>);> >lhs.add(>'For'>);> >lhs.add(>'Geeks'>);> >lhs.add(>'Is'>);> >lhs.add(>'Very helpful'>);> >// Traversing elements> >Iterator itr = lhs.iterator();> >while> (itr.hasNext()) {> >System.out.println(itr.next());> >}> >}> }> |
>
>Lähtö
Geeks For Is Very helpful>
7. Lajiteltu sarjan käyttöliittymä
Tämä käyttöliittymä on hyvin samanlainen kuin asetettu käyttöliittymä. Ainoa ero on, että tässä käyttöliittymässä on lisämenetelmiä, jotka ylläpitävät elementtien järjestystä. Lajiteltu joukko -rajapinta laajentaa joukkorajapintaa ja sitä käytetään lajiteltavan tiedon käsittelyyn. Luokka, joka toteuttaa tämän rajapinnan, on TreeSet. Koska tämä luokka toteuttaa SortedSetin, voimme luoda SortedSet-objektin tällä luokalla.
Esimerkiksi:
SortedSet ts = new TreeSet (); Where T is the type of the object.>
Luokka, joka toteuttaa lajiteltujen joukkojen rajapinnan, on TreeSet.
TreeSet
TreeSet-luokka käyttää puuta varastointiin. Elementtien järjestystä ylläpitää joukko, joka käyttää niiden luonnollista järjestystä riippumatta siitä, tarjotaanko eksplisiittinen vertailija vai ei. Tämän on oltava yhdenmukainen yhtäläisten kanssa, jotta Set-liitäntä voidaan toteuttaa oikein. Sen voi myös tilata Comparatorilla, joka toimitetaan määritetyllä luontiajalla, riippuen siitä, mitä konstruktoria käytetään.
Ymmärretään TreeSet esimerkillä:
Java
// Java program to demonstrate the> // working of a TreeSet> import> java.util.*;> public> class> TreeSetDemo {> >// Main Method> >public> static> void> main(String args[])> >{> >// Creating TreeSet and> >// adding elements> >TreeSet ts =>new> TreeSet();> >ts.add(>'Geeks'>);> >ts.add(>'For'>);> >ts.add(>'Geeks'>);> >ts.add(>'Is'>);> >ts.add(>'Very helpful'>);> >// Traversing elements> >Iterator itr = ts.iterator();> >while> (itr.hasNext()) {> >System.out.println(itr.next());> >}> >}> }> |
>
>Lähtö
For Geeks Is Very helpful>
8. Karttakäyttöliittymä
Kartta on tietorakenne, joka tukee avain-arvo-paria tietojen kartoittamiseksi. Tämä käyttöliittymä ei tue päällekkäisiä avaimia, koska samalla avaimella ei voi olla useita kartoituksia, mutta se sallii päällekkäiset arvot eri avaimissa. Kartta on hyödyllinen, jos dataa on ja haluamme suorittaa toimintoja avaimen perusteella. Tämä karttaliittymä on toteutettu eri luokilla, kuten HashMap , TreeMap , jne. Koska kaikki alaluokat toteuttavat kartan, voimme toteuttaa karttaobjektin millä tahansa näistä luokista.
Esimerkiksi:
Map hm = new HashMap (); Map tm = new TreeMap (); Where T is the type of the object.>
Usein käytetty Map-käyttöliittymän toteutus on HashMap.
HashMap
HashMap tarjoaa Javan Map-käyttöliittymän perustoteutuksen. Se tallentaa tiedot (avain, arvo) pareina. Jotta voisimme käyttää HashMap-arvoa, meidän on tiedettävä sen avain. HashMap käyttää tekniikkaa nimeltä Hashing. Hashing on tekniikka, jolla muunnetaan suuri merkkijono pieneksi merkkijonoksi, joka edustaa samaa merkkijonoa, jotta indeksointi- ja hakutoiminnot ovat nopeampia. HashSet käyttää myös HashMapia sisäisesti.
Ymmärretään HashMap esimerkillä:
Java
// Java program to demonstrate the> // working of a HashMap> import> java.util.*;> public> class> HashMapDemo {> >// Main Method> >public> static> void> main(String args[])> >{> >// Creating HashMap and> >// adding elements> >HashMap hm> >=>new> HashMap();> >hm.put(>1>,>'Geeks'>);> >hm.put(>2>,>'For'>);> >hm.put(>3>,>'Geeks'>);> >// Finding the value for a key> >System.out.println(>'Value for 1 is '> + hm.get(>1>));> >// Traversing through the HashMap> >for> (Map.Entry e : hm.entrySet())> >System.out.println(e.getKey() +>' '> >+ e.getValue());> >}> }> |
>
>Lähtö
Value for 1 is Geeks 1 Geeks 2 For 3 Geeks>