AWT und Swing sind bisher die Standardlösungen für grafische Anwendungen unter Java. AWT bildet das Fundament mit Ereignisbehandlung, Fenster-Management und einer mächtigen 2D-API. Swing sitzt auf dem AWT und ist eng mit ihm verbunden. Es realisiert die Komponenten, die zum Teil selbst in Java implementiert sind, manch ein Look and Feel – wie im Fall von Windows – lässt die Komponenten nativ vom Betriebssystem zeichnen.

Swing und AWT sind mächtig, aber es hat sich in den Letzen Jahren nicht großartig weiterentwickelt. Insbesondere gibt es Lücken im Bereich Medien und Animation, etwas, was bei modernen grafischen Oberflächen heutzutage gefragt ist. Statt das Sun/Oracle in die Weiterentwicklung investiert, hat sich das Unternehmen für eine komplette Neuentwicklung der GUI-Ebene entschieden, die nichts mehr mit Swing/AWT gemeinsam hat: JavaFX.

JavaFX ist eine Komplettlösung mit einer API für

· GUI-Komponenten

· HMTL/CSS/JavaScript mit eingebetteten Web-Brower

· Animationen

· Video

· Audio

· 2D und 3D

Da JavaFX komplett alle APIs für moderne Oberflächen anbietet, und auch nicht von AWT/Swing abhängig ist, bildet JavaFX einen kompletten Media-Stack. Die Betonung liegt auf Media, denn die AWT/Swing-API im Java SE kann keine Medien einbinden oder abspielen. Zwar ist JavaFX auch noch kein Teil der Java SE, doch das kann sich ändern. Über Profile sollte JavaFX auch auf mobilen Endgeräten und im Internet wie Applets laufen, allerdings ist eher davon auszugehen, das JavaFX es bei Rich-Client-Anwendungen Einzug hält und dort AWT/Swing verdrängt. Es ist nicht abzusehen, dass JavaFX im Internet als Flash-Ersatz oder auf mobilen Endgeräten punkten kann, dafür ist die Kombination HTML5 + CSS3 + JavaScript zu attraktiv.

Anders als AWT ist die JavaFX-Implementierung auf der Höhe der Zeit und greift direkt auf alle 2D/3D-Fähigkeiten moderner Grafikkarten zurück. So kann mit JavaFX alles das programmiert werden, was bisher eher mit Flash gemacht wurde, wohl aber fehlen noch die tollen Entwicklertools. Es gibt Plugins für Adobe Photoshop und Illustrator, mit denen Grafiken und Pfade exportiert werden können, aber eben keine ganzen Animationen, die etwa mit Adobe Flash erzeugt wurden. Und seit dem Adobe Flash auch HTML5 exportiert, öffnet sich eine ganz neue Welt.

Auch wenn sich die Welt nach freien und quelloffenen Lösungen sehnt, Microsoft Office ist immer noch eines der bestverkauftesten Produkte auf diesen Planeten mit dem MS-Dokumentenformat als Sonne im Mittepunkt. Da die Dokumentation von Microsofts Dateiformaten mittlerweile zugänglich[1] sind, gibt es auch Java-Bibliotheken, die MS-Office-Dokumente einlesen, modifizieren und schreiben. Bekannt dafür ist Apache POI[2] (http://poi.apache.org/), was APIs für folgende Formate (Komponenten genannt) bietet:

POI-Komponenten nach http://poi.apache.org/overview.html#components

OpenXML4J und POIFS sind keine üblichen Dokumentenformate, aber Archivformate für Microsoft-Dokumenten (analog zu Zip). HPSF erlaubt Zugriff auf Datei-Metadaten wie Autor, Titel, usw.

Neben POI gibt es nicht mehr so viele Alternativen, eher kleinere Bibliotheken, die sich auf ein Formate spezialisiert haben. So etwa http://jexcelapi.sourceforge.net/ für Excel, was eine sehr einfache und intuitive API hat, aber beim Lesen oft Probleme bereitet. Nur wurde es bisher seit 2 Jahren nicht mehr aktualisiert. Eine kommerzielle Lösung bietet Aspose (http://www.aspose.com/categories/java-components/aspose.total-for-java/default.aspx). Für den Zugriff auf MS Access Datenbanken gibt es die quelloffene Bibliothek http://jackcess.sourceforge.net/, die auch eine sehr aktuelle fluent API hat. Auf MS Access lässt sich aber auch per ODBC zurückgreifen, das Datenbankkapitel gibt eine kleine Übersicht.

Das neue Office-Format basiert auf XML und so auch deutlich einfacher zu verarbeiten als das binäre Format. Es ist im Office Open XML beschrieben. Für Word-Dokumente gibt es zum Beispiel das relativ neue Projekt java2word (http://code.google.com/p/java2word/).

Neben dem Office Open gibt es das OASIS Open Document Format – mit Dateiformaten wie OpenDocument (ODF) für Textdokumente – die etwa von OpenOffice verarbeitet werden. Eine Bibliothek zum Verarbeiten bietet das ODF Toolkit (http://odftoolkit.org/).

Fehlt noch was?

[1] http://www.microsoft.com/interop/docs/officebinaryformats.mspx

[2] POI steht für „Poor Obfuscation Implementation“, weil das Dateiformat so kryptisch ist. Die Kürzel der Komponenten beginnen in der Regel mit „H“ was für „Horrible“ steht .

Das folgende Code für mein Semaphoren-Beispiel (http://openbook.galileodesign.de/javainsel7/javainsel_10_006.htm) habe ich vereinfacht und ist so nicht wirklich korrekt:

  1: static Runnable r = new Runnable() { 

  2:     public void run() { 

  3:       while ( true ) { 

  4:         try 

  5:         { 

  6:           semaphore.acquire(); 

  7:  

  8:           System.out.println( "Thread=" + Thread.currentThread().getName() + 

  9:                        ", Available Permits=" + semaphore.availablePermits() ); 

 10:           Thread.sleep( 2000 ); 

 11:         } 

 12:         catch ( InterruptedException e ) { 

 13:           e.printStackTrace(); 

 14:         } 

 15:         finally { 

 16:           semaphore.release(); 

 17:         } 

 18:       } 

 19:     } 

 20:   };
Wer findet den Fehler noch?
Nun, in der 10. Auflage ist der Fehler jedenfalls korrigiert und ein Dank geht an Marco Völz.
			

Oftmals ist das Ordnungskriterium aus mehreren Bedingungen zusammengesetzt, wie die Sortierung in einem Telefonbuch zeigt. Erst gibt es eine Sortierung nach dem Nachnamen, dann folgt der Vorname. Um diese mit einem Compartor-Objekt zu lösen, müssen entweder alle Einzelvergleiche in ein neues Compartor-Objekt verpackt werden, oder einzelne Comparatoren zu einem „Super“-Comparator zusammengebunden werden – die zweite Lösung ist natürlich schöner, denn das erhöht die Wiederverwendbarkeit, denn einzelne Comparatoren können dann leicht für andere Zusammenhänge genutzt werden.

Comparatoren in eine Vergleichskette setzen

Am Anfang steht ein besonderer Comparator, der sich aus mehreren Comparatoren zusammensetzt. Immer dann, wenn ein Teil-Compartor bei zwei Objekten aussagt, dass sie gleich sind (der Vergleich liefert 0 ist), so soll der nächste Comparator die Endscheidung fällen – kann er das auch nicht, weil das Ergebnis wieder 0 ist, geht es zum nächsten Vergleicher.

Den Programmcode wollen wir einen neue Hilfsklasse ComparatorChain setzen:

package com.tutego.insel.util;

import java.util.*;

/**
 * A {@link Comparator} that puts one or more {@code Comparator}s in a sequence.
 * If a {@code Comparator} returns zero the next {@code Comparator} is taken.
 */
public class ComparatorChain<E> implements Comparator<E>
{
  private List<Comparator<E>> comparatorChain = new ArrayList<Comparator<E>>();
  
  /**
   * Construct a new comparator chain from the given {@code Comparator}s.
   * The argument is not allowed to be {@code null}.
   * @param comparators Sequence of {@code Comparator}s
   */
  @SafeVarargs  // ab Java 7
  public ComparatorChain( Comparator<E>... comparators )
  {
    if ( comparators == null )
      throw new IllegalArgumentException( "Argument is not allowed to be null" );

    Collections.addAll( comparatorChain, comparators );
  }

  /**
   * Adds a {@link Comparator} to the end of the chain.
   * The argument is not allowed to be {@code null}.
   * @param comparator {@code Comparator} to add
   */
  public void addComparator( Comparator<E> comparator )
  {
    if ( comparator == null )
      throw new IllegalArgumentException( "Argument is not allowed to be null" );

    comparatorChain.add( comparator );
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public int compare( E o1, E o2 )
  {
    if ( comparatorChain.isEmpty() )
      throw new UnsupportedOperationException(
                  "Unable to compare without a Comparator in the chain" );

    for ( Comparator<E> comparator : comparatorChain )
    {
      int order = comparator.compare( o1, o2 );
      if ( order != 0 )
        return order;
    }

    return 0;
  }
}

Die ComparatorChain können wir auf zwei Weisen mit den Comparator-Gliedern füttern: einmal zu Initialisierungszeit im Konstruktor, und dann später noch über die addComparator()-Methode. Beim Weg über den Konstruktor ist ab Java 7 die Annotation @SafeVarargs zu nutzen, da sonst die Kombination eines Varargs und Generics auf der Nutzerseite zu einer Warnung führt.

Ist kein Comparator intern in der Liste, wird das compare() eine Ausnahme auslösen. Der erste Comparator in der Liste ist auch das Vergleichsobjekt was zuerst gefragt wird. Liefert er ein Ergebnis ungleich 0 liefert das die Rückgabe der compare()-Methode. Ein Ergebnis gleich 0 führt zur Anfrage des nächstes Comparators in der Liste.

Wir wollen diese ComparatorChain für ein Beispiel nutzen, dass eine Liste nach Nach- und Vornamen sortiert.

package com.tutego.insel.util;

import java.util.*;

public class ComparatorChainDemo
{
  public static class Person
  {
    public String firstname, lastname;

    public Person( String firstname, String lastname )
    {
      this.firstname = firstname;
      this.lastname  = lastname;
    }

    @Override public String toString()
    {
      return firstname + " " + lastname;
    }
  }

  public final static Comparator<Person>
    PERSON_FIRSTNAME_COMPARATOR = new Comparator<Person>() {
      @Override public int compare( Person p1, Person p2 ) {
        return p1.firstname.compareTo( p2.firstname );
      }
    };

  public final static Comparator<Person>
    PERSON_LASTNAME_COMPARATOR = new Comparator<Person>() {
      @Override public int compare( Person p1, Person p2 ) {
        return p1.lastname.compareTo( p2.lastname );
      }
    };

  public static void main( String[] args )
  {
    List<Person> persons = Arrays.asList(
      new Person( "Onkel", "Ogar" ), new Person( "Olga", "Ogar" ),
      new Person( "Peter", "Lustig" ), new Person( "Lara", "Lustig" ) );

    Collections.sort( persons, PERSON_LASTNAME_COMPARATOR );
    System.out.println( persons );

    Collections.sort( persons, PERSON_FIRSTNAME_COMPARATOR );
    System.out.println( persons );

    Collections.sort( persons, new ComparatorChain<Person>(
        PERSON_LASTNAME_COMPARATOR, PERSON_FIRSTNAME_COMPARATOR ) );
    System.out.println( persons );
  }
}

Die Ausgabe ist:

[Peter Lustig, Lara Lustig, Onkel Ogar, Olga Ogar]

[Lara Lustig, Olga Ogar, Onkel Ogar, Peter Lustig]

[Lara Lustig, Peter Lustig, Olga Ogar, Onkel Ogar]