# indiziert-sequentiell organisierte Datei (Arbeitsspeicher)



## wayfinder (10. Jan 2005)

Hallouuu!!

Ich bräuchte dringende Hilfe bei einem Projekt.

Ich soll eine indiziert-sequentiell organisierte Datei mit verkettetem Index implementieren. Die Datei soll beliebig viele Sätze eines beliebigen, von mir zu definierenden strukturierten oder simplen Typs umfassen können; Methoden zum Einfügen eines Satzes, zum Suchen und Ausgeben eines Satzes, zum Ändern eines Satzes und zum Löschen eines Satzs sowie zum Ausgeben aller Sätze sind zu entwickeln.
Ich soll dazu eine Klasse, in der von mir gewählter strukturierter Datentyp als Elemttyp der "Datei" definiert wird. Fehlerfälle sind durch selbstdefinierte Ausnahmen abzufange.

Hat vielleicht irgendwer eine Ahnung wie ich das angehen soll???
Ich hab leider keine...

Bitte HILFE !!!

wayfinder


----------



## KSG9|sebastian (10. Jan 2005)

Also, irgendwie sieht das stark dannach aus als hättest du das Ding nur abgeschrieben, oder ?

Wenn ich das ganze richtig verstanden hab sollst du eine Datei erstellen die Sätze enthält und dazu noch eine Index-Nummer.
So, z.b.

datei.txt



> 1. Satz 1
> 2. Satz 2



Dann machst du dir mal ne Klassen, von mir aus DateiVerwaltung
und fänst an Methoden zu implementieren


```
public class Datei{
   private String pfad;
   public static int index=0;
   public Datei(String pfad){
      this.pfad = pfad;
      //Hier könntest du noch die Datei zum lesen und schreiben
      //Von mir aus mit nem RandomAccessFile   
   }
   public void setSatz(String s){
       if(!"".equals(s)){
          Datei.index++;
          //Hier fügst du den Satz ein mit der Indexnr. davor
       }  
   }
   public String getSatz(int index){
       //Hier durchläufst du die komplette Datei mit ner schleife
       //und überprüfst wann der index stimmt, dann gibst du den
       //Satz zurück
      return satz;
   }
   public String getAll(){
      //Wiederum das ganze File durchlaufen und den Inhalt an  
      //eine bestehen Variable dranhängen
      return alle_saetze;
   }
   public String sucheSatz(String search){
     //Komplette Datei durchlaufen und mit .equals überprüfen ob
     //es eine übereinstimmung gibt
    return search_result;
   } 
   public void delSatz(int index){
     //Komplette Datei durchlaufen, index herausfinden und 
     //löschen
  }
}
```

So, ich hoff mal das ich das ganze richtig verstanden h ab 
Und jetzt mach dir selber mal gedanken


----------



## wayfinder (10. Jan 2005)

naja, selber gedanken machen is gut (ja ich habs abgeschrieben da ich bahnhof verstehe)... :'(

stell dir vor du hast grade mal ahnung wie man java installiert und du sollst sowas machen. ich verzweifle...
aber naja, ich probiere immerstets...

danke erst mal für die antwort

es sollte keine datei .txt ausgegeben werden, sondern das ganze nur im arbeitsspeicher implementiert werden. das ganze sollen wir im bluej implementieren und nur über dieses vorführen (mit methodenaufrufen)


----------



## KSG9|sebastian (10. Jan 2005)

erstell dir ne klasse Wort, implementier die methoden getSatz, addSatz, searchSatz, delSatz

erstell dir ne klasse Verwaltung die nen Array/Vector vom Typ Wort enthält

erstell die die nötigen felder in der klasse Wort
text, index u.s.w.


----------



## wayfinder (11. Jan 2005)

Ich habe mal folgendes implementiert....
Das einzige das noch nicht passt, ist irgendwie das löschen und dass es sich um keinen verketteten Index handelt...
(beim verketteten Index hält jeder Knoten einen Schlüssel und die Adresse des dazugehörigen Satzes)


```
import java.util.ArrayList;

/**
 * Diese Klasse stellt das Modell einer indiziert-organisierten Datei 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.
 * Zur einfacheren Handhabung wurde ein Satz mit dem primitiven Datentyp String gewählt.
 * 
 * @author Daniel Pernold
 * @version 3.0
 */
public class Datei
{
    // Instanzvariablen
    private ArrayList datei;
    private int nummer;

    /**
     * Konstruktor für Objekte der Klasse DateiVerwaltung
     */
    public Datei()
    {
        // Instanzvariable initialisieren
        datei = new ArrayList();
        int nummer = 0;
    }

    /**
     * Methode zum Einfügen eines Satzes in das Array
     * 
     * @param  index    der Indexwert des Satzes im Array
     * @param  inhalt   der Satz zum dazugehörigen Indexwert
     */
    public void satzEinfuegen(String inhalt)
    {
        // Für den Fall, dass die satzLoeschen Methode den Wert der nummer Variablen
        // beim löschen nicht verringert
        if(datei.size() < nummer)
        {
            System.out.println("Hier ist etwas schief gegangen");
            System.out.println("-------------------------------------");
        }
        // Wenn alles richtig läuft, füge den Satz hinzu
        else
        {
        datei.add(nummer, inhalt);
        nummer++;
        }
    }
    
    /**
     * Methode zum Ausgeben eines Satzes
     * 
     * @param  index    der Indexwert des Satzes im Array den man ausgeben will
     */
    public void satzAusgeben(int index)
    {
        // Falls die ArrayList nicht leer ist
        if(!datei.isEmpty())
        {
            // Falls man einen Index eingibt der noch nicht existiert
            if(index >= datei.size())
            {
                System.out.println("Dieser Index ist noch nicht vorhanden");
                System.out.println("-------------------------------------");
            }
            else
            {
                System.out.println(index + ": " + datei.get(index));
                System.out.println("-------------------------------------");
            }
        }
        // Falls die ArrayList leer ist
        else
        {
            System.out.println("Die Datei hat keinen Satz gespeichert");
            System.out.println("-------------------------------------");
        }
    }
    
    /**
     * Methode zum Ändern eines Satzes
     * 
     * @param  index    der Indexwert des Satzes im Array der geändert werden soll
     * @param  inhalt   der zu Ändernde Inhalt im Satz
     */
    public void satzAendern(int index, String inhalt)
    {
        // Falls die ArrayList nicht leer ist
        if(!datei.isEmpty())
        {
            // Falls man einen Index eingibt der noch nicht existiert
            if(index >= datei.size())
            {
                System.out.println("Dieser Index ist noch nicht vorhanden");
                System.out.println("-------------------------------------");
            }
            else
            {
                datei.set(index, inhalt);
                System.out.println("Der Satz mit dem Index " + index + " wurde");
                System.out.println("erfolgreich auf den Wert " + inhalt + " geändert");
                System.out.println("-------------------------------------");
            }
        }
        // Falls die ArrayList leer ist
        else
        {
            System.out.println("Die Datei hat keinen Satz gespeichert");
            System.out.println("-------------------------------------");
        }
    }
    
    /**
     * Methode zum Löschen eines Satzes
     * wird ein Satz gelöscht verschiebt sich der Index der nachfolgenden Sätze
     * 
     * @param  index    der Indexwert des Satzes im Array der gelöscht werden soll
     */
    public void satzLoeschen(int index)
    {
        // Falls die ArrayList nicht leer ist, lösche den Satz und verringere nummer um 1
        if(!datei.isEmpty())
        {
            // Falls man einen Index eingibt der noch nicht existiert
            if(index >= datei.size())
            {
                System.out.println("Dieser Index ist noch nicht vorhanden");
                System.out.println("-------------------------------------");
            }
            else
            {
                datei.remove(index);
                nummer--;
                System.out.println("Der Satz mit dem Index " + index + " wurde erfolgreich gelöscht");
                System.out.println("-------------------------------------");
            }
        }
        // Falls die ArrayList leer ist
        else
        {
            System.out.println("Die Datei hat keinen Satz gespeichert");
            System.out.println("-------------------------------------");
        }
    }
    
    /**
     * Methode zum Ausgeben aller Sätze
     */
    public void alleSaetzeAusgeben()
    {
        // Falls die ArrayList nicht leer ist
        if(!datei.isEmpty())
        {
            for(int index = 0; index < datei.size(); index++)
            {
                System.out.println(index + ": " + datei.get(index));
            }
            System.out.println("-------------------------------------");
        }
        // Falls die ArrayList leer ist
        else
        {
            System.out.println("Die Datei hat keinen Satz gespeichert");
            System.out.println("-------------------------------------");
        }
    }
    
    /**
     * Methode zum sequentiellen Suchen eines Satzes
     */
    public void satzSuchen(String wert)
    {
        // Falls die ArrayList nicht leer ist
        if(!datei.isEmpty())
        {
            boolean gefunden = false;
            for(int index = 0; index < datei.size(); index++)
            {
                if(datei.get(index).equals(wert))
                {
                    System.out.println("Gefunden!");
                    System.out.println(index + ": " + datei.get(index));
                    System.out.println("-------------------------------------");
                    gefunden = true;
                }
            }
            if(gefunden == false)
            {
                System.out.println("Nichts Gefunden!");
                System.out.println("-------------------------------------");
            }
        }
        // Falls die ArrayList leer ist
        else
        {
            System.out.println("Die Datei hat keinen Satz gespeichert");
            System.out.println("-------------------------------------");
        }
    }
    
    /**
     * Methode zum Löschen aller Sätze
     */
    public void alleSaetzeLoeschen()
    {
        datei.removeAll(datei);
    }
}
```

Bitte um HILFE, es soll doch verkettet sein !!
greetz

wayfinder


----------



## wayfinder (11. Jan 2005)

Korrigierte:

verketteter Index: Jeder Knoten enthält einen Schlüssel und die Adresse des dazugehörigen Satzes und einen Zeiger auf den nächsten Satz !!


----------



## bellmann29 (11. Jan 2005)

Ich glaube, ich habe es hinbekommen.


```
/*
 * Created on 11.01.2005
 *
 */
package com.yourname.datei;

/**
 * @author bello
 *
 */
public interface Datei {
	
	public void addSatz(String satz);
	
	public void writeSatz(int index);
	
	public void aendereSatz(int index, String satz);
	
	public void deleteSatz(int index);
	
	public void printSaetze();
	
	public void searchSatz(String satz);
	
	public void clear();

}

/*
 * Created on 11.01.2005
 *
 */
package com.yourname.datei;

import java.util.Iterator;
import java.util.NoSuchElementException;

/**
 * @author bello
 *
 */
public class DateiImpl implements Datei{
	
	private ElementWrapper first;
	private ElementWrapper last;
	private int count;
	
	public DateiImpl(){
		first = last = null;
		count = 0;
	}

	public void addSatz(String satz) {
		if(count == 0){
			first = new ElementWrapper();
			last = first;
			count = 1;
		}else{
			last.next = new ElementWrapper();
			last = last.next;
			++count;
		}
		last.id = count;
		last.element = satz;
		last.next = null;
	}
	
	public void aendereSatz(int index, String satz) {
		boolean success = false;
		Iterator iter = this.iterator();
		while(iter.hasNext()){
			ElementWrapper ew = (ElementWrapper)iter.next();
			if(ew.id == index){
				ew.element = satz;
				success = true;
			}
		}
		if(success){
			System.out.println("Erfolgreich geaendert");
		}else{
			System.out.println("Satz not found");
		}
	}
	public void clear() {
		while(first != null){
			ElementWrapper tmp = first;
			first = first.next;
			tmp.next = null;
		}
		first = last = null;
		count = 0;

	}
	public void deleteSatz(int index) {
		ElementWrapper before = null;
		boolean success = false;
		Iterator iter = this.iterator();
		while(iter.hasNext()){
			ElementWrapper  s = (ElementWrapper)iter.next();
			if(s.id == index){
				if(before != null){
					before.next = s.next;
					s = null;
				}else{
					first = s.next;
					s = null;
				}
				success = true;
				System.out.println("Satz deleted with id: " + index);
			}
			if(!success)before = s;
		}
		if(!success)System.out.println("Satz not found with index " + index);
	}
	
	public void printSaetze() {
		boolean success = false;
		Iterator iter = this.iterator();
		while(iter.hasNext()){
			ElementWrapper  s = (ElementWrapper)iter.next();
			System.out.println("Satz mit id: " + s.id + " : " + s.element);
			success = true;
		}
		if(!success)System.out.println("Nothing found to print");

	}
	
	public void searchSatz(String satz) {
		boolean success = false;
		Iterator iter = this.iterator();
		while(iter.hasNext()){
			ElementWrapper  s = (ElementWrapper)iter.next();
			if(s.element.equals(satz)){
			System.out.println("Satz found: " +  (String)s.element);
			success = true;
			}
		}
		if(!success)System.out.println("Satz not found " + satz);		

	}
	
	public void writeSatz(int index) {
		boolean success = false;
		Iterator iter = this.iterator();
		while(iter.hasNext()){
			ElementWrapper  s = (ElementWrapper)iter.next();
			if(s.id == index){
			System.out.println("Satz found: " +  (String)s.element);
			success = true;
			}
		}
		if(!success)System.out.println("Satz not found with index " + index);		

	}
	
	private Iterator iterator(){
		return new Iterator(){
			ElementWrapper tmp = first;
			public boolean hasNext(){
				return tmp != null;
			}
			public Object next(){
				if(tmp == null){
					throw new NoSuchElementException();
				}
				Object ret = tmp;
				tmp = tmp.next;
				return ret;
			}
			public void remove(){
				throw new UnsupportedOperationException();
			}
		};
	}
	
	class ElementWrapper{
		int id;
		public Object element;
		public ElementWrapper next;
	}
}

/*
 * Created on 11.01.2005
 *
 */
package com.yourname.datei;

/**
 * @author bello
 *
 */
public class TestClass {

	public static void main(String[] args) {
		Datei di = new DateiImpl();
		String ersterSatz = "erster Satz";
		String zweiterSatz = "zweiter Satz";
		String dritterSatz = "dritter Satz";
		di.addSatz(ersterSatz);
		di.addSatz(zweiterSatz);
		di.addSatz(dritterSatz);
		di.printSaetze();
		di.searchSatz(ersterSatz);
		di.searchSatz("anderer Satz");
		di.writeSatz(1);
		di.writeSatz(10);
		di.deleteSatz(2);
		di.printSaetze();
		System.exit(0);
	}
}
```

Bei mir hat es funktioniert und ich glaube es klappt auch bei Dir.

Viel Spaß beim Vorzeigen.


----------



## wayfinder (13. Jan 2005)

@zweiten eintrag zu diesem thema (nicht in diesem thread): seid doch nicht so grauslich zueinander, gibts ja net. wo bleibt die nettiquette???

also ich hab den code dazu, wie er es ungefähr wollte, aber es war die aufgabenstellung eine verkette liste, die nach dem schlüssel sortiert, nicht nach dem index. das war das manko meiner note


----------



## wayfinder (13. Jan 2005)

hier der code, vielleicht könnte ihn ja jemand so umschreiben, dass es die aufgabenstellung endgültig erfüllt.


```
/**
 * 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("");
    }
}
```


----------

