FreitagsrundenWiki - Benutzerbeiträge [de]

Javakurs/Übungsaufgaben/Studentendatenbank/Musterloesung

2012-03-07T14:35:30Z

141.23.110.8: Musterlösung

'''Hinweis:''' Die Musterlösung kann von eurer Lösung abweichen, da es immer mehrere Varianten gibt ein Problem zu lösen. Im Zweifelsfall Fragt einen Tutor.

== Lösung: Student.java ==
<nowiki>
/**
* @author Jonas
*/
public class Student {

String name;
int matnr;
String studiengang;
int age;

public Student() {
}

public Student(String name, int matnr, String studiengang, int age) {
this.name = name;
this.matnr = matnr;
this.studiengang = studiengang;
this.age = age;
}

public void printMe() {
System.out.println("Student: " + name + "\n | Matrikelnummer: " + matnr + "\n | Studiengang: " + studiengang+ "\n | Alter: " + age);
}

}
</nowiki>

== Lösung: StudentDatabase.java ==
<nowiki>
/**
* @author Jonas
*/
public class StudentDatabase {

private Student[] students;

public StudentDatabase(int size) {
students = new Student[size];
}

/**
* Gibt alle Studenten auf der Konsole aus.
*/
public void printMe() {
for (Student s : students) {
// Felder im Array, die keinen Eintrag haben, werden ignoriert.
if (s != null) {
s.printMe();
}
}
}

/**
* Wenn noch Platz in der Datenbank ist, wird ein neuer Student erzeugt und
* in die Datenbank eingefügt. Wenn die DB voll ist, wird eine Fehlermeldung
* ausgegeben.
*/
public void addStudent(String name, int matnr, String studiengang, int age) {
int firstFreeIndex = -1;
// Im Array wird das erste freie Feld gesucht.
for (int i = 0; i < students.length; i++) {
if (students[i] == null) {
// Gefunden!
firstFreeIndex = i;
break;
}
}
// Wenn firstFreeIndex immer noch -1 ist, wurde kein freies Feld
// gefunden -> Datenbank ist voll!
if (firstFreeIndex == -1) {
System.out.println("Studentendatenbank voll!");
} else {
// Ansonsten genau an dieser Stelle einen neuen Studenten einfügen.
students[firstFreeIndex] = new Student(name, matnr, studiengang,
age);
}
}

/**
* Der Student mit der übergebenen Matrikelnummer wird aus der Datenbank
* gelöscht. Wenn die Matrikelnummer nicht gefunden wird, wird eine
* Fehlermeldung ausgegeben.
*/
public void deleteStudent(int matnr) {
for (int i = 0; i < students.length; i++) {
// Auch hier die Überprüfung auf null, damit keine
// NullPointerExceptions geworfen werden.
if (students[i] != null && students[i].matnr == matnr) {
students[i] = null;
return;
}
}
System.out.println("Student nicht gefunden!");
}

/**
* Gibt die Anzahl der Studenten in der Datenbank aus.
*/
public int numberOfStudents() {
int result = 0;
for (Student s : students) {
if (s != null) {
result++;
}
}
return result;
}

/**
* Berechnet das durchschnittliche Alter aller Studenten.
*/
public double averageAge() {
int totalAge = 0;
for (Student s : students) {
if (s != null) {
totalAge += s.age;
}
}
// Die Konversion nach double ist erforderlich, da sonst eine Division
// auf ganzen Zahlen durchgeführt wird und Nachkommastellen verloren
// gehen.
return (double) totalAge / (double) numberOfStudents();
}
}
</nowiki>

== Lösung: StudentendatenbankTest.java ==
<nowiki>
import java.util.Random;

/**
* @author Jonas
*/
public class StudentendatenbankTest {

public static void main(String[] args) {
//Aufgabe 1
System.out.println("Erzeuge einen neuen Studenten...");
Student max = new Student();
max.name = "Max Musterstudent";
max.matnr = 424242;
max.studiengang = "Wi-Inf";

System.out.println("Name: " + max.name + ", Matrikelnummer: " + max.matnr + ", Studiengang: " + max.studiengang);

//Aufgabe 2
System.out.println("Erzeuge noch einen neuen Studenten...");
Student paul = new Student("Paul", 213123, "Informatik", 23);
System.out.println("Name: " + paul.name + ", Matrikelnummer: " + paul.matnr + ", Studiengang: " + paul.studiengang);

//Aufgabe 3
System.out.println("Ausgabe mithilfe von printMe()...");
paul.printMe();

//Aufgabe 4
Student[] studenten = new Student[100];
Random random = new Random();
//Schritt 1: Erzeugen...
for (int i = 0; i < 100; i++) {
studenten[i] = new Student("Name", random.nextInt(899999) + 100000, "Informatik", 26);
}
//Schritt 2: Ausgeben... (Dies kann natürlich auch in der ersten for-Schleife erledigt werden.)
for (Student s : studenten) {
s.printMe();
}

//Aufgabe 5
System.out.println("Studentendatenbank erzeugen...");
StudentDatabase db = new StudentDatabase(3);
db.addStudent("Hannes", 123456, "Wi-Inf", 27);
db.addStudent("Marry", 634252, "Informatik", 28);
db.addStudent("Oliver", 234123, "Elektrotechnik", 22);
db.printMe();
//Fehler!
db.addStudent("Name", 123123, "Informatik", 64);

//Aufgabe 6
System.out.println("Hannes entfernen...");
db.deleteStudent(123456);
db.printMe();

//Aufgabe 7
System.out.println("Anzahl der Studenten in der Datenbank: " + db.numberOfStudents());
db.addStudent("Hannes", 123456, "Wi-Inf", 27);
System.out.println("Anzahl der Studenten in der Datenbank, nachdem Hannes wieder hinzugefügt wurde: " + db.numberOfStudents());

//Aufgabe 8
System.out.println("Durchschnittsalter: " + db.averageAge());
}

}
</nowiki>

== Kommentare ==
Wenn du Anmerkungen zur Aufgabe hast oder Lob und Kritik loswerden möchtest, ist hier die richtige Stelle dafür. Klicke einfach ganz rechts auf "bearbeiten" und schreibe deinen Kommentar direkt ins Wiki. Keine Scheu, es geht nichts kaputt ;)

Javakurs/Übungsaufgaben/Textwordcount/Musterloesung

2012-03-07T13:34:07Z

141.23.110.8: Musterlösung

'''Hinweis:''' Die Musterlösung kann von eurer Lösung abweichen, da es immer mehrere Varianten gibt ein Problem zu lösen. Im Zweifelsfall Fragt einen Tutor.

== Lösung ==
<nowiki>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

/**
*
* @author Jonas
*
*/
public class TextWordCount {

public static void main(String[] args) {
String filename = "<your file name here>";

String[] fileContent = EasyFileAccess.getFileContent(filename);

// Eine Hashmap speichert Schlüssel-Wert-Paare. Hier wird für jedes Wort
// gespeichert, wie oft es verwendet wurde.
Map<String, Integer> words = new HashMap<String, Integer>();

int totalWordCount = 0;

for (String line : fileContent) {

totalWordCount += line.split(" ").length;

for (String word : line.split(" ")) {

if (words.containsKey(word)) {
// Das Wort ist bereits in der Hashmap enthalten, der gerade
// hinterlegte Wert wird um eins erhöht und wieder in die
// Hashmap geschrieben.
words.put(word, words.get(word) + 1);
} else {
// Das Wort befindet sich noch nicht in der Hashmap und wird
// neu hinzugefügt.
words.put(word, 1);
}

}
}

System.out.println("Wortanzahl: " + totalWordCount);

// Um nun die am häufigsten verwendeten Wörter zu ermitteln, muss etwas
// getrickst werden. Klar ist, dass nach der Verwendungsanzahl
// absteigend sortiert werden muss. Dies lässt sich mit einer Hashmap
// allerdings nicht realisieren, da die Schlüssel-Wert-Paare unsortiert
// gespeichert werden.
// Deswegen wird an dieser Stelle eine Liste von Schlüssel-Wert-Paaren
// angelegt, die im nächsten Schritt sortiert wird.

List<Entry<String, Integer>> sortedList = new ArrayList<Entry<String, Integer>>(
words.entrySet());

// Sortiert wird mit einer Hilfsmethode aus der API. Dieser Methode kann ein "Comparator" übergeben werden, der zwei Objekte aus der Liste vergleicht.

Collections.sort(sortedList, new Comparator<Entry<String, Integer>>() {
@Override
public int compare(Entry<String, Integer> o1,
Entry<String, Integer> o2) {
//Negatives Vorzeichen deswegen, da absteigend sortiert werden soll.
return -o1.getValue().compareTo(o2.getValue());
}
});

System.out.println("Am häufigsten verwendete Wörter: ");
//Math.min für den Fall, dass weniger als 20 unterschiedliche Wörter verwendet wurden.
for (int i = 0; i < Math.min(20, sortedList.size()); i++) {
Entry<String, Integer> entry = sortedList.get(i);
System.out.println(entry.getKey() + " (" + entry.getValue()
+ " mal)");
}

System.out.println("Insgesamt wurden " + words.size()
+ " unterschiedliche Wörter verwendet.");
}

}
</nowiki>

== Kommentare ==
Wenn du Anmerkungen zur Aufgabe hast oder Lob und Kritik loswerden möchtest, ist hier die richtige Stelle dafür. Klicke einfach ganz rechts auf "bearbeiten" und schreibe deinen Kommentar direkt ins Wiki. Keine Scheu, es geht nichts kaputt ;)

Javakurs/Übungsaufgaben/Canvas/Musterloesung

2012-03-07T12:58:09Z

141.23.110.8: Musterlösung für Canvas

'''Hinweis:''' Die Musterlösung kann von eurer Lösung abweichen, da es immer mehrere Varianten gibt ein Problem zu lösen. Im Zweifelsfall Fragt einen Tutor.

== Lösung: Point3D.java ==
<nowiki>
public class Point3D {

private double x, y, z;

public Point3D(double x, double y, double z) {
this.x = x;
this.y = y;
this.z = z;
}

@Override
public String toString() {
return "(" + x + ", " + y + ", " + z + ")";
}

public void changeCoordinates(double newX, double newY, double newZ) {
this.x = newX;
this.y = newY;
this.z = newZ;
}

public double calcDistance(Point3D other) {
return Math.sqrt(Math.pow(other.x - this.x, 2) + Math.pow(other.y - this.y, 2) + Math.pow(other.z - this.z, 2));
}
}
</nowiki>

== Lösung: Sphere.java ==
<nowiki>
public class Sphere {

private Point3D orign;

private double radius;

public Sphere(Point3D orign, double radius) {
super();
this.orign = orign;
this.radius = radius;
}

public void changeOrign(Point3D newOrign) {
this.orign = newOrign;
}

public void changeRadius(double newRadius) {
this.radius = newRadius;
}

@Override
public String toString() {
return "Sphere(orign: " + orign.toString() + ", radius: " + radius
+ ")";
}

public double calcVolume() {
return (4.0 / 3.0) * Math.PI * Math.pow(radius, 3);
}

public double calcSurfaceArea() {
return 4.0 * Math.PI * Math.pow(radius, 2);
}
}
</nowiki>

== Lösung: Canvas.java ==
<nowiki>
import java.util.Arrays;

/**
* Klasse für die Zeichenoberfläche inklusive Einstiegspunkt in das Programm.
* @author Jonas
*
*/
public class Canvas {

private Point3D[] points;
private Sphere[] spheres;

private int sphereCount;
private int pointCount;

public Canvas() {
points = new Point3D[3];
spheres = new Sphere[3];
sphereCount = 0;
pointCount = 0;
}

/**
* Fügt einen neuen Punkt zu dieser Zeichenoberfläche hinzu. Erweitert wenn
* nötig das Array.
*/
public void addPoint3D(Point3D point) {
points[pointCount] = point;
pointCount++;

if (pointCount >= points.length) {
// Das Array ist voll.
// Da in Java die Länge eines Arrays nicht mehr nachträglich
// geändert werden kann, wird pohier eine Hilfsfunktion aus der Java
// API benutzt, um eine größere Kopie dieses Arrays zu erzeugen.

// In addSphere eine alternative Implementierung.
points = Arrays.copyOf(points, points.length + 3);
}
}

/**
* Fügt eine neue Kugel zu dieser Zeichenoberfläche hinzu. Erweitert wenn
* nötig das Array.
*/
public void addSphere(Sphere sphere) {
spheres[sphereCount] = sphere;
sphereCount++;

if (sphereCount >= spheres.length) {
// Das Array ist voll.
Sphere[] newSpheres = new Sphere[spheres.length + 3];
for (int i = 0; i < spheres.length; i++) {
newSpheres[i] = spheres[i];
}

spheres = newSpheres;
}
}

/**
* Berechnet das Gesamtvolumen aller Kugeln dieser Zeichenoberfläche.
*/
public double calcTotalVolume() {
double result = 0;
for (int i = 0; i < spheres.length; i++) {
if (spheres[i] != null) {
result += spheres[i].calcVolume();
}
}
return result;
}

/**
* Berechnet die Gesamtoberfläche aller Kugeln dieser Zeichenoberfläche.
*
* @return
*/
public double calcTotalSurfaceArea() {
double result = 0;
for (int i = 0; i < spheres.length; i++) {
if (spheres[i] != null) {
result += spheres[i].calcSurfaceArea();
}
}
return result;
}

@Override
public String toString() {
String result = "";
for (int i = 0; i < points.length; i++) {
// Wenn ein Array initialisiert wird, werden alle Felder mit null
// belegt. Deswegen an dieser Stelle die Überprüfung, ob im Array an
// der Stelle i ein Element abgelegt ist.
if (points[i] != null) {
result += points[i].toString() + "\n";
}
}
// Eine andere Form von for-Schleife zur Iteration über ein Array
// Wird wie folgt gelesen:
// Für jede Sphere s aus dem Array spheres...
for (Sphere s : spheres) {
if (s != null) {
// füge sie der String-Repräsentation hinzu.
result += s.toString() + "\n";
}
}
return result;
}

/**
* Einstiegspunkt in das Programm
*/
public static void main(String[] args) {
System.out.println("Erzeuge einen neuen Punkt...");
Point3D p1 = new Point3D(3, 7, 3);
System.out.println("Neuer Punkt p1: " + p1.toString());
System.out.println("Die Koordinaten werden nun geändert");
p1.changeCoordinates(2, 1, 2);
System.out.println("Geänderter Punkt p1: " + p1.toString());
System.out.println("Erzeue einen zweiten Punkt...");
Point3D p2 = new Point3D(2, 2, 3);
System.out.println("Neuer Punkt p2: " + p2.toString());
System.out
.println("Distanz zwischen p1 und p2: " + p1.calcDistance(p2));
System.out.println("Erzeuge eine neue Kugel...");
Sphere s1 = new Sphere(p1, 2);
System.out.println("Neue Kugel s1: " + s1.toString());
System.out.println("Oberfläche der Kugel: " + s1.calcSurfaceArea());
System.out.println("Volumen der Kugel: " + s1.calcVolume());

System.out.println("Erzeuge eine neue Zeichenoberfläche...");
Canvas c = new Canvas();
System.out.println("Füge 4 Punkte der Zeichenoberfläche hinzu...");
c.addPoint3D(p1);
c.addPoint3D(p2);
c.addPoint3D(new Point3D(1, 2, 3));
c.addPoint3D(new Point3D(4, 9, -2));
System.out.println("Aktueller Inhalt der Zeichenoberfläche:");
System.out.println(c.toString());

System.out.println("Füge s1 viermal zur Zeichenoberfläche hinzu...");
c.addSphere(s1);
c.addSphere(s1);
c.addSphere(s1);
c.addSphere(s1);
System.out.println("Gesamtoberfläche der Zeichenoberfläche: "
+ c.calcTotalSurfaceArea());
System.out.println("Gesamtvolumen der Zeichenoberfläche: "
+ c.calcTotalVolume());
}
}
</nowiki>

== Kommentare ==
Wenn du Anmerkungen zur Aufgabe hast oder Lob und Kritik loswerden möchtest, ist hier die richtige Stelle dafür. Klicke einfach ganz rechts auf "bearbeiten" und schreibe deinen Kommentar direkt ins Wiki. Keine Scheu, es geht nichts kaputt ;)