Java Tutorium: Übung 5

Step Zaehler n
_______________
A     0     13
B     0     13
D     0     13
E     0     40
_______________

A     1     40
B     1     40
C     1     20
E     1     20
_______________

A     2     20
B     2     20
C     2     10
E     2     10
_______________

A     3     10
B     3     10
C     3      5
E     3      5
_______________

A     4      5
B     4      5
D     4      5
E     4     16
_______________

A     5     16
B     5     16
C     5      8
E     5      8
_______________

A     6      8
B     6      8
C     6      4
E     6      4
_______________

A     7      4
B     7      4
C     7      2
E     7      2
_______________

A     8      2
B     8      2
C     8      1
E     8      1
_______________

A     9      1
Ergebnis: 9

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

Step Zaehler n

_______________

A 0 13

B 0 13

D 0 13

E 0 40

_______________

A 1 40

B 1 40

C 1 20

E 1 20

_______________

A 2 20

B 2 20

C 2 10

E 2 10

_______________

A 3 10

B 3 10

C 3 5

E 3 5

_______________

A 4 5

B 4 5

D 4 5

E 4 16

_______________

A 5 16

B 5 16

C 5 8

E 5 8

_______________

A 6 8

B 6 8

C 6 4

E 6 4

_______________

A 7 4

B 7 4

C 7 2

E 7 2

_______________

A 8 2

B 8 2

C 8 1

E 8 1

_______________

A 9 1

Ergebnis: 9

7 3 1

1

7 3 1

"hans28" 
"susi" 
 -> 89"alfred" 
"13gert" 
"magda_23" 
 -> 14"ENDE"

1

2

3

4

5

6

"hans28"

"susi"

-> 89"alfred"

"13gert"

"magda_23"

-> 14"ENDE"

-2 2 6 10

1

-2 2 6 10

3 2 1 0

1

3 2 1 0

*C 1 1
*C 1 2
*C 1 3
*C 1 4
*C 1 5
*C 1 6

*C 2 1
*C 2 2
*C 2 3
*C 2 4
*C 2 5
*C 2 6

*C 3 1
*C 3 2
*C 3 3
*C 3 4
*C 3 5
*C 3 6

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

*C 1 1

*C 1 2

*C 1 3

*C 1 4

*C 1 5

*C 1 6

*C 2 1

*C 2 2

*C 2 3

*C 2 4

*C 2 5

*C 2 6

*C 3 1

*C 3 2

*C 3 3

*C 3 4

*C 3 5

*C 3 6

++C 1 1
++C 2 1
++C 2 2
++C 3 1
++C 3 2
++C 3 3
++C 4 1
++C 4 2
++C 4 3
++C 4 4
++C 5 1
++C 5 2
++C 5 3
++C 5 4
++C 5 5

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

++C 1 1

++C 2 1

++C 2 2

++C 3 1

++C 3 2

++C 3 3

++C 4 1

++C 4 2

++C 4 3

++C 4 4

++C 5 1

++C 5 2

++C 5 3

++C 5 4

++C 5 5

package de.bht.programming1.exercise05;

import java.io.PrintWriter;
import java.util.Scanner;

final public class ScheifenTest {

    public static PrintWriter cout = new PrintWriter(System.out, true);

    public static void main(String[] args) {
        a();
        b();
        c();
        d();
        e();
        f();
        g();
    }

    public static void a() {
        int zaehler = 0;
        int n = 13;
        cout.println("Step Zaehler n");
        cout.println("_______________");
        cout.printf("%s %5d  %5d\n", "A", zaehler, n);
        while (n != 1) {
            cout.printf("%s %5d  %5d\n", "B", zaehler, n);
            if (n % 2 == 0) {
                n = n / 2;
                cout.printf("%s %5d  %5d\n", "C", zaehler, n);
            } else {
                cout.printf("%s %5d  %5d\n", "D", zaehler, n);
                n = 3 * n + 1;
            }
            cout.printf("%s %5d  %5d\n", "E", zaehler, n);
            cout.println("_______________");
            cout.println();
            zaehler = zaehler + 1;
            cout.printf("%s %5d  %5d\n", "A", zaehler, n);
        }
        cout.println("Ergebnis: " + zaehler);
    }

    public static void b() {
        int anna = 7;
        while (anna > 0) { // A
            cout.print(anna + " "); // B
            anna /= 2; // anna = anna / 2;
        }
        cout.println();
    }

    public static void c() {
        Scanner in = new Scanner(" hans28 susi 89 alfred 13gert magda_23 14 ENDE");
        while (in.hasNext()) {
            if (in.hasNextInt()) {
                cout.print(" -> " + in.nextInt());
                continue;
            }
            cout.print("\"" + in.next() + "\" ");
            cout.println();
        }
    }

    public static void d() {
        for (int celia = -3; celia < 5; celia += 2) {
            cout.print(2 * celia + 4 + " ");
        }
        cout.println();
    }

    public static void e() {
        for (int dora = 3; 3 * dora > -3; dora--) {
            cout.print(dora + " ");
        }
        cout.println();
    }

    public static void f() {
        final int MAX1 = 3;
        for (int i1 = 1; i1 <= MAX1; i1++) { // A
            for (int i2 = 1; i2 <= 2 * MAX1; i2++) { // B
                cout.print("*"); // C
                cout.println("C " + i1 + " " + i2);
            }
            cout.println();
        }

    }

    public static void g() {
        final int MAX2 = 5;
        for (int i1 = 1; i1 <= MAX2; i1++) {
            for (int i2 = 1; i2 <= i1; i2++) {
                cout.print("++");
                cout.println("C " + i1 + " " + i2);
            }
        }
        cout.println();
    }
}

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

final public class ScheifenTest {

public static PrintWriter cout = new PrintWriter(System.out, true);

public static void main(String[] args) {

a();

b();

c();

d();

e();

f();

g();

}

public static void a() {

int zaehler = 0;

int n = 13;

cout.println("Step Zaehler n");

cout.println("_______________");

cout.printf("%s %5d %5d\n", "A", zaehler, n);

while (n != 1) {

cout.printf("%s %5d %5d\n", "B", zaehler, n);

if (n % 2 == 0) {

n = n / 2;

cout.printf("%s %5d %5d\n", "C", zaehler, n);

} else {

cout.printf("%s %5d %5d\n", "D", zaehler, n);

n = 3 * n + 1;

}

cout.printf("%s %5d %5d\n", "E", zaehler, n);

cout.println("_______________");

cout.println();

zaehler = zaehler + 1;

cout.printf("%s %5d %5d\n", "A", zaehler, n);

}

cout.println("Ergebnis: " + zaehler);

}

public static void b() {

int anna = 7;

while (anna > 0) { // A

cout.print(anna + " "); // B

anna /= 2; // anna = anna / 2;

}

cout.println();

}

public static void c() {

Scanner in = new Scanner(" hans28 susi 89 alfred 13gert magda_23 14 ENDE");

while (in.hasNext()) {

if (in.hasNextInt()) {

cout.print(" -> " + in.nextInt());

continue;

}

cout.print("\"" + in.next() + "\" ");

cout.println();

}

public static void d() {

for (int celia = -3; celia < 5; celia += 2) {

cout.print(2 * celia + 4 + " ");

}

cout.println();

}

public static void e() {

for (int dora = 3; 3 * dora > -3; dora--) {

cout.print(dora + " ");

}

cout.println();

}

public static void f() {

final int MAX1 = 3;

for (int i1 = 1; i1 <= MAX1; i1++) { // A

for (int i2 = 1; i2 <= 2 * MAX1; i2++) { // B

cout.print("*"); // C

cout.println("C " + i1 + " " + i2);

}

cout.println();

}

public static void g() {

final int MAX2 = 5;

for (int i1 = 1; i1 <= MAX2; i1++) {

for (int i2 = 1; i2 <= i1; i2++) {

cout.print("++");

cout.println("C " + i1 + " " + i2);

}

cout.println();

}

package de.bht.programming1.exercise05;

import lernhilfe.v2010ws01.Person;
import lernhilfe.v2010ws01.Personenliste;
import pr1.qad.DirtyFileReader;
import pr1.qad.DirtyFileWriter;

import java.io.File;
import java.io.PrintWriter;
import java.util.Scanner;

public class MehrPersonen {

    public static final String FILEPATH = "assets/files/listen/";
    public static final String FILENAME_PERSON_LIST = "personenliste.txt";

    public static void main(String[] args) {
        // naively creating folder if not exist
        File f = new File(FILEPATH);
        f.mkdirs();
        testAusgabe();
        System.out.println();
        testEinlesen();
    }

    /**
     * test-Methode zur Ausgabe einer Freundesliste in eine Datei und auf der Konsole
     */
    public static void testAusgabe() {

        // Konsolen ausgabe
        PrintWriter cout = new PrintWriter(System.out, true);

        // Datei ausgabe
        PrintWriter fout = new PrintWriter(new DirtyFileWriter(FILEPATH + FILENAME_PERSON_LIST));

        // Erstellen der Freundesliste
        Personenliste freunde = createList();

        // Ausgabe auf der Konsole
        printPersonenliste("Konsole: Freunde", freunde, cout);

        // Ausgabe in der Datei
        printPersonenliste("Datei: Freunde", freunde, fout);

        // freigeben der Datei
        fout.close();
    }

    /**
     * test-Methode zum einlesen einer Datei und Ausgabe auf der Konsole
     */
    public static void testEinlesen() {

        // öffnen der datei
        Scanner fin = new Scanner(new DirtyFileReader(FILEPATH + FILENAME_PERSON_LIST));

        // freundeliste wird erstellt durch 'readPersonenListe(fin)'
        Personenliste freunde = createPersonenliste(fin);

        // Ausgabe der Freundesliste auf der Konsole
        printPersonenliste("Datei auf Konsole: ", freunde, new PrintWriter(System.out, true));

        // freigeben der Datei
        fin.close();
    }

    public static void printPersonenliste(String headerline, Personenliste liste, PrintWriter out) {
        out.println(headerline);
        for (Person p : liste) {
            out.println(p);
        }
    }

    /**
     * Erstellt eine Liste mit Person Objekten
     *
     * @return liste
     */
    public static Personenliste createList() {

        Personenliste liste = new Personenliste();

        Person person = new Person("Kurt", "Bangert", 1988);
        liste.add(person);

        /** kurzschreibweise für das hinzufügen einer person zur liste **/
        liste.add(new Person("Gerhard", "Ackermann", 1956));
        liste.add(new Person("Peter", "Arnke", 1977));
        liste.add(new Person("Peter", "Bartsch", 1954));
        liste.add(new Person("Reinhard", "Barrabas", 1989));
        liste.add(new Person("Christopher", "Bode", 1956));

        // gibt die liste zurück
        return liste;
    }

    public static Personenliste createPersonenliste(String filename) {
        Scanner fin = new Scanner(new DirtyFileReader(filename));
        fin.close();
        return createPersonenliste(fin);
    }

    public static Personenliste createPersonenliste(Scanner sin) {
        Personenliste list = new Personenliste();
        // führe die Schleife aus, solange bis keine weiteren Zeilen in der Datei sind
        while (sin.hasNextLine()) {
            // hinzufügen einer Person pro Zeile parsePerson-Methode kümmert
            // sich darum, das die Person korrekt erzeugt wird; sollte in einer
            // Zeile ein fehler auftreten, so wird mit der nächsten Zeile
            // fortgeführt
            list.add(createPerson(new Scanner(sin.nextLine())));
        }
        return list;
    }

    /**
     * Zergliedern (parsing) der Zeile zu einer Person
     *
     * @param in Scanner
     * @return Person
     */
    private static Person createPerson(Scanner in) {

        String vorname = "";
        String nachname = "";
        int geburtsjahr = 0;

        // vorname
        if (in.hasNext()) {
            vorname = in.next();
        }
        // nachname
        if (in.hasNext()) {
            nachname = in.next();
            // Komma am Ende entfernen
            nachname = nachname.substring(0, nachname.length() - 1);
        }
        // geb. (brauchen wir nicht, daher springen wir ein Element weiter durch '.next()'
        if (in.hasNext()) {
            in.next(); // geb.
        }
        // geburtsjahr (ist ein integer)
        if (in.hasNextInt()) {
            geburtsjahr = in.nextInt();
        }
        // Rückgabe der neu erstellten Person
        return new Person(vorname, nachname, geburtsjahr);
    }
}

98

99

100

101

102

public static Personenliste createPersonenliste(String filename) {

Scanner fin = new Scanner(new DirtyFileReader(filename));

fin.close();

return createPersonenliste(fin);

}

package de.bht.programming1.exercise05;

import lernhilfe.v2010ws01.Person;
import lernhilfe.v2010ws01.Personenliste;
import pr1.qad.DirtyFileReader;
import pr1.qad.DirtyFileWriter;

import java.io.File;
import java.io.PrintWriter;
import java.util.Scanner;

public class MehrPersonen {

    public static final String FILEPATH = "assets/files/listen/";
    public static final String FILENAME_PERSON_LIST = "personenliste.txt";

    public static void main(String[] args) {
        // naively creating folder if not exist
        File f = new File(FILEPATH);
        f.mkdirs();
        testAusgabe();
        System.out.println();
        testEinlesen();
    }

    /**
     * test-Methode zur Ausgabe einer Freundesliste in eine Datei und auf der Konsole
     */
    public static void testAusgabe() {

        // Konsolen ausgabe
        PrintWriter cout = new PrintWriter(System.out, true);

        // Datei ausgabe
        PrintWriter fout = new PrintWriter(new DirtyFileWriter(FILEPATH + FILENAME_PERSON_LIST));

        // Erstellen der Freundesliste
        Personenliste freunde = createList();

        // Ausgabe auf der Konsole
        printPersonenliste("Konsole: Freunde", freunde, cout);

        // Ausgabe in der Datei
        printPersonenliste("Datei: Freunde", freunde, fout);

        // freigeben der Datei
        fout.close();
    }

    /**
     * test-Methode zum einlesen einer Datei und Ausgabe auf der Konsole
     */
    public static void testEinlesen() {

        // öffnen der datei
        Scanner fin = new Scanner(new DirtyFileReader(FILEPATH + FILENAME_PERSON_LIST));

        // freundeliste wird erstellt durch 'readPersonenListe(fin)'
        Personenliste freunde = createPersonenliste(fin);

        // Ausgabe der Freundesliste auf der Konsole
        printPersonenliste("Datei auf Konsole: ", freunde, new PrintWriter(System.out, true));

        // freigeben der Datei
        fin.close();
    }

    public static void printPersonenliste(String headerline, Personenliste liste, PrintWriter out) {
        out.println(headerline);
        for (Person p : liste) {
            out.println(p);
        }
    }

    /**
     * Erstellt eine Liste mit Person Objekten
     *
     * @return liste
     */
    public static Personenliste createList() {

        Personenliste liste = new Personenliste();

        Person person = new Person("Kurt", "Bangert", 1988);
        liste.add(person);

        /** kurzschreibweise für das hinzufügen einer person zur liste **/
        liste.add(new Person("Gerhard", "Ackermann", 1956));
        liste.add(new Person("Peter", "Arnke", 1977));
        liste.add(new Person("Peter", "Bartsch", 1954));
        liste.add(new Person("Reinhard", "Barrabas", 1989));
        liste.add(new Person("Christopher", "Bode", 1956));

        // gibt die liste zurück
        return liste;
    }

    public static Personenliste createPersonenliste(String filename) {
        Scanner fin = new Scanner(new DirtyFileReader(filename));
        fin.close();
        return createPersonenliste(fin);
    }

    public static Personenliste createPersonenliste(Scanner sin) {
        Personenliste list = new Personenliste();
        // führe die Schleife aus, solange bis keine weiteren Zeilen in der Datei sind
        while (sin.hasNextLine()) {
            // hinzufügen einer Person pro Zeile parsePerson-Methode kümmert
            // sich darum, das die Person korrekt erzeugt wird; sollte in einer
            // Zeile ein fehler auftreten, so wird mit der nächsten Zeile
            // fortgeführt
            list.add(createPerson(new Scanner(sin.nextLine())));
        }
        return list;
    }

    /**
     * Zergliedern (parsing) der Zeile zu einer Person
     *
     * @param in Scanner
     * @return Person
     */
    private static Person createPerson(Scanner in) {

        String vorname = "";
        String nachname = "";
        int geburtsjahr = 0;

        // vorname
        if (in.hasNext()) {
            vorname = in.next();
        }
        // nachname
        if (in.hasNext()) {
            nachname = in.next();
            // Komma am Ende entfernen
            nachname = nachname.substring(0, nachname.length() - 1);
        }
        // geb. (brauchen wir nicht, daher springen wir ein Element weiter durch '.next()'
        if (in.hasNext()) {
            in.next(); // geb.
        }
        // geburtsjahr (ist ein integer)
        if (in.hasNextInt()) {
            geburtsjahr = in.nextInt();
        }
        // Rückgabe der neu erstellten Person
        return new Person(vorname, nachname, geburtsjahr);
    }
}

104

105

106

107

108

109

110

111

112

113

114

115

public static Personenliste createPersonenliste(Scanner sin) {

Personenliste list = new Personenliste();

// führe die Schleife aus, solange bis keine weiteren Zeilen in der Datei sind

while (sin.hasNextLine()) {

// hinzufügen einer Person pro Zeile parsePerson-Methode kümmert

// sich darum, das die Person korrekt erzeugt wird; sollte in einer

// Zeile ein fehler auftreten, so wird mit der nächsten Zeile

// fortgeführt

list.add(createPerson(new Scanner(sin.nextLine())));

}

return list;

}

package de.bht.programming1.exercise05;

import lernhilfe.v2010ws01.Person;
import lernhilfe.v2010ws01.Personenliste;
import pr1.qad.DirtyFileReader;
import pr1.qad.DirtyFileWriter;

import java.io.File;
import java.io.PrintWriter;
import java.util.Scanner;

public class MehrPersonen {

    public static final String FILEPATH = "assets/files/listen/";
    public static final String FILENAME_PERSON_LIST = "personenliste.txt";

    public static void main(String[] args) {
        // naively creating folder if not exist
        File f = new File(FILEPATH);
        f.mkdirs();
        testAusgabe();
        System.out.println();
        testEinlesen();
    }

    /**
     * test-Methode zur Ausgabe einer Freundesliste in eine Datei und auf der Konsole
     */
    public static void testAusgabe() {

        // Konsolen ausgabe
        PrintWriter cout = new PrintWriter(System.out, true);

        // Datei ausgabe
        PrintWriter fout = new PrintWriter(new DirtyFileWriter(FILEPATH + FILENAME_PERSON_LIST));

        // Erstellen der Freundesliste
        Personenliste freunde = createList();

        // Ausgabe auf der Konsole
        printPersonenliste("Konsole: Freunde", freunde, cout);

        // Ausgabe in der Datei
        printPersonenliste("Datei: Freunde", freunde, fout);

        // freigeben der Datei
        fout.close();
    }

    /**
     * test-Methode zum einlesen einer Datei und Ausgabe auf der Konsole
     */
    public static void testEinlesen() {

        // öffnen der datei
        Scanner fin = new Scanner(new DirtyFileReader(FILEPATH + FILENAME_PERSON_LIST));

        // freundeliste wird erstellt durch 'readPersonenListe(fin)'
        Personenliste freunde = createPersonenliste(fin);

        // Ausgabe der Freundesliste auf der Konsole
        printPersonenliste("Datei auf Konsole: ", freunde, new PrintWriter(System.out, true));

        // freigeben der Datei
        fin.close();
    }

    public static void printPersonenliste(String headerline, Personenliste liste, PrintWriter out) {
        out.println(headerline);
        for (Person p : liste) {
            out.println(p);
        }
    }

    /**
     * Erstellt eine Liste mit Person Objekten
     *
     * @return liste
     */
    public static Personenliste createList() {

        Personenliste liste = new Personenliste();

        Person person = new Person("Kurt", "Bangert", 1988);
        liste.add(person);

        /** kurzschreibweise für das hinzufügen einer person zur liste **/
        liste.add(new Person("Gerhard", "Ackermann", 1956));
        liste.add(new Person("Peter", "Arnke", 1977));
        liste.add(new Person("Peter", "Bartsch", 1954));
        liste.add(new Person("Reinhard", "Barrabas", 1989));
        liste.add(new Person("Christopher", "Bode", 1956));

        // gibt die liste zurück
        return liste;
    }

    public static Personenliste createPersonenliste(String filename) {
        Scanner fin = new Scanner(new DirtyFileReader(filename));
        fin.close();
        return createPersonenliste(fin);
    }

    public static Personenliste createPersonenliste(Scanner sin) {
        Personenliste list = new Personenliste();
        // führe die Schleife aus, solange bis keine weiteren Zeilen in der Datei sind
        while (sin.hasNextLine()) {
            // hinzufügen einer Person pro Zeile parsePerson-Methode kümmert
            // sich darum, das die Person korrekt erzeugt wird; sollte in einer
            // Zeile ein fehler auftreten, so wird mit der nächsten Zeile
            // fortgeführt
            list.add(createPerson(new Scanner(sin.nextLine())));
        }
        return list;
    }

    /**
     * Zergliedern (parsing) der Zeile zu einer Person
     *
     * @param in Scanner
     * @return Person
     */
    private static Person createPerson(Scanner in) {

        String vorname = "";
        String nachname = "";
        int geburtsjahr = 0;

        // vorname
        if (in.hasNext()) {
            vorname = in.next();
        }
        // nachname
        if (in.hasNext()) {
            nachname = in.next();
            // Komma am Ende entfernen
            nachname = nachname.substring(0, nachname.length() - 1);
        }
        // geb. (brauchen wir nicht, daher springen wir ein Element weiter durch '.next()'
        if (in.hasNext()) {
            in.next(); // geb.
        }
        // geburtsjahr (ist ein integer)
        if (in.hasNextInt()) {
            geburtsjahr = in.nextInt();
        }
        // Rückgabe der neu erstellten Person
        return new Person(vorname, nachname, geburtsjahr);
    }
}

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

/**

* Zergliedern (parsing) der Zeile zu einer Person

*

* @param in Scanner

* @return Person

*/

private static Person createPerson(Scanner in) {

String vorname = "";

String nachname = "";

int geburtsjahr = 0;

// vorname

if (in.hasNext()) {

vorname = in.next();

}

// nachname

if (in.hasNext()) {

nachname = in.next();

// Komma am Ende entfernen

nachname = nachname.substring(0, nachname.length() - 1);

}

// geb. (brauchen wir nicht, daher springen wir ein Element weiter durch '.next()'

if (in.hasNext()) {

in.next(); // geb.

}

// geburtsjahr (ist ein integer)

if (in.hasNextInt()) {

geburtsjahr = in.nextInt();

}

// Rückgabe der neu erstellten Person

return new Person(vorname, nachname, geburtsjahr);

}

package de.bht.programming1.exercise05;

import lernhilfe.v2010ws01.Person;
import lernhilfe.v2010ws01.Personenliste;
import pr1.qad.DirtyFileReader;
import pr1.qad.DirtyFileWriter;

import java.io.File;
import java.io.PrintWriter;
import java.util.Scanner;

public class MehrPersonen {

    public static final String FILEPATH = "assets/files/listen/";
    public static final String FILENAME_PERSON_LIST = "personenliste.txt";

    public static void main(String[] args) {
        // naively creating folder if not exist
        File f = new File(FILEPATH);
        f.mkdirs();
        testAusgabe();
        System.out.println();
        testEinlesen();
    }

    /**
     * test-Methode zur Ausgabe einer Freundesliste in eine Datei und auf der Konsole
     */
    public static void testAusgabe() {

        // Konsolen ausgabe
        PrintWriter cout = new PrintWriter(System.out, true);

        // Datei ausgabe
        PrintWriter fout = new PrintWriter(new DirtyFileWriter(FILEPATH + FILENAME_PERSON_LIST));

        // Erstellen der Freundesliste
        Personenliste freunde = createList();

        // Ausgabe auf der Konsole
        printPersonenliste("Konsole: Freunde", freunde, cout);

        // Ausgabe in der Datei
        printPersonenliste("Datei: Freunde", freunde, fout);

        // freigeben der Datei
        fout.close();
    }

    /**
     * test-Methode zum einlesen einer Datei und Ausgabe auf der Konsole
     */
    public static void testEinlesen() {

        // öffnen der datei
        Scanner fin = new Scanner(new DirtyFileReader(FILEPATH + FILENAME_PERSON_LIST));

        // freundeliste wird erstellt durch 'readPersonenListe(fin)'
        Personenliste freunde = createPersonenliste(fin);

        // Ausgabe der Freundesliste auf der Konsole
        printPersonenliste("Datei auf Konsole: ", freunde, new PrintWriter(System.out, true));

        // freigeben der Datei
        fin.close();
    }

    public static void printPersonenliste(String headerline, Personenliste liste, PrintWriter out) {
        out.println(headerline);
        for (Person p : liste) {
            out.println(p);
        }
    }

    /**
     * Erstellt eine Liste mit Person Objekten
     *
     * @return liste
     */
    public static Personenliste createList() {

        Personenliste liste = new Personenliste();

        Person person = new Person("Kurt", "Bangert", 1988);
        liste.add(person);

        /** kurzschreibweise für das hinzufügen einer person zur liste **/
        liste.add(new Person("Gerhard", "Ackermann", 1956));
        liste.add(new Person("Peter", "Arnke", 1977));
        liste.add(new Person("Peter", "Bartsch", 1954));
        liste.add(new Person("Reinhard", "Barrabas", 1989));
        liste.add(new Person("Christopher", "Bode", 1956));

        // gibt die liste zurück
        return liste;
    }

    public static Personenliste createPersonenliste(String filename) {
        Scanner fin = new Scanner(new DirtyFileReader(filename));
        fin.close();
        return createPersonenliste(fin);
    }

    public static Personenliste createPersonenliste(Scanner sin) {
        Personenliste list = new Personenliste();
        // führe die Schleife aus, solange bis keine weiteren Zeilen in der Datei sind
        while (sin.hasNextLine()) {
            // hinzufügen einer Person pro Zeile parsePerson-Methode kümmert
            // sich darum, das die Person korrekt erzeugt wird; sollte in einer
            // Zeile ein fehler auftreten, so wird mit der nächsten Zeile
            // fortgeführt
            list.add(createPerson(new Scanner(sin.nextLine())));
        }
        return list;
    }

    /**
     * Zergliedern (parsing) der Zeile zu einer Person
     *
     * @param in Scanner
     * @return Person
     */
    private static Person createPerson(Scanner in) {

        String vorname = "";
        String nachname = "";
        int geburtsjahr = 0;

        // vorname
        if (in.hasNext()) {
            vorname = in.next();
        }
        // nachname
        if (in.hasNext()) {
            nachname = in.next();
            // Komma am Ende entfernen
            nachname = nachname.substring(0, nachname.length() - 1);
        }
        // geb. (brauchen wir nicht, daher springen wir ein Element weiter durch '.next()'
        if (in.hasNext()) {
            in.next(); // geb.
        }
        // geburtsjahr (ist ein integer)
        if (in.hasNextInt()) {
            geburtsjahr = in.nextInt();
        }
        // Rückgabe der neu erstellten Person
        return new Person(vorname, nachname, geburtsjahr);
    }
}

68

69

70

71

72

73

public static void printPersonenliste(String headerline, Personenliste liste, PrintWriter out) {

out.println(headerline);

for (Person p : liste) {

out.println(p);

}

package de.bht.programming1.exercise05;

import lernhilfe.v2010ws01.Person;
import lernhilfe.v2010ws01.Personenliste;
import pr1.qad.DirtyFileReader;
import pr1.qad.DirtyFileWriter;

import java.io.File;
import java.io.PrintWriter;
import java.util.Scanner;

public class MehrPersonen {

    public static final String FILEPATH = "assets/files/listen/";
    public static final String FILENAME_PERSON_LIST = "personenliste.txt";

    public static void main(String[] args) {
        // naively creating folder if not exist
        File f = new File(FILEPATH);
        f.mkdirs();
        testAusgabe();
        System.out.println();
        testEinlesen();
    }

    /**
     * test-Methode zur Ausgabe einer Freundesliste in eine Datei und auf der Konsole
     */
    public static void testAusgabe() {

        // Konsolen ausgabe
        PrintWriter cout = new PrintWriter(System.out, true);

        // Datei ausgabe
        PrintWriter fout = new PrintWriter(new DirtyFileWriter(FILEPATH + FILENAME_PERSON_LIST));

        // Erstellen der Freundesliste
        Personenliste freunde = createList();

        // Ausgabe auf der Konsole
        printPersonenliste("Konsole: Freunde", freunde, cout);

        // Ausgabe in der Datei
        printPersonenliste("Datei: Freunde", freunde, fout);

        // freigeben der Datei
        fout.close();
    }

    /**
     * test-Methode zum einlesen einer Datei und Ausgabe auf der Konsole
     */
    public static void testEinlesen() {

        // öffnen der datei
        Scanner fin = new Scanner(new DirtyFileReader(FILEPATH + FILENAME_PERSON_LIST));

        // freundeliste wird erstellt durch 'readPersonenListe(fin)'
        Personenliste freunde = createPersonenliste(fin);

        // Ausgabe der Freundesliste auf der Konsole
        printPersonenliste("Datei auf Konsole: ", freunde, new PrintWriter(System.out, true));

        // freigeben der Datei
        fin.close();
    }

    public static void printPersonenliste(String headerline, Personenliste liste, PrintWriter out) {
        out.println(headerline);
        for (Person p : liste) {
            out.println(p);
        }
    }

    /**
     * Erstellt eine Liste mit Person Objekten
     *
     * @return liste
     */
    public static Personenliste createList() {

        Personenliste liste = new Personenliste();

        Person person = new Person("Kurt", "Bangert", 1988);
        liste.add(person);

        /** kurzschreibweise für das hinzufügen einer person zur liste **/
        liste.add(new Person("Gerhard", "Ackermann", 1956));
        liste.add(new Person("Peter", "Arnke", 1977));
        liste.add(new Person("Peter", "Bartsch", 1954));
        liste.add(new Person("Reinhard", "Barrabas", 1989));
        liste.add(new Person("Christopher", "Bode", 1956));

        // gibt die liste zurück
        return liste;
    }

    public static Personenliste createPersonenliste(String filename) {
        Scanner fin = new Scanner(new DirtyFileReader(filename));
        fin.close();
        return createPersonenliste(fin);
    }

    public static Personenliste createPersonenliste(Scanner sin) {
        Personenliste list = new Personenliste();
        // führe die Schleife aus, solange bis keine weiteren Zeilen in der Datei sind
        while (sin.hasNextLine()) {
            // hinzufügen einer Person pro Zeile parsePerson-Methode kümmert
            // sich darum, das die Person korrekt erzeugt wird; sollte in einer
            // Zeile ein fehler auftreten, so wird mit der nächsten Zeile
            // fortgeführt
            list.add(createPerson(new Scanner(sin.nextLine())));
        }
        return list;
    }

    /**
     * Zergliedern (parsing) der Zeile zu einer Person
     *
     * @param in Scanner
     * @return Person
     */
    private static Person createPerson(Scanner in) {

        String vorname = "";
        String nachname = "";
        int geburtsjahr = 0;

        // vorname
        if (in.hasNext()) {
            vorname = in.next();
        }
        // nachname
        if (in.hasNext()) {
            nachname = in.next();
            // Komma am Ende entfernen
            nachname = nachname.substring(0, nachname.length() - 1);
        }
        // geb. (brauchen wir nicht, daher springen wir ein Element weiter durch '.next()'
        if (in.hasNext()) {
            in.next(); // geb.
        }
        // geburtsjahr (ist ein integer)
        if (in.hasNextInt()) {
            geburtsjahr = in.nextInt();
        }
        // Rückgabe der neu erstellten Person
        return new Person(vorname, nachname, geburtsjahr);
    }
}

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

/**

* test-Methode zum einlesen einer Datei und Ausgabe auf der Konsole

*/

public static void testEinlesen() {

// öffnen der datei

Scanner fin = new Scanner(new DirtyFileReader(FILEPATH + FILENAME_PERSON_LIST));

// freundeliste wird erstellt durch 'readPersonenListe(fin)'

Personenliste freunde = createPersonenliste(fin);

// Ausgabe der Freundesliste auf der Konsole

printPersonenliste("Datei auf Konsole: ", freunde, new PrintWriter(System.out, true));

// freigeben der Datei

fin.close();

}

package de.bht.programming1.exercise05;

import lernhilfe.v2010ws01.Person;
import lernhilfe.v2010ws01.Personenliste;
import pr1.qad.DirtyFileReader;
import pr1.qad.DirtyFileWriter;

import java.io.File;
import java.io.PrintWriter;
import java.util.Scanner;

public class MehrPersonen {

    public static final String FILEPATH = "assets/files/listen/";
    public static final String FILENAME_PERSON_LIST = "personenliste.txt";

    public static void main(String[] args) {
        // naively creating folder if not exist
        File f = new File(FILEPATH);
        f.mkdirs();
        testAusgabe();
        System.out.println();
        testEinlesen();
    }

    /**
     * test-Methode zur Ausgabe einer Freundesliste in eine Datei und auf der Konsole
     */
    public static void testAusgabe() {

        // Konsolen ausgabe
        PrintWriter cout = new PrintWriter(System.out, true);

        // Datei ausgabe
        PrintWriter fout = new PrintWriter(new DirtyFileWriter(FILEPATH + FILENAME_PERSON_LIST));

        // Erstellen der Freundesliste
        Personenliste freunde = createList();

        // Ausgabe auf der Konsole
        printPersonenliste("Konsole: Freunde", freunde, cout);

        // Ausgabe in der Datei
        printPersonenliste("Datei: Freunde", freunde, fout);

        // freigeben der Datei
        fout.close();
    }

    /**
     * test-Methode zum einlesen einer Datei und Ausgabe auf der Konsole
     */
    public static void testEinlesen() {

        // öffnen der datei
        Scanner fin = new Scanner(new DirtyFileReader(FILEPATH + FILENAME_PERSON_LIST));

        // freundeliste wird erstellt durch 'readPersonenListe(fin)'
        Personenliste freunde = createPersonenliste(fin);

        // Ausgabe der Freundesliste auf der Konsole
        printPersonenliste("Datei auf Konsole: ", freunde, new PrintWriter(System.out, true));

        // freigeben der Datei
        fin.close();
    }

    public static void printPersonenliste(String headerline, Personenliste liste, PrintWriter out) {
        out.println(headerline);
        for (Person p : liste) {
            out.println(p);
        }
    }

    /**
     * Erstellt eine Liste mit Person Objekten
     *
     * @return liste
     */
    public static Personenliste createList() {

        Personenliste liste = new Personenliste();

        Person person = new Person("Kurt", "Bangert", 1988);
        liste.add(person);

        /** kurzschreibweise für das hinzufügen einer person zur liste **/
        liste.add(new Person("Gerhard", "Ackermann", 1956));
        liste.add(new Person("Peter", "Arnke", 1977));
        liste.add(new Person("Peter", "Bartsch", 1954));
        liste.add(new Person("Reinhard", "Barrabas", 1989));
        liste.add(new Person("Christopher", "Bode", 1956));

        // gibt die liste zurück
        return liste;
    }

    public static Personenliste createPersonenliste(String filename) {
        Scanner fin = new Scanner(new DirtyFileReader(filename));
        fin.close();
        return createPersonenliste(fin);
    }

    public static Personenliste createPersonenliste(Scanner sin) {
        Personenliste list = new Personenliste();
        // führe die Schleife aus, solange bis keine weiteren Zeilen in der Datei sind
        while (sin.hasNextLine()) {
            // hinzufügen einer Person pro Zeile parsePerson-Methode kümmert
            // sich darum, das die Person korrekt erzeugt wird; sollte in einer
            // Zeile ein fehler auftreten, so wird mit der nächsten Zeile
            // fortgeführt
            list.add(createPerson(new Scanner(sin.nextLine())));
        }
        return list;
    }

    /**
     * Zergliedern (parsing) der Zeile zu einer Person
     *
     * @param in Scanner
     * @return Person
     */
    private static Person createPerson(Scanner in) {

        String vorname = "";
        String nachname = "";
        int geburtsjahr = 0;

        // vorname
        if (in.hasNext()) {
            vorname = in.next();
        }
        // nachname
        if (in.hasNext()) {
            nachname = in.next();
            // Komma am Ende entfernen
            nachname = nachname.substring(0, nachname.length() - 1);
        }
        // geb. (brauchen wir nicht, daher springen wir ein Element weiter durch '.next()'
        if (in.hasNext()) {
            in.next(); // geb.
        }
        // geburtsjahr (ist ein integer)
        if (in.hasNextInt()) {
            geburtsjahr = in.nextInt();
        }
        // Rückgabe der neu erstellten Person
        return new Person(vorname, nachname, geburtsjahr);
    }
}

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

/**

* test-Methode zur Ausgabe einer Freundesliste in eine Datei und auf der Konsole

*/

public static void testAusgabe() {

// Konsolen ausgabe

PrintWriter cout = new PrintWriter(System.out, true);

// Datei ausgabe

PrintWriter fout = new PrintWriter(new DirtyFileWriter(FILEPATH + FILENAME_PERSON_LIST));

// Erstellen der Freundesliste

Personenliste freunde = createList();

// Ausgabe auf der Konsole

printPersonenliste("Konsole: Freunde", freunde, cout);

// Ausgabe in der Datei

printPersonenliste("Datei: Freunde", freunde, fout);

// freigeben der Datei

fout.close();

}

My Tweets

Frequently visiting

My Cloud

Amazing people

Favorite Tools

APIs

Online Tools

Tutorials

My Latest Animes

Java Tutorium: Übung und Aufgabe 5

Facebook comments:

Leave a Reply Cancel reply