Hallöchen,
ich hab hier zwei Klassen kommentiert und hoffe die richtig verstanden zu haben.
Wäre sehr nett, wenn ihr mal drüberschauen könntet und mir kurz sagt, ob die richtig sind.
Die dazugehörige AComplete Klasse folgendermaßen:
Die beiden Klassen realisieren einen Autocomplete.
Vielen Dank schon mal...
ich hab hier zwei Klassen kommentiert und hoffe die richtig verstanden zu haben.
Wäre sehr nett, wenn ihr mal drüberschauen könntet und mir kurz sagt, ob die richtig sind.
Code:
public class RingBuffer implements Serializable {
private String[] list;//Array zur Speicherung der eingegebenen Wörter
private int size, top = 0;
public RingBuffer() {//Konstruktor
this(4);//Größe des Arrays
}
public RingBuffer(int size) {//Konstruktor
this.size = size;//übergegebener Formalparameter size, wird Klassenvariable size zugewiesen
list = new String[size];//Initialisierung des String Arrays 'list'
for (int i = 0; i < list.length; i++) list[i] = "";//Wenn String Array leer, dann schreibe auch nichts in Array bzw. einen leeren String
}
public void Save(String file) {
try {
FileOutputStream fos = new FileOutputStream(file);//Instantiierung des FileOutputstreams fos mit Formalparameter file
//Parameter ist "buffertext.txt"
ObjectOutputStream oos = new ObjectOutputStream(fos);//Instantiierung des ObjectOutputStreams oos, mit Formalparameter fos. //Object, in dem Fall der FileOutputStream wird in DAtei geschrieben.
oos.writeObject(this);//Befehl zum Schreiben
oos.close();//Schließen des ObjectOutputStreams
fos.close();//Schließen des FileOutputStreams
} catch (Exception exc) {}//Auffangen und gleichzeitiges Ignorieren der Exception
}
public static RingBuffer Load(String file) {//Load Methode zur Laden des Inhalts der buffersave.txt in den InputStream
try {
FileInputStream fis = new FileInputStream(file);//Instantiierung des FileInputstreams fis mit Formalparameter file//Parameter ist "buffertext.txt"
ObjectInputStream ois = new ObjectInputStream(fis);//Instantiierung des ObjectInputStreams ois, mit Formalparameter fis. //Das Objekt, FileInputStream mit buffersave.txt als Inhalt wird in Stream geladen
RingBuffer obj = (RingBuffer)ois.readObject();//Lesen des Objekts buffersave.txt
ois.close();//Schließen des ObjectInputStreams
return obj;//Rückgabe des neuen RingBuffer Objekts an den Methodenaufruf in AComplete
} catch (Exception exc) {//Auffangen der Exception
System.out.println(exc.getMessage());//Wenn keine Datei vorhanden,
return new RingBuffer(); //Systemnachricht auf Konsole ausgeben und neuen RingBuffer erzeugen
}
}
public String toString() {//Eingabe in Textfield wird in String umgewandelt und im Textfield dargestellt
for (int i = top + 1; i < list.length; i++) {
System.out.println(list[i]);//Ausgabe des gespeicherten Strings an durch for-Schleife ermittelten Index
}
for (int i = 0; i < top; i++) {
System.out.println(list[i]);//Ausgabe des gespeicherten Strings an durch for-Schleife ermittelten Index
}
return "top:" + top; //Rückgabe an Methodenaufruf in AComplete
}
public void add(String s) {//Methoden zum "adden" an Array list
list[top] = s;//Mit Enter bestätigtes Wort wird in String Array an die Spitze gesetzt. Das Array stellt ein Stack dar
System.out.println(list[top]);//Ausgabe auf die Konsole an welcher Stelle wir im Array wir uns befinden bzw. das wievielte Element die Spitze ist
top++;//top wird erhöht. Mit jedem Hinzufügen eines Strings in das Array, wird das Array größer. Somit auch der Index von top.
if (top == list.length) top = 0;//Wenn die endgröße des arrays erreicht ist, wird das "älteste Element überschrieben. Das Setzen von top auf 0 bewirkt das
}
public String match(String input) {//Methode zum Vergleich auf Übereinstimmung der Eingabe mit einem String aus dem Array list.//Formalparameter ist input, heißt die aktuelle eingabe
if (input.length() == 0) return "";//wenn keine eingabe getätigt wurde, dann gebe auch nichts zurück
for (int i = 0; i < list.length; i++) {//Überprüfe stetig, ob
if (list[i].startsWith(input)) return list[i];//ein eingegebenes element mit einem Element übereinstimmt bzw. beginnt, ab dem Punkt meiner Eingabe immer aufs neue. //Bei Eingabe eines Buchstaben wird stetig geprüft, ob eine Element diese Buchstabenfolge beinhaltet
//Parameter wird an Variable match in AComplete zurückgegeben und in store gespeichert.
}
return "";//Standardrückgabewert ""
}
}Die dazugehörige AComplete Klasse folgendermaßen:
Code:
public class AComplete extends JFrame {
private JLabel fieldname;//Neues JTextLabel
private JTextField textfield;//Neues JTextField
RingBuffer buffer;//Instantiierung des RingBuffer Objects
String store = "";//Temp variable zum zwischenspeichern des Eingabe-Strings
String match = "";//StringVariable zum Speichern des "Treffers"
public AComplete(){
setTitle("Autocomplete");//Titel des Frames
buffer = RingBuffer.Load("buffersave.txt");//Methodenaufruf Load aus der Klasse RingBuffer
//Laden des Inhalts der buffersave.txt in den FileInputStream
System.out.println(buffer.toString());//Ausgabe des Inhalts der buffersave.txt
init();//Aufrufen von init()
setSize(400, 90);//Größe des Frames
setVisible(true);//Sichtbarkeit des Frames
}
private void init(){
fieldname = new JLabel("Eingabe");//Instantiierung eines neuen JLabel mit Name fieldname und dem String "Eingabe"
textfield = new JTextField("");//Instantiierung eines neuen JTextfields mit leerem Inhalt
setLayout(new GridLayout(2,1));//Reihenlayout, 2 Reihen, 1 Element pro Reihe
add(fieldname);//Hinzufügen des JLabels
add(textfield);//Hinzufügen des JTextfields
textfield.addKeyListener(new KeyListener(){ //Anonyme Implementierung des KeyListeners
//Leere Implementierung der restlichen KeyListener
public void keyPressed(KeyEvent e) {
textfield.setText(store);//Wenn Buchstabe eingetippt wird, wird dieser als Text mit Hilfe von setText gesetzt und in store gespeichert
System.out.println(e.getKeyChar());//Realisierung des AutoComplete, Markieren und vervollständigen der Eingabe
match = buffer.match(textfield.getText());//Aktuelle Eingabe in match gespeichert und auf Treffer untersucht
store = textfield.getText();//Zwischenspeicherung der aktuellen Eingabe in store
if (!match.equals("")) {//Wenn match nicht leer
textfield.setText(match);//Autocomplete mit Treffer
textfield.setSelectionStart(store.length());//Markierungsbeginn der autovervollständigten Restwortes
textfield.setSelectionEnd(match.length());//Markierungsende des autovervollständigten Restwortes
System.out.println("match: " + match);//Wenn match einen Treffer gefunden hat, wird dieser auf die Konsole ausgegeben
}
}
}
);
textfield.addActionListener(new ActionListener(){//Anonyme Implementierung des ActionListener
public void actionPerformed(ActionEvent b){//ActionEvent wird implementiert
buffer.add(textfield.getText());//Hinzufügen des eingebenen Wortes in das String Array "list", Enter ist erforderlich - ActionListener!
textfield.setText("");//Nach Bestätigung mit Enter Textfeld leer
store = "";//Store wird auch leer gesetzt
System.out.println(buffer.toString());//Ausgabe des Strings aus dem Array "list" in Textfield, Methode ermittelt passenden ArrayIndex mit for-Schleifen
}});
this.addWindowListener(new WindowListener(){//Anonyme Implementierung des WindowListeners
public void windowClosing(WindowEvent e) {
// TODO Auto-generated method stub
buffer.Save("buffersave.txt");//Speicherung in buffersave.txt bei Schließen des Fensters
System.exit(0);//Beenden der Streams und des GUIs
}
//Leere Implementierung restlicher WindowListener
});
}
public static void main(String[] args) {
new AComplete();//Instantiierung des Frames AComplete
}
}Die beiden Klassen realisieren einen Autocomplete.
Vielen Dank schon mal...
