Java 5 ist mittlerweile weit verbreitet, und Entwickler sollten auf der einen Seite die neuen Spracheigenschaften kennenlernen, auf der anderen Seite sich mit dem Update der Bibliotheken beschäftigen. Als Startlinks gelten:

• http://www.tutego.com/java/java-1.5-neuigkeiten.htm
• http://www.tutego.com/java/java-6-mustang-news.htm

Von jeder neue Klasse und Schnittstelle sollte man zumindest den API-Kopf gelesen haben. Besonderes Augenmerk sollten Entwickler auf Generics legen. Hier gilt hervorzuheben das Tutorial http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf. Die Begriffe

• Generischer Typ
• Typparameter
• formalter Typparameter
• parametrisierter Typ
• Typargument
• Wildcard-Typ
• Bounded Wildcard
• upper bound, lower bound
• generische Methode
• unchecked Warnung
• erasure
• Wildcard capture
• multiple bound

solle man sofort einordnen und beschreiben können.

Jeder Entwickler sollte insbesondere alle Anwendungen von Generics bei der Utility-Klasse Collections verstehen:

• static <T> boolean addAll(Collection<? super T> c, T... a)
• static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
• static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
• static <E> Collection<E> checkedCollection(Collection<E> c, Class<E> type)
• static <E> List<E> checkedList(List<E> list, Class<E> type)
• static <K,V> Map<K,V> checkedMap(Map<K,V> m, Class<K> keyType, Class<V> valueType)
• static <E> Set<E> checkedSet(Set<E> s, Class<E> type)
• static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V> m, Class<K> keyType, Class<V> valueType)
• static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s, Class<E> type)
• static <T> void copy(List<? super T> dest, List<? extends T> src)
• static boolean disjoint(Collection<?> c1, Collection<?> c2)
• static <T> List<T> emptyList()
• static <K,V> Map<K,V> emptyMap()
• static <T> Set<T> emptySet()
• static <T> Enumeration<T> enumeration(Collection<T> c)
• static <T> void fill(List<? super T> list, T obj)
• static int frequency(Collection<?> c, Object o)
• static int indexOfSubList(List<?> source, List<?> target)
• static int lastIndexOfSubList(List<?> source, List<?> target)
• static <T> ArrayList<T> list(Enumeration<T> e)
• static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
• static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
• static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
• static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)
• static <T> List<T> nCopies(int n, T o)
• static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
• static void reverse(List<?> list)
• static <T> Comparator<T> reverseOrder()
• static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
• static void rotate(List<?> list, int distance)
• static void shuffle(List<?> list)
• static void shuffle(List<?> list, Random rnd)
• static  <T> Set<T> singleton(T o)
• static <T> List<T> singletonList(T o)
• static <K,V> Map<K,V> singletonMap(K key, V value)
• static <T extends Comparable<? super T>>  void sort(List<T> list)
• static <T> void sort(List<T> list, Comparator<? super T> c)
• static void swap(List<?> list, int i, int j)
• static <T> Collection<T> synchronizedCollection(Collection<T> c)
• static <T> List<T> synchronizedList(List<T> list)
• static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
• static <T> Set<T> synchronizedSet(Set<T> s)
• static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)
• static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)
• static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c)
• static <T> List<T> unmodifiableList(List<? extends T> list)
• static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m)
• static <T> Set<T> unmodifiableSet(Set<? extends T> s)
• static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m)
• static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s)

PS: Beginne bei <T>/<E> bzw. <K,V>, dann <?> und dann den restlichen. max/min sind dann die Generics-„Bonbons“.

Wer danach die Nase von Generics immer noch nicht voll hat, beginnt http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html zu lesen. Das ist die umfangreichste Quelle zu dem Thema im Netz.

Ähnliche Beiträge

• Echte typsichere Container
• Arrays.parallelSort(…)
• Lexikografische Array-Verbleiche mit compare (…) und compareUnsigned(…)
• Erster Draft für “Annotations on Java Types” (JSR-308)
• Erste Implementierung für JSR 308