12.1 Java API

Das Java API ist eine plattformunabhängige Bibliothek die zum Javalaufzeitsystem gehört. Das Java API ist ein wichtiger Grund für die Popularität von Java. Man findet hier tausende von Klassen die bekannte Probleme korrekt und effizient lösen. Hieraus ergeben sich eine Reihe von Vorteilen

  • die Produktivität steigt
  • der selbstimplementierte Code wird geringer
    • die Qualität steigt
    • Testaufwände sinken
    • der Transport des Codes vereinfacht sich
  • die Klassen im Java API sind hocheffizient implementiert und untertützen oft zusätzliche Konzepte wie
    • Internationalisierung
    • Multithreading (Nebenläufigkeit)
  • Die Verwendung dieser Klassen garantiert auch, dass die Anwendungen auf den unterschiedlichsten Plattformen laufen.

Der beste Zugang zum Java API findet über die online Dokumentation von JDK Standard Edition 7  statt.

Vorsicht: Will man Anwendungen schreiben, die auch mit älteren JDKs funktionieren sollen so sollte man sich an die Schnittstellen der Klassen der älteren JDKs halten.

Das API wächst von Version zu Version und enthält eventuell Klassen und Methoden die in einer älteren Version von Java nicht enthalten sind.

Im Folgenden werden einige ausgewählte Klassen und Methoden des Java API vorgestellt. Die Liste ist nicht vollständig, sie enthält nützliche Klassen die im Rahmen dieses Kurses verwendet werden:

12.1.1 Konsolen Ein- und Ausgabe

Konsolenausgabe mit System.out

Die Klasse System gehört zum Paket java.lang und muss nicht mit einem Importbefehl deklariert werden. Man kann sie direkt benutzen. das Attribut System.out ist eine Instanz der Klasse PrintStream. Es erlaubt Ausgaben auf der Konsole in den folgenden Varianten:

  • System.out.println(a): a kann ein beliebiger Typ sein. Am Ende der Zeile wird ein Zeilenumbruch eingefügt. Die nächste Konsolenausgabe wird in einer neuen Zeile beginnen.
  • System.out.print(a): a kann ein beliebiger Typ sein. Am Ende der Zeile wird kein Zeilenumbruch angefügt. Man kann durch mehrere Aufrufe Ausgaben in der gleichen Zeile durchführen.
  • System.out.printf(formatString,a): a kann ein beliebiger Typ sein.Der String formatString erlaubt die Formatierung des Objekts a.
  • System.out.flush(): Stellt sicher das die gesamte Ausgabe auch gedruckt wird. Daten werden oft in einem "Stream" gepuffert da einzelnes abarbeiten der Daten ineffizient ist.

Konsoleneingaben mit System.in

Einlesen eines Texts mit Hilfe von System.in und eines InputStreamReader. Dies geschieht am besten mit einer eigenen Methode:

import java.io;
...
public static String StringLesen (){
     // liest einen vom Benutzer eingegebenen Text (String) ein
      BufferedReader keyboard = 
         new BufferedReader( new InputStreamReader(System.in));
      try {
         return keyboard.readLine();
      } catch (IOException e) {
         throw new RuntimeException( e );
      }
}

Konsoleneingaben mit java.util.Scanner

Die Klasse Scanner erlaubt das einfache lesen von primitiven Typen und Zeichenketten mit Hilfe regulärer Ausdrücke.

Man kann z.Bsp eine Ganzzahl(Integer) wie folgt einlesen:

Scanner sc = new Scanner(System.in);
int i = sc.nextInt();

Der Scanner kann auch mit anderen Begrenzungen als Leerzeichen umgehen. Hier ein Beispiel mit dem Text "Trenner" als Begrenzung:

String input = "47 Trenner 11 Trenner Montag Trenner Dienstag Trenner";
     Scanner s = new Scanner(input).useDelimiter("\\s*Trenner\\s*");
     System.out.println(s.nextInt());
     System.out.println(s.nextInt());
     System.out.println(s.next());
     System.out.println(s.next());
     s.close();

Wird das folgende Ergebnis liefern:

47
11
Montag
Dienstag

Parsen von Übergabeparametern mit einer eigenen Methode

Im folgenden Beispiel wird gezeigt wie man eine beliebige Anzahl von Eingabeparameter in einer eigenen Methode einliest und in Ganzzahlen umwandelt.

public class MethodenDemo {

    public static void main(String[] args) {

        int[] zahlenFeld;
        zahlenFeld = ganzZahlenEingabe(args);
        System.out.println(args.length + " arguments found");
        for (int i = 0; i < zahlenFeld.length; i++) {
            System.out.println("zahlenFeld[" + i + "] = " + zahlenFeld[i]);
        }
    }

    public static int[] ganzZahlenEingabe(String[] myArgs) {
        int[] z = new int[myArgs.length];
        if (myArgs.length > 0) {
            try {
                for (int i = 0; i < myArgs.length; i++) {
                    z[i] = Integer.parseInt(myArgs[i]);
                }
            } catch (NumberFormatException e) {
                System.err.println("Input Error: " + e.getMessage());
                System.exit(1);
            }
        }
        return z;
    }

}

Das Programm erzeugt die folgenden Ausgaben:

$ java MethodenDemo 33 22 11
3 arguments found
zahlenFeld[0] = 33
zahlenFeld[1] = 22
zahlenFeld[2] = 11

12.1.2 Swing

 Die folgenden Seiten zeigen einen stark vereinfachten Überblick über die wichtigsten Swing Klassen und Methoden. Es werden hier nur die Klassen und Methoden dokumentiert, die im Rahmen des Kurses benötigt werden.

JFrame

 Die Klasse JFrame erlaubt das Erzeugen von eigenen Fenstern für eine Javaanwendung.

Die API Dokumentation zur Klasse JFrame enthält die vollständige Dokumentation aller Methoden dieser Klasse.

Im Folgenden werden die wichtigsten Methoden (für den Kontext des Kurses) in ihrer natürlichen Benutzungsreihenfolge vorgestellt.

JFrame Übersicht
Methode Beschreibung Geerbt von
Konstruktor: JFrame() Erzeugen eines (noch) unsichtbaren Fensters ohne einen Titel -
Konstruktor: JFrame(String title) Erzeugen eines (noch) unsichtbaren Fensters mit einem Titel -
void setSize(int breite, int hoehe) Setzen der Fenstergröße durch Breite und Höhe in Pixel java.awt.Window
setLayout(LayoutManager manager) Durch das Setzen eines Layout Managers wird die Anordnung der Komponenten vorbestimmt  -
Component add(Component comp) Hinzufügen einer Komponente zum Container  java.awt.Container 
setJMenuBar(JMenuVar  menubar) Hinzufügen einer Menüleiste zum Fenster -
setDefaultCloseOperation(int Operation) Aktion die beim Schließen des Fensters geschieht. Mögliche Konstanten als Parameter: DO_NOTHING_ON_CLOSE, HIDE_ON_CLOSE, DISPOSE_ON_CLOSE, EXIT_ON_CLOSE -
pack() Berechnen des Layouts des Fensters java.awt.Window 
setVisible(boolean visible) Erlaubt ein Fenster anzuzeigen oder auszublenden java.awt.WIndow

 

Beispiel

... eines sehr einfachen Fensters welches mit der Klasse JFrame erzeugt wurde:

import javax.swing.JFrame;
import javax.swing.JLabel; ... JFrame hf = new JFrame();
// 1. Gewünschte Größe setzen
// 1. Parameter: horizontale Größe in Pixel
// 2. Parameter: vertikale Größe
hf.setSize(220,230); // Setzen des Titels
hf.setTitle("Java Anwendung");
// Setzen des Feldes mitdem Text "Mustertext"
hf.add(new JLabel("Mustertext")); // Beim Schliessen wird das Programm beendet
hf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

// Sas JFrame sichtbar machen
hf.setVisible(true);

Ergibt das folgende Fenster:

Anmerkung: Das hier gezeigte Fenster benutzt das Standard "Look and Feel" von MacOS. Die Rahmendekoration sieht bei anderen Betriebssystemen bzw. anderen "Loak and Feel" Themen anders aus. Der oben gezeigt Code ist jedoch plattformneutral.

JMenuBar, JMenu, JMenuItem

 Die Klassen JMenuBar, JMenu, JMenuItem , erlauben Konfiguration von Menüleisten, Pulldownmenüs und Menülisteneinträge für Fenster die mit JFrame erzeugt wurden.

Im Folgenden werden die wichtigsten Methoden (für den Kontext dieses Kurses) aufgeführt. Die obengenannten Klassen sind sehr viel mächtiger als hier beschrieben. Sie haben zusätzliche Methoden für:

  • Lokalisierung
  • unterschiedliche Arten von Menüeinträgen
  • konfigurierbares Look and Feel
  • Untermenüs
  • markieren von Einträgen
  • Anklicken durch Buchstaben Abkürzungen der Tastatur
  • etc.

Die Klasse JMenuBar

JMenuBar
Methode Beschreibung Geerbt von
Konstruktor: JMenuBar() Erzeugen einer Menüleiste für ein JFrame Fenster -
JMenu add(JMenu c) Hinzufügen eines Menüs zur Leiste -

Die Klasse JMenu

JMenu
Methode Beschreibung Geerbt von
Konstruktor: JMenu() Erzeugen einer Menüspalte am Ende der Menüleiste -
Konstruktor: JMenu(String title) Erzeugen einer Menüspalte mit Titel am Ende der Menüleiste -
JMenuItem add(JMenuItem c) Hinzufügen eines Menüeintrags am Ende des Menüs -

 

Die Klasse JMenuItem

JMenu
Methode Beschreibung Geerbt von
Konstruktor: JMenuItem(String text) Erzeugen eines Menüeintrags mit einem gegebenen Text -
void addActionListener(ActionListener l) Registrieren eines Listeners der aufgerufen wird wenn der Menülisteneintrag geklickt wird java.swingx.AbstractButton
void  setEnabled(boolean) Anzeigen oder ausblenden eines Menülisteneintrags -

Beispiel

... Menüs mit einem einzigen Eintrag :

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;    
import javax.swing.JMenu;  
import javax.swing.JMenuBar;  
import javax.swing.JMenuItem;
... 
JFrame hf = new JFrame();
JMenuBar menueleiste;
JMenu ablageMenue;
JMenuItem beendenMenueEintrag;
menueleiste = new JMenuBar();
ablageMenue = new JMenu("Ablage");
beendenMenueEintrag = new JMenuItem("Beenden");
beendenMenueEintrag.addActionListener(this);
beendenMenueEintrag.setEnabled(true);

ablageMenue.add(beendenMenueEintrag);
menueleiste.add(ablageMenue);

hf.setJMenuBar(menueleiste);
hf.setVisible(true);

Einen einfachen Actionlistener kann man als Klasse mit der folgenden Methode implementieren:


    public void actionPerformed(ActionEvent e) {
JMenuItem source = (JMenuItem) (e.getSource());
                if (source == beendenMenueEintrag)
                    System.exit(0);
}

beendenMenueEintrag muss hier auf das gleiche Objekt wie bei der obigen Erzeugung der Menüleiste zeigen. Der Actionlistener beendet die Anwendung bei Aufruf!

Hierdurch ergibt sich das folgende Fenster:

Anmerkung: Das hier gezeigt Fenster benutzt das Standard "Look and Feel" von MacOS. Die Rahmendekoration sieht bei anderen Betriebssystemen bzw. anderen "Look and Feel" Themen anders aus. Der oben gezeigt Code ist jedoch plattformneutral.

12.1.3 GUI IO (Swing)

Java bietet mit AWT (Another Window Tool Kit) und Swing reichhaltige Bibliotheken zum Entwurf von graphischen Benutzeroberflächen.

Hinweis: "Swing" (Schaukel) ist der Projektname. Swing ist Teil der Java Foundation Classes (JFC).

Einfache grafische "Swing" Oberfläche

Das folgende Beispiel dient als einfaches Rahmenprogramm für Text Ein- und Ausgaben.

Es übernimmt die Erzeugung eines Fensters mit:

  • Eingabefeld für einen Text
  • Ausgabefeld für einen Text
  • 3 Buttons zum Verarbeiten des Texts in drei Methoden

Der eigene Algorithmus wird in der Methode public String executeOperation1(String) oder der beiden anderen executeOpteration Methoden implementiert.

Hierzu werden die folgenden Swing-Klassen verwendet

  • JFrame: Erzeugen eines Fensters
  • JLabel: Erzeugen eines festen Texts
  • JTextField: Textfelder zur Ein- und Ausgabe von Texten
  • JButton: Knopf(Button) zum Triggern einer Aktion
  • ActionListener:Ausführen einer Aktion. Hier als anonyme Klasse implementiert.

Das erscheinende Fenster sieht wie folgt aus:

Das Fenster nach einer Texteingabe ("Eingabe"):

Das Fenster nach dem Drücken des Knopf "Do twice". Es wurde die Methode executeOperation2() aufgerufen:

Die Methoden executeOperation1(), executeOperation2(), executeOperation3() erlauben eine Implementierung des eigenen Algorithmus. Der erforderliche String in der Rückgabe wird dann im Fenster angezeigt.

Anbei das Beispielprogramm mit der Klasse DemoFrame:

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JPanel;

public class DemoFrame  extends javax.swing.JFrame {
    private javax.swing.ButtonGroup buttonGroup1;
    private javax.swing.JPanel jPanel1;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JTextField jTextField1;
    private javax.swing.JTextField jTextField2;
    private javax.swing.JButton jButton1;
    private javax.swing.JButton jButton2;
    private javax.swing.JButton jButton3;

                      
    private void initComponents() {
        jLabel1 = new javax.swing.JLabel();
        jTextField1 = new javax.swing.JTextField();
        jTextField2 = new javax.swing.JTextField();

        jButton1 = new javax.swing.JButton();
        jButton2 = new javax.swing.JButton();
        jButton3 = new javax.swing.JButton();
        
        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("My first JFrame");
        jLabel1.setText("Input Text:");
        jTextField1.setText("Input");
        jTextField2.setText("Output");
        jTextField2.setEditable(false);

        jButton1.setText("Do once:");
        jButton2.setText("Do twice:");
        jButton3.setText("Do three times:");

        JPanel radioPanel = new JPanel(new GridLayout(1, 0));
        radioPanel.add(jButton1);
        radioPanel.add(jButton2);
        radioPanel.add(jButton3);

        jButton1.addActionListener(new ActionListener()
                {
                public void actionPerformed(ActionEvent e) {
                    if(e.getSource() == jButton1)
                        jTextField2.setText(
                                executeOperation1(jTextField1.getText()));
                    }
                }
          );
          jButton2.addActionListener(new ActionListener()
                {
                public void actionPerformed(ActionEvent e) {
                    if(e.getSource() == jButton2)
                        jTextField2.setText(
                                executeOperation2(jTextField1.getText()));
                    }
                }
          );
          jButton3.addActionListener(new ActionListener()
                {
                public void actionPerformed(ActionEvent e) {
                    if(e.getSource() == jButton3)
                        jTextField2.setText(
                                executeOperation3(jTextField1.getText()));
                    }
                }
          );

        this.setBounds(300, 300, 200, 30);
        setMinimumSize(new Dimension(200,30));
        getContentPane().add(jLabel1, BorderLayout.WEST);
        getContentPane().add(jTextField1, BorderLayout.CENTER);
        getContentPane().add(radioPanel, BorderLayout.NORTH);
        getContentPane().add(jTextField2, BorderLayout.SOUTH);
        pack();
   }
    public DemoFrame() {
        initComponents();
    }

    public static void main(String[] args) {
 
        DemoFrame f1 = new DemoFrame();
        f1.setVisible(true);

    }

    public String executeOperation1(String s) {
        // Add Application logic here:
        String result = "Button 1:" + s;
        return (result) ;
    }
    public String executeOperation2(String s) {
        // Add Application logic here:
        String result = "Button 2:" + s + s;
        return (result) ;
    }
    public String executeOperation3(String s) {
        // Add Application logic here:
        String result = "Button 3:" + s + s +s;
        return (result) ;
    }

}

Als Download

Eine Swingoberfläche zum Erfassen von drei Texten

Die Klasse DemoFrame1 stellt drei Eingabefelder zum Erfassen von Texten zur Verfügung und erlaubt das Starten von 3 Operationen:

Implementierung der Klasse DemoFrame 1

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

/**
 *
 * @author sschneid
 */
public class DemoFrame1 extends javax.swing.JFrame {

    private ButtonGroup buttonGroup1;
    private JPanel jPanel1;
    private JLabel jLabel1;
    private JTextField jTextFieldin[];
    private JTextField jTextField2;
    private JButton jButton1;
    private JButton jButton2;
    private JButton jButton3;
    /**
     * Anzahl der Eingabefelder
     */
    private int inFields = 3;

    /**
     * Initialisieren aller Komponenten
     */
    private void initComponents() {
        jLabel1 = new JLabel();
        jTextFieldin = new JTextField[inFields];
        for (int i = 0; i < inFields; i++) {
            jTextFieldin[i] = new JTextField();
        }
        jTextField2 = new JTextField();

        jButton1 = new JButton();
        jButton2 = new JButton();
        jButton3 = new JButton();

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("My second JFrame");

        jLabel1.setText("Input Text:");

        // Belegen alle Eingabefelder mit Standwerten
        for (int i = 0; i < inFields; i++) {
            jTextFieldin[i].setText("Input" + i);
        }
        // Belegen des Augabefeldes mit Standartwert
        jTextField2.setText("Output");
        jTextField2.setEditable(false);

        // Erzeugen dreier Buttons
        jButton1.setText("Do once:");
        jButton2.setText("Do twice:");
        jButton3.setText("Do three times:");

        // Ezeugen einer Datenstruktur(Panel) die drei Buttons aufnimmt
        JPanel radioPanel = new JPanel(new GridLayout(1, 0));
        radioPanel.add(jButton1);
        radioPanel.add(jButton2);
        radioPanel.add(jButton3);

        // Führe Operation 1 aus wenn Button 1 gedrückt wird
        jButton1.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                if (e.getSource() == jButton1) {
                    jTextField2.setText(executeOperation1(
                            jTextFieldin[0].getText(),
                            jTextFieldin[1].getText(),
                            jTextFieldin[2].getText()));
                }
            }
        });

        // Führe Operation 2 aus wenn Button 2 gedrückt wird
        jButton2.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                if (e.getSource() == jButton2) {
                    jTextField2.setText(executeOperation2(
                            jTextFieldin[0].getText(),
                            jTextFieldin[1].getText(),
                            jTextFieldin[2].getText()));
                }
            }
        });

        // Führe Operation 3 aus wenn Button 3 gedrückt wird
        jButton3.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                if (e.getSource() == jButton3) {
                    jTextField2.setText(executeOperation3(
                            jTextFieldin[0].getText(),
                            jTextFieldin[1].getText(),
                            jTextFieldin[2].getText()));
                }
            }
        });

        // Allgemeine Konfiguration des Fensters
        this.setBounds(300, 300, 200, 30);
        setMinimumSize(new Dimension(200, 30));
        // Einfügen der Eingabeaufforderung links
        getContentPane().add(jLabel1, BorderLayout.WEST);
        // Panel zum verwalten von mehreren Eingabefelder
        JPanel inputPanel = new JPanel(new GridLayout(inFields, 0));
        for (int i = 0; i < inFields; i++) {
            inputPanel.add(jTextFieldin[i]);
        }
        // Einfügen des Panels mit Eingabefeldern in der Mitte
        getContentPane().add(inputPanel, BorderLayout.CENTER);
        // Einfügen des Panels mit Buttons oben
        getContentPane().add(radioPanel, BorderLayout.NORTH);
        // Einfügen der Ausgabezeile unten
        getContentPane().add(jTextField2, BorderLayout.SOUTH);
        pack();
    }

    /**
     * Initialierung alle Komponenten
     */
    public DemoFrame1() {
        initComponents();
    }

    /**
     * Hauptprogramm: Erzeuge eine Instanz von DemoFrame1 und zeige sie an
     * @param args
     */
    public static void main(String[] args) {

        DemoFrame1 f1 = new DemoFrame1();
        f1.setVisible(true);
    }

    /**
     * Führe Operation 1 aus (Button 1 wurde gedrückt)
     * @param s1
     * @param s2
     * @param s3
     * @return
     */
    public String executeOperation1(String s1, String s2, String s3) {
        // Add Application logic here:
        String result = "Button 1:" + s1 + s2 + s3;
        return (result);
    }

    /**
     * Führe Operation 2 aus (Button 2 wurde gedrückt)
     * @param s1
     * @param s2
     * @param s3
     * @return
     */
    public String executeOperation2(String s1, String s2, String s3) {
        // Add Application logic here:
        String result = "Button 2:" + s1 + s2 + s3;
        return (result);
    }

    /**
     * Führe Operation 3 aus (Button 3 wurde gedrückt)
     * @param s1
     * @param s2
     * @param s3
     * @return
     */
    public String executeOperation3(String s1, String s2, String s3) {
        // Add Application logic here:
        String result = "Button 3:" + s1 + s2 + s3;
        return (result);
    }
}

12.1.4 Math

 Die Math Klasse enthält alle mathematischen Hilfsroutinen wie z.Bsp.

public static double random(): Zufallszahlengenerator

...erzeugt zufällige Fliesskommazahlen im Intervall von 0.0 bis 1.0

Die folgende Methode erzeugt ein beliebig großes Feld von zufälligen Ganzzahlen in einem bestimmten Bereich (range)

public static int[] createRandom(int size, int range) {
   int[] array1 = new int[size];
   for (int i=0; i<size;i++) 
       array1[i] = (int)(Math.random()*range);
   return array1;
}

12.1.5 Systemresourcencheck mit der Klasse Runtime

 Die Java Runtime bietet die Möglichkeit die folgenden Systemwerte auszulesen:

  • verfügbare Prozessoren
  • freier Speicher
  • maximal verfügbarer Speicher
  • gesamter allokierter Speicher der VM

Die Klasse bietet ebenfalls die Möglichkeit eine Reihe von Operationen zu starten:

  • expliziter Aufruf eines "Garbage Collectors"
  • expliziter Aufruf des Finalizers
  • externer Aufruf eines Betriebssystemkommandos
  • beenden des Prozesses
  • laden von dynamischen Bibliotheken

Warnung: Alle aufgeführten Operationen haben erheblichen Einfluss auf die gesamte VM. Im normalen Entwicklungsumfeld größerer Anwendungen führen die oben genannten Operationen in der Regel zu erheblichen negativen Seiteneffekten für Sicherheit, Stabilität und Performanz von Anwendungen.

Die folgende Methode nutzt die Klasse Runtime um die wichtigsten Werte des Prozesses auszulesen:

public static void systemStatus(){
        Runtime r = Runtime.getRuntime();
        System.out.println("*** System Status ***");
        System.out.println("Prozessoren :       " + r.availableProcessors());
        System.out.println("Freier Speicher:    " + r.freeMemory());
        System.out.println("Maximaler Speicher: " + r.maxMemory());
        System.out.println("Gesamter Speicher:  " + r.totalMemory());
        System.out.println("***  ***");
    }

12.1.6 Collator (Vergleichen von Zeichenketten)

Der Vergleich von Zeichenketten hängt oft von der lexikographischen Ordnung ab. Die lexikographische Ordnung selbst hängt wieder von der Region ab. Java bietet hierfür die Klasse Collator (Collation engl. : Der Textvergleich) an, die Zeichenketten nach bestimmten Kriterien sortieren kann. Die Methode compare() erlaubt das Vergleichen zweier Zeichenketten.

Zur Bestimmung der Sortierreihenfolge wird die Klasse java.util.Locale benötigt, die die entsprechende Region und deren Sprache bestimmt.

Das Vorgehen zum Konfigurieren und Vergleichen von Zeichenketten ist das folgende:

  • Auswahl der gewünschten Region und Sprache (Locale). Z.Bsp. Locale.GERMANY
  • Bestimmung der gewünschten Sortierstärke für den Collator ( setStrength() )
    • Collator.PRIMARY : nur die grundlegende Abfolge  wie z.Bsp 'a' und 'b' werden berücksichtigt
    • Collator.SECONDARY: Unterschiede wie z.Bsp. 'a' und 'ä' werden berücksichtigt falls nach den Regeln der Kategorie "Primary" kein Unterschied existiert.
    • Collator.TERTIARY: Unterschiede wie z. Bsp. 'a' und 'A' werden berücksichtigt falls nach den Regeln der Kategorie "Secondary" kein Unterschied existiert
  • Vergleichen der Zeichenketten mit compare() oder equals()

Beispiel

Vergleichen von Vor- und Nachnamen einer Person nach deutschen Sortierregeln inklusive besonderer deutscher Zeichen mit der Methode compare() der Klasse Collator.

import java.text.Collator;
import java.util.Locale;
 
public class Person{
   private String nachname;
   private String vorname;
private static Locale myLocale = Locale.GERMANY;
 
public boolean istKleinerAls(Person p) {
boolean kleiner = false;
   Collator myCollator = Collator.getInstance(myLocale);
// Beim Vergleich auch Gross- und Kleinschreibung unterscheiden
   myCollator.setStrength(Collator.TERTIARY);
   // Konfiguriere die Sortierordnung
   if (myCollator.compare(nachname, p.nachname) < 0) {
      kleiner = true;
   } else if (myCollator.compare(nachname, p.nachname) == 0) {
      kleiner = myCollator.compare(vorname, p.vorname) < 0;
}
   return kleiner;
}
}

Lauffähiges Programm zum Testen von Locales und Sortierordnungen

Das Programm Lexikographisch akzeptiert die folgende Kommandozeilensyntax:

java Kurs2.Sort.Lexikographisch String1 String2 [[German|French|UK|US] [PRIMARY|SECONDARY|TERTIARY]]

Beispiele

$ java Kurs2.Sort.Lexikographisch SPULE Spüle German PRIMARY
SPULE ist gleich Spüle
$ java Kurs2.Sort.Lexikographisch SPULE Spüle German SECONDARY
SPULE vor Spüle
$ java Kurs2.Sort.Lexikographisch Schmidt SCHMIDT German PRIMARY
Schmidt ist gleich SCHMIDT
$ java Kurs2.Sort.Lexikographisch Schmidt SCHMIDT German SECONDARY
Schmidt ist gleich SCHMIDT
$ java Kurs2.Sort.Lexikographisch Schmidt SCHMIDT German TERTIARY
Schmidt vor SCHMIDT

Quellcode

package Kurs2.Sort;
import java.text.Collator;
import java.util.Locale;
/**
 *
 * @author sschneid
 */
public class Lexikographisch {
    public static void main(String[] args) {
        String s1 = "Test1";
        String s2 = "Test2";
        Locale myLocale = Locale.GERMANY;
        int strength = Collator.TERTIARY;
        if (args.length < 2) {
            System.out.println("Erforderliche Mindestparameter: String1 String2");
            System.out.println("Syntax: java Kurs2.Sort.Lexikographisch "
                    + "String1 String2 "
                    + "[[German|French|UK|US] [PRIMARY|SECONDARY|TERTIARY]]");
} else { s1 = args[0]; s2 = args[1]; } if (args.length >= 3) { String loc = args[2]; if (loc.equalsIgnoreCase("German") || loc.equalsIgnoreCase("Germany")) { myLocale = Locale.GERMAN; } if (loc.equalsIgnoreCase("France") || loc.equalsIgnoreCase("French")) { myLocale = Locale.FRENCH; } if (loc.equalsIgnoreCase("US")) { myLocale = Locale.US; } if (loc.equalsIgnoreCase("UK") || loc.equalsIgnoreCase("English")) { myLocale = Locale.UK; } // Add more locales here... } if (args.length >= 4) { String s = args[3]; if (s.equalsIgnoreCase("PRIMARY")) { strength = Collator.PRIMARY; } if (s.equalsIgnoreCase("SECONDARY")) { strength = Collator.SECONDARY; } if (s.equalsIgnoreCase("TERTIARY")) { strength = Collator.TERTIARY; } } vergleich(s1, s2, myLocale, strength); } private static void vergleich(String s1, String s2, Locale myLocale, int strength) { Collator myCollator = Collator.getInstance(myLocale); // Beim Vergleich auch Gross- und Kleinschreibung unterscheiden // Konfiguriere die Sortierordnung myCollator.setStrength(strength); if (myCollator.compare(s1, s2) == 0) { System.out.println(s1 + " ist gleich " + s2); } if (myCollator.compare(s1, s2) < 0) { System.out.println(s1 + " vor " + s2); } if (myCollator.compare(s1, s2) > 0) { System.out.println(s2 + " vor " + s1); } } }