Collections Összetett adatstruktúrák
Collections framework Előregyártott interface-ek és osztályok a leggyakoribb összetett adatszerkezetek megvalósítására Legtöbbször módosítás nélkül használhatók Időt, energiát takaríthatunk meg Tesztelt, minőségi és teljesítmény centrikus implementációk Nem kell különböző adatszerkezet API-kat megtanulni Támogatja a kód újrafelhasználást Package: java.util
Miből áll a keretrendszer Collection Interface-ek Az alap adatszerkezet típusokat definiálják. Ez alkotja a keretrendszer alapját. Általános implementációk A Collection interface-ek elsődleges implementációi (osztályok). Legacy implementációk Korábbi Java verziók adatszerkezet osztályai (Vector and Hashtable) a kompatibilitás miatt. Wrapper implementációk Plusz funkciók (pl. szinkronizáció, módosíthatatlanság) megvalósítása. Absztrakt implementációk részleges implementációk, melyek lehetővé teszik speciális adatszerkezetek kialakítását. Algoritmusok Statikus metódusok alapalgoritmusok megvalósítására, pl. rendezés.
Az alap interface osztályok Collection Ős interface: objektumok csoportját reprezentálja Lehet rendezett vagy rendezetlen csoport Lehet ismétlődéses vagy nem ismétlődő Nincs közvetlen implementációja A Collection leszármaztatott interface osztályai List rendezett, elemek szekvenciája Set a matematikai halmaz modellje SortedSet -
Az alap interface osztályok Map kulcs-érték párok tárolására szolgál. Azonos kulcs nem megengedett. SortedMap mint a Map de az értékeket növekvő kulcs szerint rendezve tárolja (pl. szótár)
Fontosabb Collection metódusok boolean add(object o) boolean addall( Collection c) void clear() boolean contains(object o) boolean containsall( Collection c) boolean isempty() Iterator iterator() boolean remove)object o) boolean removeall(collection c) boolean retainall(collection c) int size() Object[] toarray() Object[] toarray( Object[] a)
Collection interface public interface Collection { // Basic Operations int size(); boolean isempty(); boolean contains(object element); boolean add(object element); // Optional boolean remove(object element); // Optional Iterator iterator(); // Bulk Operations boolean containsall(collection c); boolean addall(collection c); // Optional boolean removeall(collection c); // Optional boolean retainall(collection c); // Optional void clear(); // Optional // Array Operations Object[] toarray(); Object[] toarray(object a[]);
Módosítás A módosítás opcionális operátor Nem mindegyik implementáció támogatja UnsupportedOperationException
A List interface public interface List extends Collection { // Positional Access Object get(int index); Object set(int index, Object element); // Optional void add(int index, Object element); // Optional Object remove(int index); // Optional abstract boolean addall(int index, Collection c); // Optional // Search int indexof(object o); int lastindexof(object o); // Iteration ListIterator listiterator(); ListIterator listiterator(int index); // Range-view List sublist(int from, int to);
A Set interface public interface Set { // Basic Operations int size(); boolean isempty(); boolean contains(object element); boolean add(object element); // Optional boolean remove(object element); // Optional Iterator iterator(); // Bulk Operations boolean containsall(collection c); boolean addall(collection c); // Optional boolean removeall(collection c); // Optional boolean retainall(collection c); // Optional void clear(); // Optional // Array Operations Object[] toarray(); Object[] toarray(object a[]);
A Map interface public interface Map { // Basic Operations Object put(object key, Object value); Object get(object key); Object remove(object key); boolean containskey(object key); boolean containsvalue(object value); int size(); boolean isempty(); // Bulk Operations void putall(map t); void clear(); // Collection Views public Set keyset(); public Collection values(); public Set entryset(); // Interface for entryset elements public interface Entry { Object getkey(); Object getvalue(); Object setvalue(object value);
Alap implementációs osztályok List ArrayList általános célú LinkedList bizonyos esetekben gyorsabb Set HashSet gyors, nincs sorrend TreeSet sorrend van Map HashMap - gyors, nincs sorrend TreeMap sorrend van
Iterator public boolean hasnext() public Object next() Returns: the next element in the iteration. Throws: NoSuchElementException - iteration has no more elements. public void remove()
Collection Algoritmusok A Collections (!) osztály statikus metódusai Legtöbbjük a List adatszerkezeten működik Rendezés sort Keverés shuffle Adat manipuláció reverse, fill, copy Keresés - binarysearch Extrémumok keresése min, max
Rendezési példa import java.util.*; public class Sort { public static void main(string args[]) { List l = Arrays.asList(args); Collections.sort(l); System.out.println(l);
Sort Két formája van sort(list list) normál sorrend sort(list list, Comparator c) komparátor által meghatározott sorrend Comparator interface int compare(object a, Object b) Returns: neg, 0, pos
Változások az 1.5 verziótól kezdve Új interfészek és osztályok Queue Vector
Cast problémák List myintlist = new LinkedList(); // 1 myintlist.add(new Integer(0)); // 2 Integer x = (Integer) myintlist.iterator().next(); // 3 Or String[] s = (String[])myTextList.toArray(); Nincs fordításkor ellenőrzés!
Generics Hasonló a C++ template-hez Paraméterezhető osztályokat és metódusokat eredményez Általánosabb kód Fordítás közbeni ellenőrzés lehetséges Collection<E> The most commonly used type parameter names are: E - Element (used extensively by the Java Collections Framework) K - Key N - Number T - Type V - Value S,U,V etc. - 2nd, 3rd, 4th types
Példa /** * Generic version of the Box class. */ public class Box<T> { private T t; // T stands for "Type" public void add(t t) { this.t = t; public T get() { return t; Box<Integer> integerbox; integerbox = new Box<Integer>();
Új Collection interface public interface Collection<E> extends Iterable<E> { // Basic operations int size(); boolean contains(object element); boolean add(e element); //optional boolean remove(object element); //optional Iterator<E> iterator(); // Bulk operations boolean containsall(collection<?> c); boolean addall(collection<? extends E> c); //optional boolean retainall(collection<?> c); //optional // Array operations Object[] toarray(); <T> T[] toarray(t[] a);
Módosított interfészek public interface List<E> { void add(e x); Iterator<E> iterator(); public interface Iterator<E> { E next(); boolean hasnext();
List<Integer> myintlist = new LinkedList<Integer>(); // 1 myintlist.add(new Integer(0)); //2 Integer x = myintlist.iterator().next(); // 3