Einführung in die Programmierung Datensammlung Fakultät für Wirtschaftswissenschaften Einführung in die Programmierung Datensammlung Uwe Lämmel www.wi.hs-wismar.de/~laemmel Uwe.Laemmel@hs-wismar.de

Inhalt Verwalten mehrerer Objekte: Sammlungen (Collections) ArrayList Arbeiten mit Sammlungen: Wiederholung (Iteration) Iteratoren Schleifen ( for–each, while–do, for)

Sammlungen Typische Aufgabe der Wirtschaftsinformatik: Verwalten mehrerer (beliebig vieler) Objekte : Personal Termine Aufträge Rechnungen Aktionen: Elemente hinzufügen Elemente entfernen Element suchen

 Machen Sie sich mit dem Notizbuch-Projekten vertraut!! Beispiel: Notizbuch Anforderungen / Erwartungen: Notizen speichern keine Begrenzung für die Anzahl Anzahl gespeicherter Notizen angeben Einzelne Notizen anzeigen Alle Notizen anzeigen  Machen Sie sich mit dem Notizbuch-Projekten vertraut!!

Klassen-Bibliotheken nicht alles muss neu programmiert werden: es gibt nützliche, bereits "fertige" Klassen: Java – API: Application Programming Interface Bibliothek in Java: package java.util package bietet Klassen für Objekt-Sammlungen Wir nutzen Klasse ArrayList  Machen Sie die Java – API für sich verfügbar! Schauen Sie sich die Klasse ArrayList an!

Klasse Notizbuch import java.util.ArrayList; /** * ... */ public class Notizbuch { // Speicher für beliebige Anzahl von Notizen private ArrayList <String> notizen;   * Initialisierung für ein Notizbuch public Notizbuch( ) { notizen = new ArrayList<String>(); } // Konstruktor ... } // Notizbuch erst ab Java 1.5

Klasse ArrayList es wird definiert: Typ der Sammlung: ArrayList Typ der Elemente: <String> Name der Sammlung: notizen private ArrayList <String> notizen; ArrayList<String> – "Array-Liste von Zeichenketten"

 Was passiert beim Einfügen einer weiteren Notiz? Objekt-Struktur  Was passiert beim Einfügen einer weiteren Notiz?

Benutzen der Sammlung class Notizbuch { private ArrayList <String> notizen; ... public void speichereNotiz(String notiz) { notizen.add(notiz); } // speichereNotiz   public int anzahlNotizen() { return notizen.size(); } // anzahlNotizen } // Notizbuch Hinzufügen einer Notiz Gibt Anzahl der Elemente in der ArrayList zurück add, size : Methoden der Klasse ArrayList, siehe API

Gültigkeit des Index prüfen! Ermitteln einer Notiz public void zeigeNotiz(int notiznummer){ if ( notiznummer >= 0 && notiznummer < anzahlNotizen() ) { System.out.println(notizen.get(notiznummer)); } // if } // zeigeNotiz Gültigkeit des Index prüfen! vordefinierte Methode! Parameter: Aufruf einer Methode!

Zusammenfassung Elemente können hinzugefügt /entfernt werden Jedes Element hat eine Nummer / Index: 0, 1 … Wichtige Methoden der Klasse ArrayList sind: add, get, remove, size ArrayList ist ein parametrisierter/generischer Datentyp ArrayList-Objekte speichern beliebig viele Objekte Java - API enthält packages mit vordefinierten Klassen: java.util.ArrayList, java.lang.String, java.lang.System

Wiederholung = Iteration oft sind Aktionen mehrfach auszuführen: z.B. Ausgabe aller Notizen des Notizbuchs die meisten Programmiersprachen bieten: Schleifen–Anweisungen (loop statements) mehrere Schleifen-Formen in Java. beginnen mit for–each–Schleife.

Anweisungen, die wiederholt werden for–each–Schleife Schlüsselwort for Schleifen-Kopf for ( ElementTyp element : Sammlung) { Schleifen-Körper } // for-each Anweisungen, die wiederholt werden Bedeutung: Für jedes element aus der Sammlung, führe die Anweisungen im Schleifen-Körper aus.

for each note in notes, print out note for–each–Beispiel /** * Gib alle Notizen eines Notizbuchs aus */ public void notizenAusgeben() { for(String notiz : notizen) { // Schleifen-Kopf System.out.println(notiz); // Schleifen-Körper } // for } //notizenAusgeben for each note in notes, print out note

while–Schleife while(bedingung) { Schleifen-Körper }//while Schlüsselwort while Schleifenkopf: Bedingung while(bedingung) { Schleifen-Körper }//while Anweisungen, die wiederholt werden Bedeutung: Solange die bedingung wahr (true) ist, führe die Anweisungen im Schleifen-Körper aus.

while-Schleife: Beispiel /** * Gib alle Notizen eines Notizbuchs aus */ public void notizenAusgeben() { int index = 0; while(index < notizen.size()) { System.out.println(notizen.get(index)); index++; } //while }//notizenAusgeben um 1 erhöhen Bedeutung: while the value of index is less than the size of the collection, print the next note, and then increment index

while (Bedingung) { Anweisungen } while–Schleife while (Bedingung) { Anweisungen } while-Schleife ist anfangsgesteuert: Bedingung wird zuerst geprüft  mind. einmal! wird benutzt, falls: die Zahl der Durchläufe unbestimmt und Test der Bedingung vor dem Bearbeiten des Körpers erforderlich: z.B. in Sammlungen: Gibt es überhaupt ein Element? Anweisungen im Schleifen–Körper müssen Bedingung beeinflussen, z.B. i++;

for–each versus while for–each: einfacher aufzuschreiben sicher: stoppt garantiert! stets für alle Elemente der Sammlung while: nicht notwendig, die gesamte Sammlung zu bearbeiten kann auch ohne Sammlung benutzt werden Gefahr unendlicher Wiederholungen!

while – ohne eine Objektsammlung Gib alle geraden Zahlen zwischen 0 und 30 aus. Berechne alle Teiler einer Zahl. Bestimme die Quersumme einer Zahl. Bestimme den größten gemeinsamen Teiler zweier Zahlen. …

Suche in einer Sammlung von Objekten int index = 0; // Nr. des aktuellen Elements boolean gefunden = false; // schon gefunden? // index < Größe der Sammlung UND noch nicht gefunden while(index < notizen.size() && !gefunden) { String notiz = notizen.get(index); // aktuelles Element if(notiz.contains(suchString)) { // siehe API: lang.String gefunden = true; // gefunden: Zeichenkette ist enthalten } //if else { index++; // nächster Index=>nächstes Element } //else } //while // Entweder gefunden oder gesamte Sammlung durchsucht if(!gefunden) index = –1; // index für nicht gefunden /** * Kopf der Methode (Signatur) sucheText * @param suchString Zeichenkette nach der gesucht wird * @return Index der Notiz, die text enthält, oder –1 */ public int sucheNotiz( String suchString ) { … return index; } // sucheNotiz

Schleife mittels Iterator-Objekt Iterator<Elementtyp> it = meineSammlung.iterator(); while(it.hasNext()) { ElementTyp el = it.next(); // nächstes Element Anweisungen "machen etwas" mit Element el } //while Beispiel: public void notizenAusgaben() { Iterator<String> it = notizen.iterator(); while ( it.hasNext() ) { String el = it.next(); System.out.println(el); } //while } //notizenAusgeben

Schleifen und Objektsammlungen for–each: wenn alle Elemente bearbeitet werden while–Schleife: falls nur einige Elemente bearbeitet werden wird durch Bedingung gesteuert für Wiederholungen ohne Sammlungen Iterator–Objekt: falls nur einige Elemente zu bearbeiten insbesondere für Sammlungen ohne Index alle Sammlungen (collections) der API stellen Iterator bereit Iteration / Schleife ist wichtiges Programmier-Muster (pattern)

Array: Sammlungen fester Größe häufig Obergröße für Objekt-Sammlungen bekannt Programmiersprachen bieten: spezielle Konstruktion: array spezielle Schreibweise (Syntax): typ[ ] bzw. element[index] Arrays in Java speichern Objekte oder Werte einfacher Datentypen .

feste Anzahl von Elementen eines Typs Array feste Anzahl von Elementen eines Typs Arrays sind Objekte: mit new-Methode erzeugen Elemente eines Array beliebig aber fest: Attribut length gibt Anzahl der Elemente an: System.out.writeln(feld.length); // ausgegeben wird 6 Zugriff: int[ ] feld = new int[6]; 1 2 3 4 5 feld[0] = 17; feld[1] = 35; for(int i=0; i<feld.length; i++) feld[i]=2*i+1;

Array: Arbeitsweise Deklaration: int[ ] folge; int zfolge; // Zeiger Füllstand Erzeugung: folge = new int[100]; Initialisierung: for(int i=0;i<max;i++) folge[i]=0; Zugriff nur zwischen 0…max Index möglich! Lesen: a = folge[z]; System.out.println(folge[2]); for(int i=1; i<zfolge; i++) summe +=folge[i]; Schreiben: folge[z] = b;

Weblog–Analyse Auswertung der Zugriffe je Stunde vereinfacht Zugriffe = Eingabe der Stunde durch Nutzer: Eingabe 14 = ein Zugriff in 14:00 – 14:59 notwendig: Sammlung für 24 Werte (int) Methode zum Einlesen von Werten

Array zugriffeInStunde

Klasse Weblog class Weblog { // Instanz-Variabeln private int[ ] zugriffInStunde; private int maxSt; public Weblog () { maxSt = 24; zugriffInStunde = new int[maxSt]; for(int i=0; i<maxSt; i++) zugriffInStunde[i] = 0; } //Weblog public int getZugriffInStunde(int st) { return zugriffInStunde[st];} public int summeZugriffe(){ … }

Methode Einlesen public void liesZugriffe() { wiederhole: Sag Nutzer, dass Stunde einzugeben ist. Lies Stunde ein. Wenn gültige Stunde, dann erhöhe Anzahl Zugriffe in der Stunde um eins. bis Ende (Nutzer hat –1 eingegeben) } //liesZugriffe

Ein–, Ausgabe: Klasse LineIO Sammlung von Methoden für Ein-, Ausgabe: write, writeln für String, int, double, … io.writeln("zahl= "+z); formatierte Ausgabe: io.write(betrag,7,2); Eingabe für Sring, double, int, char: zahl = io.readInt("Bitte Zahl eingeben: "); KEIN Bestandteil der API! Datei LineIO.class muss im Verzeichnis stehen

 Schauen Sie sich LineIO.java an, welche Methoden es gibt! Nutzung von LineIO LineIO.java kopieren in BlueJ: Edit > Add class from file E/A-Objekt in Methode erzeugen: LineIO io = new LineIO(); Methoden nutzen: st = io.readInt(" Zahl eingeben"); werden Eingaben programmiert, dann: public void einlesen() throws Exception …  Schauen Sie sich LineIO.java an, welche Methoden es gibt!

Methode Einlesen public void liesZugriffe() throws Exception { IntIO io = new IntIO(); // Ein- Ausgabe-Objekt int st = -1; // einzulesende Stunde io.writeln(" Weblog: Eingabe der Stunden. Ende mit –1 "); do { st=io.readInt("Zugriff in Stunde: "); if(st>=0 && st<=maxSt) { // Test auf gueltige Stunde zugriffInStunde[st]++; // Anzahl Zugriffe erhöhen } else if(st!= -1){ // falls keine Stunde (s.o.) und kein Ende io.writeln("Ungueltige Stundenangabe!"); } //if while(st!=-1); // wiederhole solange nicht Ende } //liesZugriffe

Iteration: do–while–Schleife do { Anweisungen } while (Bedingung); do { zahl = io.readInt("Zahl: "); if (zahl >0) summe = summe +zahl; } while (zahl != -1); endgesteuert eingesetzt, falls: Zahl der Durchläufe unbestimmt ist, und Körper mindestens einmal durchlaufen werden muss. typisch: Nutzerdialog Interpretation: Führe die Anweisungen wiederholt aus, solange die Bedingung wahr ist.

Iteration: for–Schleife for (Initialisierung; Bedingung; EndeAnweisung) { Anweisungen } //for int fak = 1; for (int i=1;i<=zahl; i++) { fak = fak * i; } //for anfangsgesteuert eingesetzt, falls: Zahl der Schleifendurchläufe bekannt ist und durch eine Zählvariable gezählt werden kann Interpretation: Führe die Initialisierung aus, führe dann die Anweisungen des Körpers wiederholt aus, solange die Bedingung gilt. Nach jeder Ausführung des Schleifenkörpers wird die EndeAnweisung einmal ausgeführt.

Beispiel for(int index = 0; index < zugriffeInStunden.length; index++) { io.writeln(index + ": " + zugriffeInStunden[index]); } //for Wirkung identisch! int index = 0; while(index < zugriffeInStunden.length) { io.writeln(index + ": " + zugriffeInStunden [index]); index++; } //while

Zusammenfassung Sammlung Arraylist Sammlung: Elemente (Objekte) mit Index 0,1,… import java.util.Arraylist; API enthält die Infos über Methoden wichtige Methoden: add, delete, get, size Arrays für Sammlungen mit fester Obergrenze Sammlung: Elemente mit Index 0,1,… Elemente sind Objekte oder einfache Datentypen Arrays sind Objekte  mit new erzeugen haben spezielle Syntax: eckige Klammern [ ]

Zusammenfassung – Schleifen while(!gefunden) { … } do { … } while(!ende); for(Notiz n:notizen) … //for-each for(int i= 0,i<zfolge, i++) { folge[i] … } // iterator: Iterator<Notiz> it = notizen.iterator(); while (it.hasNext()) …

Aufgabe - Sieb des Eratosthenes Zahl n einlesen Array mit Elementen von 0..n erzeugen; Alle Komponenten auf true setzen Mit 2 beginnen bis n: alle Vielfachen im Array „streichen“, d.h. auf false setzen Ausgabe der Primzahlen zwischen 0..n  Programmieren Sie den Algorithmus in einer ausführbaren Klasse (main-Methode)

Aufgabe Studenten–Team Felder/Array kann beliebigen Typ enthalten! Student[ ] team; int zst; 1 2 3 4 5 … team = new Student[anzahl]; … team[zst] = new Student(name, matrikel); zst++;  Entwickeln Sie eine Klasse Team, in der ein Studenten–Team verwaltet werden kann. Benutzen Sie eine Klasse Student und verwalten Sie die Team-Mitglieder in einem Array! Die maximale Teamgröße wird beim Erzeugen eines Teams festgelegt.

Ende