szit

Ez az oldal csak olvasható. Megtekintheted a forrását, de nem változtathatod meg. Ha úgy gondolod, hogy ez helytelen, kérdezd az Adminisztrátorokat!
[[oktatas:programozás:java|< Java]]

====== Kollekciók ======

  * **Szerző:** Sallai András
  * Copyright (c) Sallai András, 2014, 2022
  * Licenc: [[https://creativecommons.org/licenses/by-sa/4.0/|CC Attribution-Share Alike 4.0 International]]
  * Web: https://szit.hu

===== Bevezetés =====

A kollekció, azt jelenti gyűjtemény. Dolgok gyűjteménye. Angolul Collection. 
A kollekciókon összehasonlításokat végzünk, megnézzük tartalmaz-e egy elemet,
lekérdezzük hány eleme van, stb.


===== Kollekciók a Java nyelvben =====

A kollekciók esetén előfordulhat néhány hasznos eszköz:
  * java.lang.Comparable interfész
  * java.lang.Object osztály metódusai
    * equals()
    * hasCode()
  * java.util.Iterator interfész


Kollekciók interfészei:
  * Collection (java.util csomag)
    * Set
    * List
    * Queue
  * Map
    * SortedMap
    * NavigableMap


Az interfészekből megvalósított osztályok:
  * **HashSet** 
    * a Set interfészből
    * az elemekre nincs sorrend rögzítve
  * LinkedHashSet 
    * (Set interfészből)
    * tárolás a hozzáadás sorrendjében
  * TreeSet 
    * Sorted és NavigableSet interfészből
    * tárolás rendezetten; gyors keresés
  * **ArrayList**
    * List interfészből
    * Többszállas program esetén nem szinkronizált
  * Vector
    * List interfészből
    * Többszállas program esetén szinkronizált
  * **LinkedList**
    * List és Queue interfészből
    * Gyorsabb beszúrás és törlés, lassabb iterálás
  * PriorityQueue
    * Queue interfészből
  * Hashtable
    * Map interfészből
  * **HashMap**
    * Map interfészből
    * sorrend nincs rögzítve
  * **LinkedHashMap**
    * Map interfészből
    * elemek a hozzáadás sorrendjében
  * **TreeMap**
    * SortedMap és NavigableMap interfészből
    * rendezett tárolás



===== HashSet =====

<code java Program01.java>
import java.util.HashSet;
import java.util.Iterator;
class Program01
{
	public static void main(String args[])
	{
		HashSet<Integer> h = new HashSet<Integer>();
		//elem hozzáadása
		h.add(35);
		System.out.println(h.contains(35));
		//az összes elem törlése
		h.clear();
		h.add(103);
		h.add(107);
		h.add(227);
		if(h.contains(107))
			System.out.println("Van 107-es elem");
		
		Iterator it = h.iterator();
		while(it.hasNext())
			System.out.println(it.next());
		
		System.out.println("Töröljük a 227-es értéket");
		//törlés
		h.remove(227);
		
		for(Integer a : h)
			System.out.println(a);
		//méret
		System.out.println(h.size());
		//Object tömbbé alakítás
		Object[] t = h.toArray();
		System.out.println("A tömb első eleme: " + t[0]);
		
		Integer[] t2 = h.toArray(new Integer[h.size()]);
		for(Integer a : t2)
			System.out.print(a + " ");
		System.out.println();
	}
}
</code>



===== ArrayList =====


<code java Program01.java>
import java.util.ArrayList;
class Program02
{
	public static void main(String args[])
	{
		ArrayList<Integer> t = new ArrayList<Integer>();
		t.add(43);
		t.add(27);
		t.add(32);
		t.add(74);
		t.add(48);
		
		t.add(2, 50);
		
		for(Integer a : t)
			System.out.println(a);
		
		System.out.println(t.contains(50));
		System.out.println(t.get(2));
		System.out.println(t.indexOf(50));
		
		Integer b = t.remove(1);
		System.out.println(b);
		boolean c = t.remove(new Integer(48));
	}
}
</code>


===== HashMap =====


<code java Program01.java>
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Iterator;
class Program03
{
	public static void main(String args[])
	{
		HashMap<String, String> m = new HashMap<String, String>();
		m.put("alma", "apple");
		m.put("asztal", "table");
		m.put("szék", "chair");
		
		System.out.println(m.get("asztal"));
		
		System.out.println(m.containsKey("alma"));
		System.out.println(m.containsValue("apple"));
		
		Set<Map.Entry<String, String>> h = m.entrySet();
		System.out.println("------------------");		
		Iterator<Map.Entry<String, String>> i = h.iterator();
		while(i.hasNext())
		{
			Map.Entry<String, String> elem = i.next();
			System.out.println("Kulcs: "+elem.getKey()+
				"\térték: "+ elem.getValue());
		}
		System.out.println("------------------");

		System.out.println("------------------");		
		for (Map.Entry<String, String> entry : m.entrySet())
		{
			System.out.println(entry.getKey() + "\t" + entry.getValue());
		}
		System.out.println("------------------");
		
		String magyar = m.get("alma");
		System.out.println("Az alma jelentése: " + magyar);
		
		Set h2 = m.keySet();
		System.out.println("Van-e alma: " + h2.contains("alma"));
		
		String s = m.remove("asztal");
		System.out.println("Töröleve ez: " + s); //Eredmény: table
		
		m.clear();
		System.out.println(m.size());
	}
}
</code>

==== Országok és fővárosok ====

<code java Model.java>
import java.util.HashMap;

public class Model {
    HashMap<String, String> fovarosok;
    public Model() {
        fovarosok = new HashMap<>();
        fovarosok.put("Norvégia", "Oslo");
        fovarosok.put("Németország", "Berlin");
        fovarosok.put("Finnország", "Helsinki");
        fovarosok.put("Anglia", "London");
        fovarosok.put("Csehország", "Prága");
        fovarosok.put("Franciaország", "Párizs");
        fovarosok.put("Svájc", "Bern");
        fovarosok.put("Belgium", "Brüsszel");
        fovarosok.put("Hollandia", "Amszterdam");
        fovarosok.put("Szerbia", "Belgrád");
        fovarosok.put("Törökország", "Ankara");
        fovarosok.put("Ausztria", "Bécs");
        fovarosok.put("Románia", "Bukarest");
        fovarosok.put("Spanyolország", "Madrid");
        fovarosok.put("Dánia", "Koppenhága");
        fovarosok.put("Szlovákia", "Pozsony");
        fovarosok.put("Olaszország", "Róma");
        fovarosok.put("Svédország", "Stockholm");
        fovarosok.put("Bulgária", "Szófia");
        fovarosok.put("Albánia", "Tirana");
        fovarosok.put("Lengyelország", "Varsó");
        fovarosok.put("Horvátország", "Zágráb");
        fovarosok.put("Koszovó", "Pristina");
        fovarosok.put("Lettország", "Riga");
        fovarosok.put("Monetengró", "Podgorica");
        fovarosok.put("Portugália", "Lisszabon");
        fovarosok.put("Görögország", "Athén");
        fovarosok.put("Szlovénia", "Ljubljana");

    }
    
}
</code>

<code java App.java>

public class App {    
    public static void main(String[] args) throws Exception {
        System.out.println("HashMap");
        Model model = new Model();
        System.out.printf("Méret: %d\n", 
            model.fovarosok.size());
        System.out.printf("Szerbia: %s\n",
            model.fovarosok.get("Szerbia"));
    }
}

</code>

==== Metódusok ====

Néhány metódus a teljesség igénye nélkül:

| clear() | A szótár törlése |
| isEmpty() | Űres-e? |
| put(Object kulcs, Object érték) | Szópár beszúrása |
| remove(Object kulcs) | Törlés kulcs alapján |
| boolean containsValue(Object érték) | Van-e ilyen érték? |
| boolean containsKey(Object kulcs) | Van-e ilyn kulcs? |
| boolean equals(Object objektum)  | Egyenlőség vizsgálat |
| V get(Object kulcs) | Érték kulcs alapján |
| size() | Méret |




===== Várakozási sor =====

<code java Program01.java>
public class Program01 {
	
	public static void main (String args[]) {
		java.util.Queue<String> sor;
		sor = new java.util.LinkedList<String>();
		
		sor.add("Első");
		sor.add("Második");
		sor.add("Harmadik");		
		
		System.out.println(sor.remove());
		System.out.println(sor.remove());
	}
}
</code>

===== Az ArrayList és a Vector =====

^  ArrayList   ^  Vector  ^
| nem szinkronizált  | szinkronizált \\ Többszálú környezetben az egyik \\ szál zárolja az objektumot |
| gyors, mert nem szinkronizált | lassú, mert szinkronizált |
| 50%-kal növeli a tömb kapacitását | 100%-kal növeli a tömb kapacitását, \\ vagyis megduplázza |
| A JDK 1.2-ben került be | Mindig benne volt a JDK-ban. |

A kollekció létrehozásakor a Java automatikusan több elemnek foglal helyet a memóriában.
Az ArrayList induláskor 10 elemnek foglal helyet, vagyis ez a kapacitása. Ha túllépi ezt a határt, akkor 50%-kal növeli tömb méretét. A Vector megduplázza a lefoglalt méretet.

Forrás:
  * https://www.javatpoint.com/difference-between-arraylist-and-vector (2022)
  * https://www.geeksforgeeks.org/how-to-increase-the-capacity-size-of-arraylist/

===== Szűrés =====

<code java App.java>
import java.util.ArrayList;
import java.util.List;

public class App {
    public static void main(String[] args) throws Exception {
        List<Integer> numList = new ArrayList<>();
        numList.add(35);
        numList.add(27);
        numList.add(12);
        numList.add(38);

        Integer[] nums = numList
        .stream()
        .filter(e -> e > 30)
        .toArray(Integer[]::new);

        for(Integer num: nums) {
            System.out.println(num);
        }        
    }
}

</code>

Forrás:
  * https://hellokoding.com/query-an-arraylist-in-java/ (2023)


===== Példák =====

<code java Program01.java>
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.TreeMap;
import java.util.Collection;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.HashMap;

class Program01
{
	public static void main(String[] args)
	{
		
		//kiegyenlített fa
		Map<String, Integer> m = new TreeMap<String, Integer>();		
		m.put("Valami", 1);
		
		//List
		List<String> szavak = new ArrayList<String>();
		szavak.add("Első");
		szavak.add("Második");
		szavak.add("Harmadik");
		
		for (String szo : szavak)
			System.out.println(szo);
		
		ListIterator li = szavak.listIterator();
		while(li.hasNext())
		{
			System.out.println(li.next());
		}
		
		
		//Kollekció
		Collection<String> c = new ArrayList<String>();
		c.add("Egy");
		c.add("Kettő");
		c.add("Három");

		Iterator it = c.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
		
		//Hash tábla
		Map<String,String> szotar = new HashMap<String,String>();
		szotar.put("egy", "körte");
		szotar.put("kettő", "szilva");
		szotar.put("három", "barack");
	}
}
</code>

===== Linkek =====

  * http://docs.oracle.com/javase/tutorial/collections/interfaces/collection.html