/**
* Diese Klasse stellt das Modell einer indiziert-organisierten Dateiverwaltung mit verkettetem
* Index dar. Die Datei umfasst beliebig viele Sätze eines beliebigen zu definierenden
* strukturierten oder simplen Typs.
* Methoden zum Einfügen, Suchen, Ausgeben, Ändern, Löschen eines Satzes sowie zum Ausgeben aller
* Sätze sind implementiert.
*
* @author Daniel Pernold
* @version 5.0
*/
public class DateiVerwaltung
{
// Initialisiere folgende Datenfelder.
private Festplatte Laufwerk;
private Eintrag[] Dateien;
private Eintrag Erster, Letzter;
/**
* Dieser Konstruktor übergibt eine neue Instanz der Klasse Festplatte der Variable Laufwerk.
* Er erstellt ein Array der Größe der Variable FESTPLATTENGROESSE und übergibt dieses der
* Variable Dateien.
* Die Pointer Erster und Letzter werden auf "null" gesetzt, da sie zu
* Beginn auf kein Objekt zeigen sollen (Ausgangsstatus).
*/
public DateiVerwaltung()
{
Laufwerk = new Festplatte();
Dateien = new Eintrag[Laufwerk.FESTPLATTENGROESSE];
Erster = Letzter = null;
}
/**
* Methode, die einen Eintrag in der DateiVerwaltung mit einem
* bestimmten Schlüssel des Typs String sucht.
*
* Details: Mittels einer for-Schleife werden die Einträge solange sequentiell
* durchsucht, bis der passende Eintrag gefunden wird. Werden mehrere
* Einträge gefunden, werden alle gefundenen zurückgegeben.
*
* @param _schluessel Der Schlüssel des Eintrages den man sucht.
* @return Den Eintrag, den die Suche ergibt.
*/
private Eintrag find(String _schluessel)
{
for (int i=0; i < Laufwerk.FESTPLATTENGROESSE; i++)
{
if (Dateien[i] != null && Dateien[i].schluessel().equals(_schluessel))
{
return Dateien[i];
}
}
return null;
}
/**
* Methode, die mittels der gefundenen Einträge die dazugehörigen Sätze retourniert.
*
* @param _schluessel Der Schlüssel des Satzes den man sucht.
* @return Den Satz, die die Suche ergibt.
*/
public Satz search(String _schluessel)
{
Eintrag en = find(_schluessel);
if(en != null)
{
return Laufwerk.get(en.addresse());
}
else
{
return null;
}
}
/**
* Methode, die einen Satz auf der Festplatte über einen Eintrag speichert.
*
* @param _schluessel Der Schlüssel.
* @param _name Der Name.
* @param _alter Das Alter.
* @param _email Die E-Mail-Adresse.
* @return true wenn der Eintrag erfolgreich war, false falls nicht.
*/
public boolean add(String _schluessel, String _name, int _alter, String _email)
{
// Prüfen ob der eingegebene Schlüssel bereits existiert.
if (find(_schluessel) != null)
{
System.out.println("Der Schluessel " + _schluessel + " existiert bereits");
return false;
}
// Erstelle einen neuen Satz.
Satz satz = new Satz(_name, _alter, _email);
int addresse = Laufwerk.add(satz);
if (addresse == -1) return false;
// Suche in der DateiVerwaltung einen Freien Platz für einen Eintrag.
int i = 0;
while (Dateien[i] != null)
{
i++;
}
// Füge einen Eintrag in den gefundenen freien Platz ein.
Dateien[i] = new Eintrag(_schluessel, addresse, null, Letzter);
// Falls es der erste Eintrag ist.
if (Erster == null) {
Erster = Letzter = Dateien[i];
}
// Falls es nicht der erste Eintrag ist, mache den letzten Eintrag zum vorletzten Eintrag.
else
{
Letzter.next(Dateien[i]);
Letzter = Dateien[i];
}
return true;
}
/**
* Methode zum Löschen Eines Satzes auf der Festplatte.
*
* @param _schluessel Der Schlüssel.
* @return true wenn das Löschen erfolgreich war, false wenn nicht.
*/
public boolean remove(String _schluessel)
{
Eintrag en = null;
int i;
// Durchlaufe die Einträge so lange, bis der zu löschende Eintrag gefunden wurde.
for (i=0; i < Laufwerk.FESTPLATTENGROESSE; i++)
{
if (Dateien[i] != null && Dateien[i].schluessel().equals(_schluessel))
{
en = Dateien[i];
break;
}
}
// Wenn der Eintrag nicht gefunden wurde.
if (en == null)
{
System.out.println("Kann keinen Satz mit " + _schluessel + " finden");
return false;
}
// Falls der Eintrag gefunden wurde, lösche diesen, in dem man den Eintrag "null" übergiebt.
Laufwerk.remove(en.addresse());
Dateien[i] = null;
// Falls der Eintrag nicht der Erste ist, lasse den ursprünglich vorherigen Eintrag auf
// den ursprünglich nächsten zeigen.
if (en != Erster)
{
en.prev().next(en.next());
}
// Falls der Eintrag der Erste ist, mache den ursprünglich nächsten Eintrag zum Ersten.
else
{
Erster = en.next();
}
// Deto wie (en != Erster), nur umgekehrt.
if (en != Letzter)
{
en.next().prev(en.prev());
}
// Deto wie (en = Erster), nur umgekehrt.
else
{
Letzter = en.prev();
}
return true;
}
/**
* Methode, die zum Schlüssel den dazugehörigen Eintrag und somit den Satz ausgibt.
*
* @param _schluessel Der Schlüssel.
* @return true falls der Eintrag überhaupt gefunden wurde, false falls nicht.
*/
public boolean print(String _schluessel)
{
Eintrag en = find(_schluessel);
if (en != null)
{
System.out.println(Laufwerk.get(en.addresse()).toString());
return true;
}
else
{
return false;
}
}
/**
* Methode zum Ausgeben aller Einträge und der dazugehörigen Sätze.
*/
public void printAll()
{
Eintrag iter = Erster;
System.out.println("*********** DateiVerwaltung printAll() Start");
while (iter != null)
{
System.out.println(Laufwerk.get(iter.addresse()).toString());
iter = iter.next();
}
System.out.println("*********** DateiVerwaltung printAll() Ende");
}
public void musterDatenEingeben()
{
add("Schluessel_1", "Daniel Pernold", 21, "dandjo@gmx.at");
add("Schluessel_2", "Martin Holzer", 21, "hoiza@gmx.at");
add("Schluessel_3", "Christoph Krell", 21, "krell@gmx.at");
}
}
/**
* Diese Klasse verwaltet einen Eintrag in der DateiVerwaltung (Indextabelle).
*/
public class Eintrag
{
private String Schluessel;
private int Addresse;
private Eintrag Prev, Next;
/**
* Dieser Konstruktor übergibt lediglich die Parameter den definierten Datenfeldern.
*
* @param _schluessel Der Schluessel für diesen Eintrag.
* @param _adresse Der Index (die Adresse) auf der Festplatte für einen Satz (Pointer auf einen Satz).
* @param _next Pointer auf den nächsten Eintrag.
* @param _prev Pointer auf den vorherigen Eintrag.
*/
public Eintrag(String _schluessel, int _addresse, Eintrag _next, Eintrag _prev)
{
Schluessel = _schluessel;
Addresse = _addresse;
Next = _next;
Prev = _prev;
}
/**
* Methode zum retournieren des Schlüssels.
*
* @return Den Schlüssel.
*/
public String schluessel()
{
return Schluessel;
}
/**
* Methode zum retournieren der Adresse.
*
* @return Die Adresse.
*/
public int addresse()
{
return Addresse;
}
/**
* Methode zum retournieren des nächsten Eintrages.
*
* @return Den nächsten Eintrag.
*/
public Eintrag next()
{
return Next;
}
/**
* Methode zum festzsetzen des nächsten Eintrages.
*
* @param _next Der nächste Eintrag.
*/
public void next(Eintrag _next)
{
Next = _next;
}
/**
* Methode zum retournieren des vorherigen Eintrages.
*
* @return Den vorherigen Eintrag.
*/
public Eintrag prev()
{
return Prev;
}
/**
* Methode zum festsetzen des vorherigen Eintrages.
*
* @param _prev Der vorherige Eintrag.
*/
public void prev(Eintrag _prev)
{
Prev = _prev;
}
}
/**
* Diese Klasse verwaltet Sätze und bietet Funktionalität zum Hinzufügen und Entfernen von
* diesen an (Simulation einer Festplatte mittels eines nackten Arrays).
*/
public class Festplatte
{
// Setze die Festplattenkapazität auf maximal 100 Einträge.
public final int FESTPLATTENGROESSE = 100;
// Die Variable Daten hält ein Array der Sätze.
private Satz[] Daten;
// Die Variable Groesse hält Information über die bereits gespeicherten Sätze (zu Beginn 0).
private int Groesse;
/**
* Dieser Konstruktor erstellt ein Array mit der Größe der Variable FESTPLATTENGROESSE und
* übergibt es der Variable Daten.
* Groesse wird auf 0 gesetzt.
*/
public Festplatte()
{
Daten = new Satz[FESTPLATTENGROESSE];
Groesse = 0;
}
/**
* Methode zum Hinzufügen eines Satzes.
*
* @param satz Der Satz der hinzugefügt wird.
* @return Den Index (die Adresse) auf der Festplatte (bzw. -1 im Fehlerfall)
*/
public int add(Satz satz)
{
// Prüfen ob Festplatte voll ist.
if (Groesse == FESTPLATTENGROESSE)
{
System.out.println("Die Festplatte ist voll");
return -1;
}
// Prüfen ob ein Objekt übergeben wurde das null ist.
if (satz == null) {
System.out.println("Kein gueltiger Satz");
return -1;
}
// Prüfen ob ein Festplattenplatz belegt ist, bis ein freier Platz gefunden wird...
int i = 0;
while (Daten[i] != null)
{
i++;
}
// ...dann füge den Satz hinzu.
Daten[i] = satz;
// Erhöhe die Größe der bereits gespeicherten Sätze um 1.
Groesse++;
// Gib den Index (die Adresse) des Satzes auf der Festplatte zurück.
return i;
}
/**
* Methode zum Retournieren eines Satzes mit dem Index (der Adresse) a
*
* @param a Der Index (die Adresse) auf der Festplatte
* @return Den Satz mit dem Index (der Adresse) a
*/
public Satz get(int a)
{
// Prüfen ob der Index kleiner ist als 0 oder größer als die Festplattenkapazität.
if (a < 0 || a >= FESTPLATTENGROESSE)
{
System.out.println("Festplatte: Address out of Range");
return null;
}
return Daten[a];
}
/**
* Methode zum Löschen eines Satzes mit dem Index (der Adresse) a
*
* @param a Der Index (die Adresse) auf der Festplatte.
* @return true wenn Löschen erfolgreich war, false wenn nicht.
*/
public boolean remove(int a)
{
// Prüfen ob der Index kleiner ist als 0 oder größer als die Festplattenkapazität.
if (a < 0 || a >= FESTPLATTENGROESSE)
{
System.out.println("Festplatte: Address out of Range");
return false;
}
// Prüfen ob es einen Satz mit dem Index (der Adresse) a überhaupt existiert.
if (Daten[a] == null) {
System.out.println("Festplatte: Es gibt keinen Satz mit der Adresse " + a);
return false;
}
// Setze den Satz mit dem Index (der Adresse) a auf null.
Daten[a] = null;
// Verringere die Größe der bereits gespeicherten Sätze um 1.
Groesse--;
// Retourniere dass die Operation erfolgreich war.
return true;
}
}
/**
* Diese Klasse verwaltet einen Satz (simuliert gespeicherte Informationen des Users auf einer
* Festplatte).
*/
public class Satz
{
// Initialisiere Variablen zur speicherung eines Namens, des Alters und einer E-Mail-Adresse
// für einen Satz (einen Eintrag).
private String Name;
private int Alter;
private String EMail;
/**
* Dieser Konstruktor übergibt lediglich die Parameter den definierten Datenfeldern.
*
* @param _name Der Name.
* @param _alter Das Alter.
* @param _email Die E-Mail-Adresse.
*/
public Satz(String _name, int _alter, String _email)
{
Name = _name;
Alter = _alter;
EMail = _email;
}
/**
* Methode zum retournieren des Namens.
*
* @return Den Namen.
*/
public String name()
{
return Name;
}
/**
* Methode zum retournieren des Alters.
*
* @return Das Alter.
*/
public int alter()
{
return Alter;
}
/**
* Methode zum retournieren der E-Mail-Adresse.
*
* @return Die E-Mail-Adresse.
*/
public String email()
{
return EMail;
}
/**
* Methode zum Retournieren der Satz-Daten als String.
*
* @return Den String der Satz-Daten.
*/
public String toString()
{
return Name + " " + Alter + " " + EMail;
}
}
/**
* Diese Klasse testet die Funktionalität aller Klassen dieses Projektes.
*/
public class Test
{
/**
* Methode zum vereinfachen des Statements "System.out.println();"
*
* @param str Die auszugebende Information.
*/
public static void pl(String str)
{
System.out.println(str);
}
/**
* Die eigentliche Test-Methode zum Ausführen.
*/
public static void main(String[] args)
{
DateiVerwaltung fs = new DateiVerwaltung();
pl("");
pl("-----------------------------------------------------------------");
pl("Hinzufuegen von: 'Schluessel_1', 'Daniel Pernold', 21, 'dandjo@gmx.at'");
pl("func returns: " + fs.add("Schluessel_1", "Daniel Pernold", 21, "dandjo@gmx.at"));
pl("Hinzufuegen von: 'Schluessel_2', 'Martin Holzer', 21, 'hoiza@gmx.at'");
pl("func returns: " + fs.add("Schluessel_2", "Martin Holzer", 21, "hoiza@gmx.at"));
pl("Hinzufuegen von: 'Schluessel_3', 'Christoph Krell', 21, 'krell@gmx.at'");
pl("func returns: " + fs.add("Schluessel_3", "Christoph Krell", 21, "krell@gmx.at"));
pl("");
fs.printAll();
pl("-----------------------------------------------------------------");
pl("");
pl("");
pl("-----------------------------------------------------------------");
pl("Hinzufuegen von: 'Schluessel_1', '', 0, ''");
pl("Funktion returns: " + fs.add("Schluessel_1", "", 0, ""));
pl("-----------------------------------------------------------------");
pl("");
pl("");
pl("-----------------------------------------------------------------");
pl("Suchen von: Satz mit 'Schluessel_2'");
Satz satz = fs.search("Schluessel_2");
if (satz == null) {
pl("Satz ist 'null'");
} else {
pl("Satz gefunden mit: " + satz.toString());
}
pl("-----------------------------------------------------------------");
pl("");
pl("");
pl("-----------------------------------------------------------------");
pl("Loeschen von: Satz mit 'Schluessel_3'");
pl("Funktion returns: " + fs.remove("Schluessel_3"));
pl("");
fs.printAll();
pl("-----------------------------------------------------------------");
pl("");
}
}
