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

 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.

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:

package s2.swing;
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 in GitHub.

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

package s2.swing;
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 s@scalingbits.com
 */
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);
    }
}

 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;
}

 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("***  ***");
    }

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.

package s2.sort;


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 s2.sort.Lexikographisch String1 String2 [[German|French|UK|US] [PRIMARY|SECONDARY|TERTIARY]]

Beispiele

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");

} 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); } } }