Kolekce je sbírka objektů v operační paměti, organizovaná dle JCF ( Java Collection Framework ). JCF sídlí v balíčku java.util a zahrnuje zejména: Interfejsy: Collection<E> - sbírka objektů Set<E>, SortedSet <E> - sbírka unikátních objektů – příp. uspořádaná Map<K,V>, SortedMap <K,V> - sbírka dvojic (zobrazení) objektů key  value - příp. uspořádaná List<E> - indexovaná sbírka objektů Queue<E> - fronta ( FIFO ) Comparator<T>, java.lang.Comparable - pro porovnávání objektů Iterator<E>, ListIterator<E>, RandomAccess - pro přístup k prvkům Abstraktní třídy: AbstractCollection AbstractSet, AbstractMap, AbstractList, AbstractSequentialList PJV04

Kolekce ( Collection, Map ) Konkrétní třídy implementující Collection<E>, Cloneable, Serializable: ArrayList, LinkedList HashSet, LinkedHashSet, TreeSet, Vector, Stack, PriorityQueue, ArrayDeque Konkrétní třídy implementují Map<K,V>, Cloneable a Serializable: HashMap, LinkedHashMap, TreeMap WeakHashMap – Entry může být zrušeno je-li klíč je nepřístupný. IdentityHashMap – klíč se porovnává pomocí == , nikoli equals. EnumMap – pro klíče typu enum . Hashtable ( starší ), Properties ( inovace pro XML ) Pomocné konkrétní třídy Arrays, Collections mají jen statické metody podporující řazení, přesouvání, doplňování, kopírování a vyhledávání. Třídy *Hash* vyžadují vhodnou funkci hashCode( ) - ta generální totiž nepočítá svoji hodnotu z atributů objektu nýbrž z polohy objektu. PJV04

Iterable Set List Vector TreeSet Stack Queue HashSet Deque Linked java.lang Service Loader java.util.concurrent java.nio …. Iterable 1.8 <E> <S> SortedSet Set Collection List RandomAccess <E> <E> <E> <E> Abstract Set Abstract Collection Abstract List synch Vector NavigableSet <E> <E> <E> <E> <E> TreeSet synch Stack Abstract Queue mimo JCF Queue <E> <E> <E> <E> HashSet java.util. concurrent Deque Abstract Sequential List <E> <E> <E> Linked HashSet Priority Queue Array Deque Linked List ArrayList <E> <E> <E> <E> <E> .concurrent .concurrent Concurrent SkipListSet EnumSet Blocking Deque javax. management <E> <E> <E> - viz Collections. synchronized, unmodifiable, checked PJV04 - functional interface ALG

Arrays Scanner Iterator ListIterator Collections Comparator java.lang Iterator ListIterator 1.8 AutoCloseable 1.8 <E> <E> binarySearch, copy, equals, fill, sort, stream ….. java.io Scanner PrimitiveIterator Closeable Collections 1.8 <T,T_CONS> 1.8 javax.xml.stream binarySearch checked, sort, disjoint, frequency, synchronized, unmodifiable, … XMLEvent Reader javax.xml.stream.util EventReader Delegate Comparator Spliterator <T> <T> 1.8 java.text java.lang Collator Cloneable java.text RuleBased Collator PJV04 - functional interface ALG

Map HashMap TreeMap Linked HashMap Weak HashMap Identity HashMap java.security java.security nepatří do JCF Dictionary synch Hashtable Properties Provider Auth Provider <K,V> javax.script Map.Entry Map Bindings <K,V> 1.8 <K,V> AbstractMap. SimpleEntry javax.xml.ws.handler Abstract Map SortedMap Message Context <K,V> <K,V> AbstractMap. Simple ImmutableEntry Logical Message Context HashMap TreeMap NavigableMap <K,V> <K,V> <K,V> SOAPMessage Context Linked HashMap EnumMap <K … <K,V>> <K,V> .concurrent .concurrent Weak HashMap Concurrent SkipListMap Concurrent NavigableMap <K,V> <K,V> .concurrent .concurrent Identity HashMap Concurrent HashtMap ConcurrentMap <K,V> <K,V> - viz Collections. synchronized, unmodifiable, checked PJV04

Užité techniky interface HT RA BT LL HT+LL List - ArrayList - LinkedList - Set HashSet - - - LinkedHashSet SortedSet - - TreeSet - - Map HashMap - - - LinkedHashMap SortedMap - - TreeMap - - HT - hashtable - rozmítaná tabulka, RA - resizable array - pole s proměnnou velikostí, BT - balanced tree - vyvážený strom, LL - linked list - spojový seznam. PJV04

Hashing čili patlání chytrého poštmistra V městě kde žádném domě nebydlí stejnojmené osoby si pošmistr ukládá došlé poste-restante zásilky do očíslovaných košů. Z určených znaků jména a bydliště adresáta metodicky zpatlaně vypočítá číslo koše. Pro tazatele na zásilku stejným způsobem zpatlaně vypočítá číslo koše. Jsou-li čísla rovnoměrně zpatlaná ( metodou hashCode ) a košů je hodně, pak skoro každý koš obsahuje jen málo zásilek. Takový koš snadno postupně prohledá ( metodou equals ). Poštmistr tak rychle zásilku najde - téměř v čase O(1). Ty dvě metody musejí dodržovat tzv. kontrakt - i po překrytí: public boolean equals( Object obj ) - definuje relaci ekvivalence objektů public native int hashCode( ) – vrací číslo jež: - je konstatní v jednom běhu při neměných hodnotách užitých v equals( ). ( Např.: deserializovaný transient atribut zhatí kontrakt. Z kolekce je takový objekt nutno vyjmout a znova vložit. ) - ekvivalentní objekty - musejí vracet totéž číslo. - neekvivalentní objekty - nemusejí vracet různá čísla. Důsledek pro objekty téže třídy: hash1 != hash2 pak obj1 != obj2. . PJV02

Třída Collections má užitečné statické metody operující s objekty typu Collection, ale i Map: void sort - pro List<T>, případně s dodaným komparátorem int binarySearch - pro List<? extends Comparable<? super T>> boolean disjoint - true - nemají-li dvě Collection<?> společný prvek <T ex. max, min - pro List<? extends T> vrací max či min prvek int indexOf, lastIndexOf, indexOfSubList, lastIndexOfSubList - pro List<T> void reverse, swap, shuffle, rotate - pro List<?> addAll replaceAll - pro List<T> copy, fill, nCopies empty, enumeration, list, frequency, swap singleton, singletonList, singletonMap Set<E> newSetFromMap ( Map<E, Boolean> map ) Obálky (wrapper) pro: synchronized , unmodifiable , checked Např.: List list = Collections.synchronizedList( new ArrayList( ) ); Obdobně pro Map – viz typy označené včetně jejich podtypů. PJV04

Interfejs Collection<E> extends Iterable<E> int size( ) boolean isEmpty( ) boolean contains( Object o ) boolean containsAll( Collection <?> c ) - true, když všechny prvky c Iterator<E> iterator( ) – vrátí objekt pro probírku sbírky Object[ ] toArray( ) – převod referencí prvků do pole <T> T [ ] toArray( T [ ] a ) - s určením typu boolean add( E o ), addAll( Collection< ? extends E > c ) boolean remove( Object o ) boolean removeAll( Collection <?> c ) - odstraní prvky patřící do c boolean retainAll( Collection <?> c ) – odstraní prvky nepatřící do c void clear( ) – zruší všechy reference, tj. size( ) == 0 default void forEach( Consumer <? super E> action ) – vše pozřít default Spliterator<E> spliterator( ) – získání spliteratoru default Stream<E> stream( ) – získání proudu default Stream<E> parallelStream( ) – získání paralelního proudu default boolean removeIf( Predicate <? super E > filter ) - vyřazení 1.8 PJV04

Interfejs Collection zdědil z Iterable metody iterator a 1.8 default forEach a spliterator Třída AbstractCollection implements Collection, abstraktními zůstávají pouze metody iterator( ) a size( ). Interfejs Iterator slouží k postupnému jednosměrnému výpisu sbírky v pořadí v závislosti na jejím typu. Interfejs ListIterator extends Iterator, navíc má metody pro prohlížení oběma směry, získávání indexů a vkládání prvků. Interfejs RandomAccess je pouhý marker. PJV04

Interfejs List <E> extends Collection<E> vyžaduje přístup dle indexu k prvkům sbírky. void add ( E element ) – přidá na konec boolean addAll ( Collection < ? extends E > c ) boolean addAll ( int index, Collection < ? extends E > c ) boolean equals ( Object o ) – porovnání seznamů E get ( int index ) - E set ( int index, E element ) – nahradí element, vrátí původní E remove ( int index ) boolean remove ( Object o ), removeAll ( Collection <? extends E> c ) int indexOf ( Object o ) - hledání zepředu int lastIndexOf ( Object o ) - hledání zezadu ListIterator<E> listIterator ( ) , listIterator ( int index ) List<E> subList ( int fromIndex, int toIndex ) - pohled default void replaceAll( UnaryOperator<E> op ) default void sort( UnaryOperator<E> op ) default Spliterator<E> spliterator( ) 1.8 PJV04

Třída AbstractList extends AbstractCollection a implements List. Přidává jen metodu protected void removeRange( int, int ) a abstraktní má jen metody get( int ) a size( ). AbstractList sleduje také modifikace a komodifikace. Má tři přímé potomky: AbstractSequentialList - polotovar pro sekvenční přístup s abstraktními metodami listIterator( int ) a size( ). ArrayList - nesynchronizovaná obdoba Vectoru. Vector je stará, synchronizovaná třída - od verze 1.2 redefinovaná. Některé původní metody mají nově, systematičtěji nazvané ekvivalenty, např.: elementAt( int ) má nový ekvivalent get( int ). Radno používat ty, které jsou zavedené v příslušných interfejsech. Při probírce lépe použít Iterator iterator( ) než Enumeration elements( ). PJV04

ArrayList<E> a LinkedList<E> Třída ArrayList uchovává reference objektů v poli. Operace size, isEmpty, get, set, add, iterator a listIterator probíhají v konstantním čase, ostatní v lineárním. Konstruktor a dvě metody nastavují kapacitu tj. velikost pole a tím ovlivňují nárok na paměť i četnost a dobu relokací. Metoda ensureCapacity( ) realokuje pole o polovinu větší (defaultně: 16, 24, 36, 54, 81, 121 … ), trimToSize( ) redukuje rozsah na stávající velikost. Třída LinkedList implements Queue, Deque Kolekce objektů je uspořádána jako obousměrný spojový seznam v němž se postupně hledá pomocí ListIteratoru s lineární časovou složitostí. Pro synchronizaci resp. fixaci ( read-only ) lze zapouzdřit takto: List list = Collections.synchronizedList( new ArrayList( ) ); List list = Collections.unmodifiableList( new LinkedList( ) ); List list = Collections.checkedList( new LinkedList( ), … ); ( Obdobně pro Collection, Set, SortedSet, Map, SortedMap. ) PJV04

Třída Stack<E> extends Vector<E> Zásobník přidává metody, které nejsou : E push ( E item ) - vloží prvek na vrchol. E pop ( ) - odebere prvek z vrcholu. E peek ( ) - vrátí prvek z vrcholu, ale neodebere. boolean empty ( ) int search ( Object x ) - pozice objektu od vrcholu počítaná od 1 Tato stará, synchronizovaná třída je užitečná - ač nepatří do JCF a tedy její vlastní metody nelze využít interfejsem List. Užívejte třídy splňující interfejs Deque, ( Double Ended QUEue ) tj.: ArrayDeque, LinkedList, LinkedBlockingDeque. PJV04

Interfejsy Set<E>, SortedSet<E>, NavigableSet<E> Set extends Collection Nepřipouští duplikované prvky ( dle equals( ) ), dovoluje jedinou null. Zvláštní pozornost zasluhuje případ jsou-li prvky obsahově proměnné. Tento interfejs nepřidává další metody. SortedSet extends Set a přidává metody: Comparator<? super E> comparator( ) E first( ) - vrací první ( nejmenší ) prvek SortedSet<E> headSet( E toElement ) - vrací pohled E last( ) - vrací poslední ( největší ) prvek SortedSet<E> subSet( E fromElement, E toElement ) SortedSet<E> tailSet( E fromElement ) - vrací pohled NavigableSet extends SortedSet a přidává metody: ceiling( ), floor( ), higher( ), lower( ) descendingIterator( ), descendingSet( ) pollFirst( ), pollLast( ) PJV04

Třída AbstractSet a její potomci AbstractSet přepisuje pouze metody equals( ), hashCode( ), removeAll( ). Abstraktními zůstávají iterator( ) a size( ). Všichni následující konkrétní potomci jsou nesynchronizovaní. Třída HashSet umožňuje prvek null. Iterátor nezaručuje pořadí. Operace jsou zprostředkovány třídou HashMap v O(1) čase. Třída LinkedHashSet extends HashSet a také umožňuje prvek null. Iterátor zaručuje výstup v pořadí vkládání i v případě reinserce téhož prvku. Operace jsou zprostředkovány třídou LinkedHashMap v O(1) čase. Třída TreeSet navíc implementuje interfejs SortedSet. Iterátor zaručuje výstup v pořadí objektů buď dle Comparable anebo dodaného Comparatoru. Operace jsou zprostředkovány třídou TreeMap v čase O( log n ) . PJV04

Interfejsy pro fronty Queue<E> a Deque<E> Interfejs Queue extends Collection. Přidává obdobné metody s mírně jiným chováním: vyhazují vyjímky vracejí spec. hodnotu vložení boolean add( E e ) boolean offer( E e ) odstranění E remove( ) E poll( ) přístoupení E element( ) E peek( ) Interfejs Deque extends Queue. ( zkratka: double ended queue ) , přidává “zásobníkové” metody: E pop( ) void push( E e ) E getFirst( ) void addFirst( E e ) E peekFirst( ) E getLast( ) void addLast( E e ) E peekLast( ) Iterator<E> iterator( ) Iterator<E> descendingIterator( ) PJV04

Třída PriorityQueue<E> PriorityQueue extends AbstractQueue. Elementy jsou ve frontě dynamicky řazeny buď podle přirozeného pořadí anebo podle dodaného komparátoru. boolean add( E e ) boolean addAll( Collection<? extends E> e ) boolean contains( Object o) boolean offer( E e ) E remove( ) boolean remove( Object o ) E poll( ) E peek( ) E element( ) void clear( E e ) PJV04

Interfejs Map < K, V > Zobrazení keys -> values, tj. klíče ( množinu objektů ) na hodnoty ( multimnožinu objektů ) a definuje metody: void clear ( ) boolean containsKey ( Object key ) boolean containsValue ( Object value ) Set <Map.Entry<K,V>> entrySet ( ) V get ( Object key ) boolean isEmpty ( ) Set<K> keySet ( ) V put ( K key, V value ) void putAll ( Map< ? extends K, ? extends V > m ) V remove ( Object key ) int size ( ) Collection<V> values ( ) compute, foreach, getOrDefault, merge, putIfAbsent, remove, replace Map.Entry je vnořený interfejs s metodami: K getKey( ), V getValue(etValue), V s ( ), boolean equals( ), int hashCode( ) default 1.8 PJV04

Interfejsy SortedMap<K,V> a NavigableMap<K,V> SortedMap extends Map - přidává metody pro uspořádané zobrazení: Comparator<? super K> comparator( ) K firstKey( ) - vrací první ( nejmenší ) klíč SortedMap<K,V> headMap( Object toKey ) - vrací pohled K lastKey( ) - vrací poslední ( největší ) prvek SortedMap<K,V> subMap( K fromKey, K toKey ) - vrací pohled SortedMap<K,V> tailMap( K fromKey ) - vrací pohled NavigableMap extends SortedMap - přidává metody pro lepší navigaci: ceilingEntry( ), floorEntry( ), higherEntry( ), lowerEntry( ), ceilingKey( ), floorKey( ), higherKey( ), lowerKey( ), firstEntry( ), lastEntry( ), descendingKeySet( ), descendingMap( ), navigableKeySet( ), pollFirstEntry( ), pollLastEntry( ), PJV04

Třída AbstractMap implements Map - má jen metodu abstract keySet( ) a přidává metody: boolean containsKey ( Object x ) boolean containsValue ( Object x ) Konkrétní třídy: HashMap extends AbstractMap, umožňuje null reference. LinkedHashMap extends HashMap umožňuje zachovat pořadí vložených objektů. ( Volitelně i uspořádání least/most–recently accessed. ) TreeMap extends AbstractMap implements SortedMap. Udržuje unikátní klíče v pořadí objektů buď podle přirozeného pořadí anebo podle dodaného komparátoru. Hashtable je starší obdobou HashMap, splňuje interfejs Map, je však potomkem zastaralé abstraktní třídy Dictionary, neumožňuje null reference, je synchronizovaná. Properties je potomkem Hashtable, která umožňuje vstup i výstup pomocí proudů ( streams ). PJV04

Interfejsy Iterator<E> a ListIterator<E> Iterator požaduje metody pro objekt, kterým lze probrat sbírku: boolean hasNext ( ) - testuje zda jsou ještě další prvky E next( ) - podá další prvek default void remove( ) – odstraní prvek ze sbírky (Unsupported) default void forEachRemaining( Consumer <? Super E>) ListIterator extends Iterator s dodatečnými požadavky pro sekvenční přístup, přidávání, změny a indexování prvků metodami: E previous( ) - podá předchozí prvek int nextIndex( ) – vrátí index dalšího prvku int previousIndex( ) – vrátí index předchozího prvku void set( E e ) void add( E e ) a metody zděděné Modifikace sbírky iteratory způsobí ConcurrentModificationException. 1.8 1.8 1.8 PJV04

Interfejs Comparator < T > definuje metody objektu-rozhodčího, který ze dvou daných objektů je větší: int compare( T x, T y ) - vrací <0, 0, >0 pro x<y, x==y, x>y boolean equals ( Object obj ) - srovnává objekty typu Comparator Příklad: public class ValueComparator implements Comparator { int compare( Object x, Object y ) { float a = ( (Valuable)x ).getValue( ); float b = ( (Valuable)y ).getValue( ); return a < b ? -1 : a == b ? 0 : 1 ; } Alternativně return Float.compare(((Valuable)x).getValue(), ((Valuable)y).getValue() ); kde porovnávané objekty implementují public interface Valuable { float getValue( ) ; } PJV04

Interfejs Comparator < T > 1.8 má další 9 static metod: <T, U extends Comparable<? super U>> Comparator<T> comparing( Function< ? super T, ? extends U > keyExtractor ) <T, U>Comparator<T> comparing( ToIntFunction < ? super T> keyExtractor) <T extends Comparable<? super T>> Comparator<T> naturalOrder() <T >Comparator<T> nullsFirst( Comparator<? super T> comparator ) a dalších 7 default metod: Comparator<T> reversed( ) Comparator<T> thenComparing( ToIntFunction < ? super T> keyExtractor ) Comparator<T> thenComparing( Comparator < ? super T > other ) Int Long Double natural reverse First Last PJV04

Příklad: frekvenční statistika (1/4) Definice dosti obecné položky s čítačem výskytů: public class Item implements Comparable { private String id; private int count = 1; public Item( String id ) { this.id = id;} public String getId( ) { return id; } public int getCount( ) { return count; } public int add( ) { return ++count; } public int add( int any ) { return count += any; } public int compareTo( Object o ) { return this.id.compareTo( (Item)o.id ); } public String toString( ) { return "Item " +count+" "+id ; } PJV04

Příklad: frekvenční statistika (2/4) static Map <String, Item> map = new TreeMap <String, Item> ( ); ... enter("A"); enter("A"); enter("BB"); Set ks = map.keySet( ); System.out.println( ks ); System.out.println( map ); Item item = (Item) map.get("A"); public static void enter( String key ) { if ( map.containsKey( key ) ) { ( (Item) map.get( key ) ).add( ); } else { Item x = new Item( key ); map.put( x.getId( ), x ); } } Zadáním parametrických typů není třeba přetypovávat. PJV04

Příklad: frekvenční statistika (3/4) // Výpis relativních četností int total = 0; for ( Item it : map.values( ) ) total += it.getCount( ); for ( Map.Entry< String, Item> e : map.entrySet( ) ) System.out.println( e.getKey( )+" "+ (double) e.getValue( ).getCount( ) / total ); PJV04

Příklad: frekvenční statistika (4/4) public PriorityQueue resort( Map m ) { // řazení podle absolutní četností Iterator< Map.Entry<String, Item> > it = m.entrySet( ).iterator( ); PriorityQueue< Map.Entry<String, Item> > pq= new PriorityQueue( m.size( ), new EntryComp( ) ); while ( it.hasNext( ) ) pq.add( it.next( ) ); Map.Entry<String, Item> entry; while ( (entry = pq.poll( ) ) != null ) System.out.println( entry ); return pq; } class EntryComp implements Comparator< Map.Entry<String, Item> > { public int compare( Entry<String, Item> o1, Entry<String, Item> o2) { return o2.getCount( ) - o1.getCount( ); // sestupně PJV04