Einführung in die Programmierung Datensammlung

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

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

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

4. 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!!

5. 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 packagebietet 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!

6. erst ab Java 1.5 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

7. 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"

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

9. Benutzen der Sammlung class Notizbuch { private ArrayList <String> notizen; ... publicvoid speichereNotiz(String notiz) { notizen.add(notiz); } // speichereNotiz publicint 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

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

11. 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

12. 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.

13. 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.

14. 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

15. while–Schleife 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.

16. while-Schleife: Beispiel /** * Gib alle Notizen eines Notizbuchs aus */ publicvoid 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

17. 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++;

18. 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!

19. 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. • …

20. 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

21. 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

22. 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)

23. 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 .

24. 0 1 2 3 4 5 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]; feld[0] = 17; feld[1] = 35; for(int i=0; i<feld.length; i++) feld[i]=2*i+1;

25. Array: Arbeitsweise • Deklaration: int[ ] folge;int zfolge; // Zeiger Füllstand • Erzeugung: folge = newint[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;

26. 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

27. Array zugriffeInStunde

28. 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(){ … } } //Weblog

29. Methode Einlesen publicvoid 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

30. 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

31. 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:publicvoid einlesen() throws Exception …  Schauen Sie sich LineIO.java an, welche Methoden es gibt!

32. Methode Einlesen publicvoid 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

33. Iteration: do–while–Schleife do { zahl = io.readInt("Zahl: "); if (zahl >0) summe = summe +zahl; } while (zahl != -1); do { Anweisungen } while (Bedingung); • 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.

34. Iteration: for–Schleife int fak = 1; for (int i=1;i<=zahl; i++) { fak = fak * i; }//for for (Initialisierung; Bedingung; EndeAnweisung) { Anweisungen } //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.

35. 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

36. 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 [ ]

37. 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()) …

38. 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)

39. … 0 1 2 3 4 5 Aufgabe Studenten–Team Student[ ] team;int zst; Felder/Array kann beliebigen Typ enthalten! 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.

40. Ende