Daten ausgeben
Wir haben in unserem Programm schon öfter Daten ausgegeben. Warum beschäftige ich mich jetzt noch damit?
Ganz einfach, im Moment werden die Daten, unsere Kaffetassen, einfach nur auf dem Bildschirm ausgegeben. Es gibt bis jetzt
noch keine Formatierung. Was ist wenn ich verschiedene Texte zusammenfügen will? Darum geht es in diesem Kapitel.
Um die Ausgabe von Daten zu erklären verlasse ich für eine Weile unsere Kaffetassen. Bisher haben wir alles als Zeichenreihe, String, ausgegeben. Wir hatten gelernt, dass die Klasse String ein Literal ist, also aus mehreren Zeichen vom Typ char besteht. Was ist also ein char? Char ist dei kurzform für "Character", was im englischen für "Buchstaben" steht. Ein Char ist also ein einzelnes Zeichen. Die zur Verfügung stehenden Zeichen, für unsere Ausgabe, werden im Zeichensatz abgelegt. Im Zeichensatz wird jedes Zeichen einem Zahlenwert zugeordnet. @ entspricht zum Beispiel dem Wert 64. Die druckbaren Zeichen fangen normalerweise bei 32 an. Nicht druckbare Zeichen sind zum Beispiel Tabulator oder der Zeilenvorschub. Dieses kleine Programm zeigt euren Zeichensatz an:
class Zeichensatz() {
// Zeichensatz ausgeben
Zeichensatz() {
for(int i = 32; i <= 255; i++) {
char Zeichen;
String iStr = Integer.toString(i);
Zeichen = (char) i;
// Wenn die Ausgabe 3-stellig wird kann ein Leerzeichen weg.
if(i < 100) {
System.out.print(iStr + " " + Zeichen + " ");
}
else {
System.out.print(iStr + " " + Zeichen + " ");
}
// Nach 10 ausgegebenen Zeichen neue Zeile
if(i%10 == 0) {
System.out.println();
}
}
}
// Main Methode
public static void main (String [] args) {
new Zeichensatz();
}
}
Gehen wir das ganze einmal durch. Wir haben einen Schleife, die von 32 an bis 255 zählt. Das liegt daran, dass ein Zeichen aus
8 Bit, also einem Byte besteht. Jedes Bit, Kurzform für binary digit, kann die Werte 0 und 1 annehmen, folglich können mit
8 Bit die Zahlen von 0 bis 255 dargestellt werden.
Mit char Zeichen; erzeuge ich eine Variable für meine Zeichen vom Typ char. String iStr = Integer.toString(i);
wandelt meinen Zähler in einen String um. Dann gebe ich mit System.out.print(iStr + " " + Zeichen + " "); meine
Zeichen aus, zu beachten ist das ich hier System.out.print() benutze und nicht System.out.println();.
Der Unterschied ist, dass System.out.print() keinen Zeilenvorschub macht.
Zum Schluß, wird wie gehabt die Main-Methode aufgerufen.
Nun kann die Klasse String um einiges mehr, als einfach nur aneinander gereihte Zeichen anzuzeigen. Im Kapitel über IF-Abfragen mit Strings hatte ich schon einige Methoden gezeigt.
- Variable.length() gibt die Länge des Strings zurück
- Variable.substring(int Start, int Ende) gibt den String zwischen Start und Ende zurück. Die beiden Variablen geben die Position des ersten und des letzten Buchstaben des Teils, der ausgeschnitten werden soll, wieder.
- Variable.replace(char alt, char neu) ersetzt den Buchstaben im String.
- Variable.toLowerCase() wandelt alle Buchstaben in kleine Buschstaben um.
- Variable.toUpperCase) wandelt alle Buchstaben in große Buchstaben um.
- Variable.trim() entfernt Leerzeichen aus dem String.
- Variable.indexOf(String s) gibt die Position des Strings s in der Variable zurück. Wird nichts gefunden wird -1 zurück gegeben. Optional kann ein Startpunkt angegeben werden.
- Variable.startsWith(String s) prüft ob ein String mit dem String s beginnt.
- Variable.endsWith(String s) prüft ob ein String mit dem String s endet.
- Variable.toCharArray() erzeugt aus dem String ein Array von Chars.
Mit diesen Methoden kann man einen String beliebig auseinander nehmen und wieder zusammensetzen.
Nehmen wir zum Beispiel den String Donaudampfschifffahrtsgesellschaft.
class Textmanipulation() {
Textmanipulation() {
String Text = "Donaudampfschifffahrtsgesellschaft";
int fff, ll, anfang, ende, laenge;
String Dampfschiff, Donau, Gesellschaft;
String Ausgabe, Zwischen;
fff = Text.indexOf("fff");
ll = Text.indexOf("ll");
Dampfschiff = Text.substring(5,16);
Donau = Text.substring(0,5);
Gesellschaft = Text.substring(22,34);
anfang = fff;
ende = ll;
laenge = Text.length();
Ausgabe = "Eine " + Gesellschaft + " fahrt im " + Dampfschiff + " auf der " + Donau;
Zwischen = "Zwischen fff und ll steht " + Text.substring(anfang, ende);
System.out.println(Text + " hat " + Integer.toString(laenge) + " Zeichen" );
System.out.println(Ausgabe);
System.out.println(Zwischen);
System.out.println("fff steht an Position: " + Integer.toString(fff));
System.out.println("ll steht an Position: " + Integer.toString(ll));
System.out.println(Text + " in Großbuchstaben: " + Text.toUpperCase());
System.out.println(Text + " in Kleinbuchstaben: " + Text.toLowerCase());
System.out.println(Text.replace('a', 'o'));
}
public static void main (String [] args) {
new Textmanipulation();
}
}
Die Beispiele zeigen einige Möglichkeiten, wie Strings manipuliert werden können. Nach den üblichen Vorarbeiten, wird in die
Variable fff mit Text.indexOf("fff");, die Position von fff in unserem String Text angegeben.
Das selbe machen wir für ll. Hier ist wieder zu beachten, in JAVA wird von 0 gezählt, das heißt, die Position von fff
wird mit 14 angegeben, beginnt aber beim 15 Buchstaben !
Dann schneiden wir die Wörter Dampfschiff, Donau und Gesellschaft aus unserem String aus und schreiben sie in die dazu
passenden Variablen. Im nächsten Schritt werden fff und ll den Variablen anfang und ende zugewiesen, mit Text.length();
ermitteln wir, wie lang unser String ist.
In die Variablen Ausgabe und Zwischen werden dann die Ergebnisse der vorherigen Arbeit mit einem anderen Text
kombiniert. Das + verbindet die unterschiedlichen Strings, zu einem großen String, der in der jeweiligen Variable
abgelegt wird.
Zum Schluß geben wir unsere Ergebnisse aus. Bei dieser Gelegenheit wandeln wir den String Text einmal in Großbuchstaben und
einmal in Kleinbuchstaben und ersetzen alle a durch o.
Weiter geht es mit dem Speichern von Daten.
Mit JAVA programmieren
Als Entwicklungsumgebung benutze ich NetBeans 7.