java collections framework tutorial
Tento výukový program podrobně vysvětluje rámec Java Collections Framework (JCF) spolu s hierarchií kolekcí, různými rozhraními a výhodami JCF:
Doufám, že tyto výmluvné návody k tomu Série Java pro začátečníky jsou opravdu užitečné při obohacení vašich znalostí jazyka Java.
Náš předchozí tutoriál stručně informoval o základní I / O operace v Javě . V tomto kurzu se podrobně seznámíme s Java Collection Framework (JCF).
Java Collections Framework (JCF) obsahuje rozhraní, abstraktní třídy a třídy, které mohou poskytnout architekturu pro ukládání a manipulaci se skupinou objektů.
Co se naučíte:
- Výukové videonávody v prostředí Java Collections Framework
- Závěr
Výukové videonávody v prostředí Java Collections Framework
Znalost Arraylist v Javě:
Nastavte rozhraní a frontové rozhraní v Javě pomocí příkladů v reálném čase:
HashMap, TreeMap a HashTable v Javě:
Zatím jsme viděli proměnné, které ukládají různé typy dat. Jedná se o singulární jednotky a nejsou příliš užitečné, pokud máte obrovské množství dat k ukládání a řešení. Jak víme, data jsou nejdůležitější složkou počítačového zpracování.
Vaše aplikace musí být schopna extrahovat a shromáždit data, zpracovat je, aby zjistila užitečné informace, a také je předat sem a tam, aby byla efektivně použita k dosažení řešení.
V tomto softwarovém světě ukládáme data, která je třeba strukturovat určitým způsobem, aby softwarové programy byly schopny ukládat, číst, zpracovávat a nakonec vydávat výsledky. To se provádí pomocí datových struktur.
Téměř všechny programovací jazyky podporují datové struktury. Datovou strukturu lze definovat jako strukturovanou reprezentaci dat. Programovací jazyky poskytují funkce API (Application Programming Interface) za účelem manipulace s datovými strukturami.
Need For Collection Framework
Před verzí Java 1.2 podporoval programovací jazyk Java datové struktury, jako jsou pole, vektory nebo hashovací tabulky. Provádění operací na těchto datových strukturách nebylo snadné, protože na těchto datových strukturách neexistovalo žádné společné rozhraní, které by fungovalo.
Programátoři považovali za obtížné psát algoritmy, které by fungovaly pro všechny datové struktury a byly velkým problémem. Bylo zapotřebí společné rozhraní, které by fungovalo konzistentně na všech datových strukturách a také efektivně provádělo operace.
Později Java přišla s frameworkem sbírek, což je skupina tříd a rozhraní skládající se z různých operací, které lze s datovými strukturami provádět.
V tomto výukovém programu Java Collections budeme obecně diskutovat o prostředí Java Collections Framework. Prozkoumáme každou z komponent kolekce v našich připravovaných tutoriálech.
Rámec kolekcí Java
Než definujeme rámec Java Collections Framework, poznejme význam kolekce a rámce.
Kolekce může být definována jako skupina objektů. Kolekce je obvykle jedna jednotka skládající se z více než jednoho objektu. Rámec je software, který má hotové funkční rozhraní nebo architekturu a také obsahuje sadu tříd a rozhraní, která se mají použít s poskytnutým rozhraním.
Rámec kolekcí je definován jako jednotná, připravená architektura skládající se z níže uvedeného.
# 1) Algoritmy
Jedná se o metody nebo sadu příkazů, které mohou programátorům pomoci při vyhledávání, třídění a zpracování shromážděných dat. Kolekce je dodávána s rozhraními, třídami a algoritmy.
Aplikace, které jsou vyvinuty zděděním rámce kolekce, mají přístup k těmto algoritmům a používají již definované metody a postupy.
# 2) Rozhraní
Rozhraní v Javě poskytují abstrakci implementace, tj. Pomocí rozhraní si uživatel není vědom podrobností implementace, ale může vidět pouze metody a data potřebná k napsání aplikace. Rozhraní kolekce má mnoho rozhraní, která mohou být implementována programátorem pro psaní vlastních tříd.
# 3) Třídy
Třídy Collection Framework jsou datové struktury, které lze implementovat v programu. Tyto třídy implementují rozhraní „Collection“, a tak dědí všechny metody a definice rozhraní kolekce.
Rámec kolekce se používá pro ukládání a manipulaci s kolekcí, která je skupinou objektů.
Rámec kolekce Java se skládá z vysoce výkonných algoritmů, které provádějí standardní operace, jako je vyhledávání, třídění a zpracování. Poskytuje různé standardní implementace, včetně LinkedList, TreeSet a HashSet, pro která jsou k dispozici rozhraní.
Dále pochopíme hierarchii kolekce Java.
Hierarchie kolekce Java
Všechny třídy a rozhraní zobrazené v níže uvedené hierarchii kolekce Java patří do balíčku „java.util. *“.
Jak ukazuje výše uvedený diagram, hierarchie kolekce Java se skládá z různých tříd a rozhraní. Jak vidíte, každá třída dědí z rozhraní a všechny třídy a rozhraní zase zdědí z jediného rozhraní „kolekce“.
Pojďme diskutovat o některých běžných metodách v rozhraní kolekce spolu s krátkým úvodem o každé z tříd a rozhraní, které jsou uvedeny ve výše uvedené hierarchii.
Rozhraní kolekce
Rozhraní kolekce je kořenové rozhraní. Všechny třídy v rámci kolekce implementují rozhraní kolekce. To znamená, že každá kolekce bude mít metody deklarované v rozhraní kolekce.
Níže jsou uvedeny některé metody rozhraní Collection.
| Nedělej | Metoda Prototyp | Popis |
|---|---|---|
| 7 | default boolean removeIf (filtr predikátů) | Odeberte ze sbírky všechny prvky, které splňují daný „predikát“ predikátu. |
| 1 | public int size () | Vrátí počet prvků v dané kolekci. |
| dva | public void clear () | Vymaže kolekci odebráním všech prvků z kolekce. |
| 3 | public boolean add (E e) | Vloží prvek e do kolekce. |
| 4 | public booleanaddAll (kolekce c) | Vložte všechny prvky v kolekci dané c do kolekce. |
| 5 | public boolean remove (prvek objektu) | Odstranit prvek daný „prvkem“ z kolekce. |
| 6 | public boolean removeAll (Collectionc) | Odeberte kolekci c ze sbírky. |
| 8 | public booleanretain All (kolekce c) | Odstraňte všechny prvky z kolekce kromě těch v uvedené kolekci c. |
| 9 | veřejný iterátor iterátoru () | Vraťte iterátor kolekce. |
| 10 | public Object () toArray () | Převést kolekci do pole. |
| jedenáct | veřejné T () toArray (T () a) | Převést kolekci na pole se zadaným návratovým typem. |
| 12 | public boolean isEmpty () | Vraťte se, pokud je sbírka prázdná nebo ne. |
| 13 | public boolean contains (Object element) | Zkontrolujte, zda kolekce obsahuje daný prvek (operace vyhledávání). |
| 14 | public booleancontainsAll (Collectionc) | Zkontrolujte, zda kolekce obsahuje v ní specifikovanou kolekci c. |
| patnáct | výchozí rozdělovač Spliterator () | Vrátí rozdělovač přes zadanou kolekci. |
| 16 | public booleanequals (Object element) | Používá se k párování dvou sbírek. |
| 17 | výchozí Stream parallelStream () | Vrátí paralelní stream pomocí kolekce jako zdroje. |
| 18 | výchozí Streamstream () | Vrátí sekvenční stream využívající kolekci jako zdroj. |
| 19 | public int hashCode () | Vrátí číselný hashcode kolekce. |
Iterovatelné rozhraní
Iterovatelné rozhraní je také základním rozhraním rámce kolekce. Rozhraní Collection, které je nadřazeným rozhraním všech ostatních tříd, rozšiřuje Iterable rozhraní. Proto všechny třídy implementují rozhraní kolekce i rozhraní Iterable.
Iterovatelné rozhraní má pouze jednu metodu iterátor (), která vrací iterátor (), který můžete použít k iteraci nad prvky typu T.
Iterator iterator ()Iterátorové rozhraní
Rozhraní Iterator poskytuje schopnost iterovat prvky v dopředném směru.
Níže jsou uvedeny metody, které toto rozhraní podporuje.
| Nedělej | Metoda Prototyp | Popis |
|---|---|---|
| 1 | public Object next () | Nejprve vrátí prvek a poté přesune kurzor tak, aby ukazoval na další prvek. |
| dva | public boolean hasNext () | Zkontroluje, zda má iterátor více prvků. |
| 3 | public void remove () | Odebere prvek, který je na konci vrácen iterátorem. |
Seznam rozhraní
Rozhraní seznamu dědí rozhraní kolekce. Rozhraní seznamu obsahuje datové struktury, které se používají k ukládání objednaných dat nebo shromažďování objektů. Tyto datové struktury jsou typu seznamu. Tyto datové struktury implementující rozhraní seznamu mohou nebo nemusí mít duplicitní hodnoty.
Rozhraní seznamu obsahuje metody, které se používají k přístupu, vložení nebo odebrání prvků z objektů seznamu.
Různé třídy, které implementují rozhraní seznamu, jsou následující:
základní otázky a odpovědi na sql pro nováčky
- ArrayList
- Spojový seznam
- Vektor
- Zásobník
Každou z těchto tříd krátce probereme. Naše následující témata budou mít podrobnou diskusi o každé z tříd rámcových kolekcí.
# 1) ArrayList
ArrayList je nejjednodušší implementace rozhraní List. ArrayList zachovává pořadí vložení a není synchronizováno.
Obecná definice datové struktury ArrayList (Collection) je následující:
List list1= new ArrayList ();Jakmile je seznam definován, můžete k přidání prvků použít metodu „add“. Všimněte si, že ArrayList interně používal mechanismus dynamického pole.
Podívejte se na následující příklady, které vytvářejí kolekci barev ArrayList.
import java.util.*; class Main { public static void main(String args()) { //Creating arraylist of String objects ArrayList color_list=new ArrayList(); //populate the arraylist with add method color_list.add('Red'); color_list.add('Green'); color_list.add('Blue'); color_list.add('Cyan'); color_list.add('Magenta'); color_list.add('Yellow'); //Traverse the list through Iterator Iterator itr=color_list.iterator(); System.out.println('The contents of the arraylist are:'); while(itr.hasNext()){ System.out.println(itr.next()); } } } Výstup:
Výše uvedený program ukazuje ukázku kolekce ArrayList. Přidáme do kolekce barevné hodnoty a poté procházíme kolekcí, abychom pomocí iterátoru zobrazili jednotlivé hodnoty v kolekci.
# 2) LinkedList
Kolekce LinkedList interně používá mechanismus dvojnásobně propojeného seznamu pro ukládání prvků. Může obsahovat duplicitní prvky. Operace shromažďování LinkedList jsou rychlejší, protože posun prvků není nutný.
Obecná definice vytvoření propojeného seznamu je následující:
List list2 = new LinkedList ();Následující program ukazuje propojená kolekce seznamů čísel .
import java.util.*; class Main { public static void main(String args()) { //linked list of String objects LinkedList linkedlist_num=new LinkedList(); linkedlist_num.add('one'); linkedlist_num.add('two'); linkedlist_num.add('three'); linkedlist_num.add('four'); linkedlist_num.add('five'); //iterate over the linked list to display contents Iterator itr=linkedlist_num.iterator(); System.out.println('The contents of the linked list are:'); while(itr.hasNext()) { System.out.println(itr.next()); } } } Výstup:
Vytvoříme tedy propojený seznam a poté do něj přidáme prvky pomocí metody „add“. Poté pomocí iterátoru projdeme propojeným seznamem a zobrazíme každý prvek.
# 3) Vektor
Vektor je podobný ArrayList a používá dynamické pole k ukládání prvků jako ArrayList. Ale vektor podporuje mnoho nezávislých metod kromě kolekce, díky které je lepší volbou být preferovanou kolekcí.
Obecná definice vektorové kolekce je:
List list3 = new Vector();Všimněte si, že ačkoli vektor a ArrayList používají stejný mechanismus dynamických polí, vektorové prvky jsou synchronizovány.
Níže uvedený program Java demonstruje použití vektorů v rámci kolekce .
import java.util.*; public class Main { public static void main(String args()) { Vector subject_vector=new Vector(); subject_vector.add('English'); subject_vector.add('Hindi'); subject_vector.add('Maths'); subject_vector.add('Science'); Iterator itr=subject_vector.iterator(); System.out.println('Vector contents:'); while(itr.hasNext()) { System.out.println(itr.next()); } } } Výstup:
V tomto programu jsme definovali vektorovou sbírku skládající se z předmětů. Přidáme různé předměty a pak použijeme iterátor k výstupu prvků.
# 4) Zásobník
Stacková datová struktura implementuje způsob vkládání prvků last-in-first-out (LIFO). Zásobník je podtřídou vektoru třídy (viz diagram hierarchie kolekce výše). Kromě vlastních metod podporuje kolekce zásobníku také metody vektorové kolekce.
Obecná definice Stack kolekce je:
List list4 = new Stack();Následující program implementuje Stack collection .
import java.util.*; public class Main { public static void main(String args()) { Stack even_stack = new Stack (); even_stack.push(2); even_stack.push(4); even_stack.push(6); even_stack.push(8); even_stack.push(10); System.out.println('The element removed from stack: ' + even_stack.pop()); Iterator itr=even_stack.iterator(); System.out.println('The contents of the stack are:'); while(itr.hasNext()) { System.out.print(itr.next() + ' '); } } } Výstup:
Jak vidíte ve výše uvedené implementaci, nové prvky se přidají do zásobníku pomocí 'tam' úkon. Zásobník má jediný vstupní bod s názvem „Horní část zásobníku“ a prvky jsou tlačeny do zásobníku v horní části. Poslední přidaný prvek je tedy v horní části zásobníku.
Stejně jako přidávání, prvky jsou také odstraněny z jednoho konce, tj. Horní části zásobníku. K odebrání prvků se používá operace „pop“. Pokud tedy zavoláte pop (), prvek v horní části zásobníku bude odstraněn.
Ve výstupu výše vložíme prvek 2, 4, 6,8,10 a poté zavoláme pop (), takže 10 bude odstraněno.
Rozhraní fronty
Kolekce odvozené z rozhraní fronty sledují pořadí first-in-first-out (FIFO). Prvky jsou vloženy na jednom konci a jsou odstraněny z druhého konce. Prvkem zadaným jako první je tedy prvek, který je odstraněn jako první.
Níže jsou uvedeny kolekce podporující rozhraní dotazu.
- Prioritní fronta
- a rozhraní
- ArrayDeque
Pojďme si krátce promluvit o každém z nich.
# 1) PriorityQueue
V kolekci PriorityQueue se uložené prvky zpracovávají na základě jejich priorit. Ve frontě priorit nelze ukládat hodnoty null.
Obecná definice prioritní fronty je následující:
Queue q1 = new PriorityQueue();Níže uvedený program implementuje prioritní frontu.
import java.util.*; public class Main { public static void main(String args()) { PriorityQueue color_queue=new PriorityQueue(); color_queue.add('red'); color_queue.add('green'); color_queue.add('blue'); color_queue.add('cyan'); color_queue.add('magenta'); color_queue.add('yellow'); System.out.println('Priority Queue elements:'); System.out.println('head:'+color_queue.peek()); System.out.println('Other elements in Priority Queue:'); Iterator itr=color_queue.iterator(); while(itr.hasNext()) { System.out.print(itr.next() + ' '); } System.out.println('
'); color_queue.remove(); System.out.println('After removing element, new head:'+color_queue.element()); System.out.println('
'); color_queue.poll(); System.out.println('After removing another element, Priority Queue :'); Iterator itr2=color_queue.iterator(); while(itr2.hasNext()) { System.out.print(itr2.next() + ' '); } } } Výstup:
Opět používáme barvy jako prvky prioritní fronty. Ve výše uvedeném programu jsme použili metody add a remove k přidání prvků do fronty a odebrání prvku. Používáme metodu peek (), která vrací prvek, na který ukazuje ve frontě priorit.
Nakonec se pomocí iterátoru zobrazí prvky prioritní fronty.
# 2) dotykové rozhraní
Deque neboli „dvojitá fronta“ je datová struktura, která umožňuje přidávat a odebírat prvky z obou konců. Deque rozhraní v rámci kolekce prostředí Java, které rozšiřuje rozhraní fronty.
Poskytuje funkčnost deque a má třídu, kterou z ní dědí „ArrayDeque“.
# 3) ArrayDeque
ArrayDeque implementuje deque rozhraní.
Obecná definice ArrayDeque je následující:
Deque d = new ArrayDeque();ArrayDeque umožňuje používat funkce Deque. Na rozdíl od jiných kolekcí, jako je ArrayList nebo stack, nemá ArrayDeque žádná omezení své kapacity.
Následující příklad ukazuje implementaci ArrayDeque.
import java.util.*; public class Main { public static void main(String() args) { //Creating Deque and adding elements Deque deque = new ArrayDeque (); deque.add(10); deque.add(20); deque.add(30); System.out.println('Deque Elements:'); //Traversing elements for (Integer num : deque) { System.out.println(num); } } } Výstup:
Ve výše uvedeném programu definujeme kolekci ArrayDeque typu integer a přidáme do ní celočíselné prvky pomocí metody add. Kolekce je poté procházena pomocí konstrukce for.
Nastavit rozhraní
Nastavené rozhraní je součástí balíčku java.util a vychází z rozhraní kolekce. Sada je struktura, která neumožňuje kolekci mít duplicitní hodnoty a také více než jednu nulovou hodnotu.
Následující třídy implementují nastavené rozhraní.
- HashSet
- LinkedHashSet
- Sada stromů
# 1) HashSet
Kolekce HashSet, která implementuje rozhraní Set, má v sobě uložené odlišné hodnoty. Tato kolekce používá hashovací techniku k ukládání položek a používá hashovací tabulku pro ukládání prvků.
T Obecná definice kolekce HashSet je uvedena níže.
Set s1 = new HashSet();Implementaci HashSet jsme dali v následujícím programu.
import java.util.*; public class Main { public static void main(String args()) { //Create HashSet set_subjects HashSet set_subjects=new HashSet(); System.out.println('Elements in the given hashsetset_subjects are:'); set_subjects.add('Maths'); set_subjects.add('Computers'); set_subjects.add('English'); set_subjects.add('French'); //Traverse the hashset Iterator itr=set_subjects.iterator(); while(itr.hasNext()) { System.out.println(itr.next()); } } } Výstup:
Ve výše uvedeném programu vytvoříme kolekci předmětů HashSet a poté ji projdeme pomocí iterátoru k zobrazení prvků v kolekci.
jak extrahovat soubory 7z na mac
# 2) LinkedHashSet
LinkedHashSet implementuje nastavené rozhraní a rozšiřuje HashSet (viz hierarchie kolekce). LinkedHashSet je propojená seznamová reprezentace sady rozhraní. LinkedHashSet obsahuje jedinečné prvky, ale umožňuje hodnoty null.
Obecná definice LinkedHashSet je uvedena níže.
Set s2 = new LinkedHashSet();Implementace pro LinkedHashSet je uvedena níže.
import java.util.*; public class Main { public static void main(String args()) { LinkedHashSet set_subjects=new LinkedHashSet(); System.out.println('Elements in the LinkedHashSet set_subjects:'); set_subjects.add('Maths'); set_subjects.add('Computers'); set_subjects.add('English'); set_subjects.add('Sanskrit'); Iterator itr=set_subjects.iterator(); while(itr.hasNext()) { System.out.println(itr.next()); } } } Výstup:
K vytváření Linkedhashset opět využíváme názvy knih. Jak můžete vidět z výstupu, pořadí přidávání je udržováno linkedHashSet.
Rozhraní SortedSet
Rozhraní SortedSet umožňuje úplné řazení prvků. Obsahuje metody, které poskytují přirozené řazení prvků. Prvky v kolekci, které implementují rozhraní SortedSet, jsou uspořádány ve vzestupném pořadí.
Třída TreeSet je jedním z příkladů, které implementuje rozhraní SortedSet.
Strom
Obecná definice stromu je následující:
Set s3 = new TreeSet();TreeSet implementuje rozhraní SortedSet a obsahuje jedinečné prvky. Ukládání a načítání je poměrně rychlé a poté jsou prvky seřazeny vzestupně.
import java.util.*; public class Main{ public static void main(String args()) { //create a treeset of integers TreeSet set_oddnums=new TreeSet (); set_oddnums.add(1); set_oddnums.add(3); set_oddnums.add(5); set_oddnums.add(7); set_oddnums.add(9); System.out.println('Elements in TreeSet are:'); //traverse the treeset using iterator Iterator itr=set_oddnums.iterator(); while(itr.hasNext()) { System.out.print(itr.next() + ' '); } } } Výstup:
Ve výše uvedeném programu jsme pomocí metod add vytvořili a přidali do kolekce lichá čísla. Potom pomocí iterátoru vydáme prvky v kolekci.
Výhody prostředí Java Collections Framework
- Snížené programování: Rámec Collections přichází se všemi rozhraními a třídami obsahujícími metody, které programátorům umožňují psát efektivní program. Tímto způsobem se programátor nemusí soustředit na příliš mnoho programování.
- Konzistentní metody a API: Všechny třídy mají společné metody, které působí na data. Tyto API jsou konzistentní ve všech třídách a programátor se nemusí obávat, že bude mít pro každou třídu příliš mnoho různých metod.
- Zvyšte rychlost a přesnost: Můžete psát vysoce efektivní programy pomocí rámce kolekce a také rychlejší a přesnější programy, protože rámec kolekce poskytuje plnou funkčnost pro implementaci datových struktur a kolekcí.
- Usnadňuje opětovné použití softwaru: Datové struktury a algoritmy rámce kolekce Java jsou opakovaně použitelné.
- Interoperabilita mezi nesouvisejícími API: Collection API umožňují interoperabilitu i mezi nesouvisejícími API.
- Méně úsilí při navrhování nových API: Programátoři mohou používat standardní kolekce API a na základě toho navrhovat nová API. Nemusí se snažit psát úplně nová API.
Často kladené otázky
# 1) Jaké je použití rámce kolekce v Javě?
Odpovědět: Rámec kolekce nabízí předem zabalené algoritmy, rozhraní a třídy, které programátorům umožňují psát vysoce efektivní programy, které mohou ukládat a zpracovávat data.
# 2) Proč je Collection rámec?
Odpovědět: Rámec je opakovaně použitelná kolekce tříd, rozhraní a algoritmů. Rámec kolekce je také opakovaně použitelnou kolekcí tříd datových struktur a algoritmů pracujících na těchto třídách.
# 3) Co je Java Collections API v Javě?
Odpovědět: Rozhraní API pro kolekce Java poskytuje rozhraní a třídy, které lze rozšířit a implementovat, aby bylo možné používat datové struktury, které nejsou ničím jiným než kolekcemi.
# 4) Jaký je rozdíl mezi kolekcí a kolekcemi v Javě?
Odpovědět: Kolekce je základním rozhraním v rámci kolekce, zatímco kolekce je třída. Oba jsou součástí balíčku java.util.
**** Další podrobnosti a příklady prostředí Java Collections Framework: ****
Porovnání mezi seznamem, sadou a frontou:
| Seznam | Soubor | Fronta |
|---|---|---|
| Pořadí vložení je zachováno | Pořadí vložení není udržováno v sadě hash | Pořadí vložení je zachováno. |
| Může obsahovat duplicitní prvky | Nelze obsahovat duplicitní prvky | Může obsahovat duplicitní prvky. |
| Vložení a odebrání pole lze provést pro jakýkoli index. | Odeberte určený prvek. | Vyskakovat lze pouze poslední vložený prvek. K vložení prvků dochází také na konci. |
Třída seznamu polí
V poli je přidělení paměti pevné. Ale v ArrayList lze paměť alokovat dynamicky. Tato třída ArrayList udržuje pořadí vložení a můžete vložit duplicitní prvky.
Demo program pro seznam polí:
public class ArrayListDemo { public static void main(String() args) { ArrayList li = new ArrayList (); li.add(1); li.add(2); li.add(3); li.remove(0); for (Integer temp : li) { System.out.println(temp); } System.out.println('=========='); ArrayList l = new ArrayList(); l.add('text1'); l.add('text2'); l.add('text3'); for (String temp : l) { System.out.println(temp); } System.out.println('=========='); ArrayList al=new ArrayList(); al.add(1); al.add(2); al.forEach((a)->;System.out.println(a)); } } 
Třída LinkedList
Datová struktura propojeného seznamu obsahuje uzly a tento uzel bude obsahovat dvě části:
- Data
- Odkaz na další prvek
První uzel není samostatný uzel. Obsahuje pouze odkaz a nazývá se hlava. Poslední uzel má hodnotu null.
Demo program:
public class LinkedListDemo { public static void main(String() args) { LinkedList list =new LinkedList(); list.add(22); list.add(44); list.add(46); list.add(46); list.add(46); for(Integer temp:list) { System.out.println(temp); } Iterator it =list.iterator(); while(it.hasNext()) { System.out.println(it.next()); } System.out.println('=========='); for (int i=0;i 
Fronta
Fronta je datová struktura FIFO (first in first out). Pokud zavoláte metodu remove, bude z fronty odebrán vždy první vložený prvek. Fronta se tedy používá v aplikaci v reálném čase, kde je nutné data načíst v vloženém pořadí.
Příklad programu:
public class QueueDemo { public static void main(String() args) { PriorityQueue pq=new PriorityQueue(); pq.add(1); pq.add(2); pq.add(3); pq.add(4); pq.add(5); pq.add(6); pq.add(7); for(int temp : pq) { System.out.println(temp); } pq.remove(); System.out.println('queue after removing a element'); System.out.println(pq); } } 
Soubor
Sada kolekce neumožňuje duplicitní prvky. Nastavenou datovou strukturu můžete použít, když chcete zpracovat sběr dat bez duplikace a když není nutné udržovat pořadí vložení.
Demo program:
public class demohashset { public static void main (String() args){ HashSet hs=new HashSet(); hs.add(23); hs.add(24); hs.add(25); hs.add(26); hs.add(27); hs.add(28); hs.add(293); hs.add(203); hs.add(263); hs.add(243); hs.add(243); (int temp:hs) { System.out.println(temp); } hs.remove(24); hs.remove(23); System.out.println('==============='); System.out.println('after removing a element ::::'); System.out.println('==============='); hs.forEach((temp)->System.out.println(temp)); ; } } 
Rozhraní MAP
- Pokud chcete sbírat prvky s dvojicí klíč a hodnota, můžete použít strukturu dat mapy, protože mapa je objekt, který může mapovat klíče na hodnoty.
- Mapa nemůže obsahovat duplicitní klíče.
- Důležité implementace mapy jsou HashMap, Treemap, LinkedHashMap, HashTable.
Rozdíl mezi HashMap, Treemap, LinkedHashMap a HashTable:
HashMap TreeMap LinkedHashmap HashTable Nulové klíče a hodnoty jsou povoleny Povoleny jsou pouze nulové hodnoty. Jsou povoleny nulové klíče a hodnoty. Nepovolí nulové klíče a hodnoty. Nesynchronizováno Nesynchronizováno Nesynchronizováno synchronizované Neexistuje žádná záruka udržování pořádku v iteraci Třídění bude probíhat na základě přirozeného pořadí. Objednávka vložení bude zachována Objednávka vložení není udržována.
Demo program:
public class HashMapDemo { public static void main(String() args) { HashMap m=new HashMap(); m.put(1, 'one'); m.put(2, 'two'); m.put(3, 'three'); m.put(4, 'four'); m.put(null, 'one'); m.put(null, null); System.out.println(m); TreeMap tm =new TreeMap(); tm.put('R', 'red'); tm.put('B', null); tm.put('G', 'green'); System.out.println(tm); Hashtable ht =new Hashtable(); ht.put(1, 'one'); ht.put(2, 'two'); ht.put(3, 'three'); ht.put(4, 'four'); System.out.println(ht); } } 
Klíčové body, které je třeba poznamenat:
- Seznam, fronta, nastavená rozhraní rozšiřují rozhraní kolekce a toto rozhraní kolekce má běžné metody, jako je přidání, odebrání atd.
- Pořadí vložení je udržováno v seznamu a sada nemůže obsahovat duplicitní prvky. Fronta je datová struktura First in First out.
- Mapa bude obsahovat páry klíčů a hodnot. HashMap, Treemap, Hashtable, Linked HashMap jsou důležitou implementací mapového rozhraní.
Závěr
Tento výukový program nám představil úvod do prostředí Java Collections Framework. Krátce jsme se dotkli všech tříd a rozhraní, která jsou součástí rámce kolekce Java.
V našich dalších výukách v této sérii se podrobně seznámíme s každou z těchto tříd a rozhraní.
Více o Reflections v JAVA si můžete prohlédnout v našem připravovaném tutoriálu !!!
Výukový program PREV | DALŠÍ výuka
Doporučené čtení
- Výukový program Java Reflection s příklady
- Výukové programy pro zatmění do hloubky pro začátečníky
- Výukový program Java SWING: Kontejner, komponenty a zpracování událostí
- Výukový program JAVA pro začátečníky: 100+ praktických výukových programů Java Video
- Modifikátory přístupu v Javě - výuka s příklady
- Výukový program Java String s funkcí String Buffer a String Builder
- Úvod do programovacího jazyka Java - výukový program
- Cucumber Selenium Tutorial: Cucumber Java Selenium WebDriver Integration
