Worter - Sertler.de

Worterkennung.java
14/Jan/2004
/***********************************************************************
* Module: Worterkennung.java
* Author: Saim Sert
* Created: Dienstag, 24. Dezember 2003
* Purpose: Defines the Class Worterkennung
***********************************************************************/
import java.io.IOException ;
public class Worterkennung
{
private static Liste myList = null ;
/** @param args
** @exception IOException */
public static void main(String[] args) throws IOException
{
String inFile, outFile ;
int auswahl = 0 ;
System.out.println
("\n\tDieses Programm oeffnet eine Textdatei und gibt eine sortierte Liste") ;
System.out.println
("\tder gezaehlten Woerter aus, und schreibt sie in eine neue Datei.") ;
do
{
auswahl = IO.readInt("\n\tBitte Option auswaehlen !\n\n" +
"\t\t(1) Text aus Datei einlesen\n" +
"\t\t(2) Auswertung anzeigen\n" +
"\t\t(3) Auswertung in Datei schreiben\n" +
"\t\t(0) Ende\n\n" + "\tAuswahl: ",0,3);
System.out.println("\n");
switch (auswahl)
{
case 1: read() ;
break ;
case 2:print() ;
break ;
case 3: write() ;
break ;
case 0: System.out.print("\tProgramm wird beendet - ");
break ;
default: auswahl = 6;
break ;
} ;
} while (auswahl != 0) ;
} ;
/** Liest die Quelldatei in die Liste ein */
static void read()
{
String inFile = null ;
while (inFile == null)
{
inFile = IO.readString("\n\tBitte Dateinamen eingeben - Quelle: ") ;
inFile = IO.readFile(inFile) ;
} ;
myList = new Liste(inFile) ;
} ;
/** Gibt Inhalt der Liste aus */
static void print()
{
myList.print() ;
} ;
/** Schreibt Liste in Zieldatei */
static void write()
{
boolean ok = false ;
String outFile = null ;
while (outFile == null || !ok)
{
outFile = IO.readString("\n\tBitte Dateinamen eingeben - Ziel: ") ;
ok = (!IO.isFile(outFile)) ;
if (ok)
outFile = IO.writeFile(outFile,myList.toString()) ;
} ;
} ;
} ;
1 of 1
Liste.java
14/Jan/2004
/***********************************************************************
* Module: Liste.java
* Author: Saim Sert
* Created: Dienstag, 24. Dezember 2003
* Purpose: Defines the Class Liste
***********************************************************************/
import java.util.LinkedList ;
import java.util.ListIterator ;
import java.util.StringTokenizer ;
public class Liste
{
StringTokenizer myToken ;
LinkedList myLinkedList ;
ListIterator myIterator ;
public Liste ()
{
myToken = null ;
myLinkedList = null ;
myIterator = null ;
info() ;
} ;
/** @param bufferedString - Text welches sortiert werden soll */
public Liste (String bufferedString)
{
myToken = new StringTokenizer(bufferedString) ;
init() ;
} ;
/** Gibt Benutzer- bzw. Implementierungshinweis aus */
private void info ()
{
System.out.println
("\n\tFehler !\tKonstruktoraufruf ohne Parameter nicht moeglich") ;
System.out.println
("\t\t\tKonstruktoraufruf: Liste(String bufferedString)") ;
} ;
/** Gibt Inhalt der Liste aus */
public void print ()
{
int myInt = 0 ;
char myChar = 'j' ;
myIterator = myLinkedList.listIterator() ;
while (myIterator.hasNext() && myChar == 'j')
{
System.out.println(myIterator.next()) ;
if (++myInt % 22 == 0)
{
myChar = 'x' ;
while (!(myChar == 'j'|| myChar == 'n'))
{
myChar = IO.readChar("\n\tWeiter (j/n) : ") ;
if (!(myChar == 'j'|| myChar == 'n'))
System.out.println("\tEingabefehler !") ;
else
System.out.println("\n") ;
} ;
} ;
} ;
} ;
/** Sortiert den Text in eine Liste rein */
private void init ()
{
int myInt = 0 ;
myLinkedList = new LinkedList() ;
Wort wort = null ;
while (myToken.hasMoreTokens())
{
wort = new Wort(myToken.nextToken()) ;
myInt = this.compare(wort) ;
if (myInt == -1)
{
myLinkedList.add(wort) ;
}
else if (myInt > 0)
{
myLinkedList.add((myInt-1),wort) ;
} ;
} ;
} ;
1 of 2
Liste.java
14/Jan/2004
/** Ermoeglicht das korrekte Vergleichen von Objekten */
private int compare (Wort object)
{
int position = 0 ;
int myInt = 1 ;
Wort wort = null ;
myIterator = myLinkedList.listIterator() ;
while (myIterator.hasNext())
{
wort = (Wort) (myIterator.next()) ;
myInt = object.compareToIgnoreCase(wort) ;
position++ ;
if (myInt == 0)
{
wort.increment() ;
return 0 ;
}
else if (myInt < 0)
return position ;
} ;
return -1 ;
} ;
/** Ermoeglicht die korrekte Ausgabe des Objektes */
public String toString ()
{
StringBuffer stringBuffer = new StringBuffer() ; ;
myIterator = myLinkedList.listIterator() ;
while (myIterator.hasNext())
{
stringBuffer.append(myLinkedList.get(myIterator.nextIndex()) + "\n") ;
myIterator.next() ;
} ;
return ("" + stringBuffer) ;
} ;
} ;
2 of 2
Wort.java
14/Jan/2004
/***********************************************************************
* Module: Wort.java
* Author: Saim Sert
* Created: Dienstag, 24. Dezember 2003
* Purpose: Defines the Class Wort
***********************************************************************/
public class Wort
{
private String wort ;
private int anzahl ;
public Wort ()
{
wort = null ;
anzahl = 0 ;
info() ;
} ;
/** @param bufferedString - Text aus dem ein Wort generiert wird */
public Wort (String bufferedString)
{
wort = bufferedString ;
anzahl = 1 ;
} ;
/** Gibt Benutzer- bzw. Implementierungshinweis aus */
private void info ()
{
System.out.println
("\n\tFehler !\tKonstruktoraufruf ohne Parameter nicht moeglich") ;
System.out.println
("\t\t\tKonstruktoraufruf: Wort(String bufferedString)") ;
} ;
/** @return wort - Wort*/
public String getWort ()
{
return this.wort ;
} ;
/** @param wort - Wort welches gesetzt wird */
public void setWort (String wort)
{
this.wort = wort ;
} ;
/** @return anzahl - Anzahl der Woerter */
public int getAnzahl ()
{
return this.anzahl ;
} ;
/** @param anzahl - Anzahl welches gesetzt wird */
public void setAnzahl (int anzahl)
{
this.anzahl = anzahl ;
} ;
/** Erhoeht die Anzahl um 1 */
public void increment ()
{
anzahl += 1 ;
} ;
/** Ermoeglicht das korrekte Vergleichen von Objekten */
public int compareToIgnoreCase (Wort object)
{
return this.wort.compareToIgnoreCase(object.wort) ;
} ;
/** Ermoeglicht das korrekte Vergleichen von Objekten */
public int compareTo (Wort object)
{
return this.wort.compareTo(object.wort) ;
} ;
/** Ermoeglicht das korrekte Vergleichen von Objekten */
public boolean equals (Wort object)
{
return this.wort.equals(object.wort) ;
} ;
/** Ermoeglicht die korrekte Ausgabe des Objektes */
public String toString ()
{
1 of 2
Wort.java
14/Jan/2004
return ("\t" + anzahl + " x\t" + wort) ;
} ;
} ;
2 of 2
IO.java
14/Jan/2004
/***********************************************************************
* Module: IO.java
* Author: Saim Sert
* Created: 02.12.2003 +readString +readInt +readChar
* Updated: 09.12.2003 +readIntASCII, Exceptions, import Classes
* Updated: 20.12.2003 +readFile -openFileReader
* Updated: 04.01.2004 +writeFile -openFileWriter
* Updated: 08.01.2004 +isFile
* Purpose: Defines the Class IO, Input and Output from Console and File
***********************************************************************/
import
import
import
import
import
import
java.io.BufferedReader ;
java.io.InputStreamReader ;
java.io.FileReader ;
java.io.FileWriter ;
java.io.IOException ;
java.io.FileNotFoundException ;
public class IO
{
/** @param prompt - Ausgabetext, Eingabeaufforderung
* @return String - Eingabetext von Konsole */
public static String readString(String prompt)
{
BufferedReader myStream =
new BufferedReader(new InputStreamReader(System.in)) ;
String myString = null;
if (prompt != null)
{
try
{
System.out.print(prompt);
myString = myStream.readLine() ;
}
catch (Exception e)
{
System.out.println("\tEingabefehler !
myString = null;
}
} ; //while(myString == null);
return myString ;
- " + e);
} ;
/** @param prompt - Ausgabetext, Eingabeaufforderung
* @param max - Maximal zulaessiger Wert
* @return myInt - Eingelesene Zahl */
public static int readInt(String prompt, int max)
{
int myInt = 0;
String myString = null;
do
{
myString = readString(prompt);
try
{
myInt = Integer.valueOf(myString).intValue() ;
//System.out.println(myInt);
}
catch (NumberFormatException e)
{
System.out.println("\tEingabefehler ! - Keine gueltige Zahl");
myInt = -1;
}
if (myInt <= 0 || myInt > max)
System.out.println("\tEingabefehler !");
} while(myInt <= 0 || myInt > max);
return myInt ;
} ;
/** @param prompt - Ausgabetext, Eingabeaufforderung
* @param min - Minimal zulaessiger Wert
* @param max - Maximal zulaessiger Wert
* @return myInt - Eingelesene Zahl */
public static int readInt(String prompt, int min, int max)
{
int myInt = 0;
String myString = null;
do
{
myString = readString(prompt);
try
{
myInt = Integer.valueOf(myString).intValue() ;
1 of 4
IO.java
14/Jan/2004
//System.out.println(myInt);
}
catch (NumberFormatException e)
{
System.out.println("\tEingabefehler ! - Keine gueltige Zahl");
myInt = -10000;
}
if (myInt < min || myInt > max)
System.out.println("\tEingabefehler ! - " + min + " < Zahl < " + max);
} while(myInt < min || myInt > max);
return myInt ;
} ;
/** @param prompt - Ausgabetext, Eingabeaufforderung
* @param min - Minimal zulaessiger Buchstabe als ASCII Wert
* @param max - Maximal zulaessiger Buchstabe als ASCII Wert
* @return myInt - Eingelesener Buchstabe als ASCII Wert */
public static int readIntASCII(String prompt, int min, int max)
{
int myInt = 0;
String myString = null;
do
{
myString = readString(prompt);
myString = myString.toUpperCase();
try
{
myInt = (int) myString.charAt(0);
//myInt = (int) Integer.valueOf(myString).intValue() ;
//System.out.println(myInt);
}
catch (NumberFormatException e)
{
System.out.println("\tEingabefehler ! - Kein gueltiger Buchstabe");
myInt = -10000;
}
if (myInt < min || myInt > max)
System.out.println("\tEingabefehler !");
} while(myInt < min || myInt > max);
return myInt-min+1 ;
} ;
/** @param prompt - Ausgabetext, Eingabeaufforderung
* @return myChar - Eingelesener Buchstabe */
public static char readChar(String prompt)
{
char myChar = 0;
String myString = null;
do
{
myString = readString(prompt);
try
{
myChar = myString.charAt(0) ;
}
catch (IndexOutOfBoundsException e)
{
System.out.println("\tEingabefehler !");
myChar = 0;
}
} while(myChar == 0);
return myChar;
} ;
/** @param filename - Dateiname, Quelldatei
* @return true - wenn Datei existiert */
public static boolean isFile(String filename)
{
FileReader myFile = null ;
if (filename != null)
{
try
{
myFile = new FileReader(filename) ;
System.out.println("\tSchreibfehler !
}
catch (FileNotFoundException e)
{
myFile = null ;
} ;
} ;
if (myFile == null)
return false ;
else
2 of 4
- Datei existiert bereits !") ;
IO.java
14/Jan/2004
return true ;
} ;
/** @param filename - Dateiname, Quelldatei
* @return myString - Dateiinhalt, bei Fehler null */
public static String readFile(String filename)
{
int myInt = 0 ;
String myString = null ;
StringBuffer myStringBuffer = new StringBuffer() ;
FileReader myFile = openFileReader(filename) ;
if (myFile != null)
{
try
{
while (myInt != -1 )
myStringBuffer.append((char) (myInt = myFile.read())) ;
myString = new String(myStringBuffer) ;
myFile.close() ;
}
catch (IOException e)
{
System.out.println("\tDateifehler ! - " + e) ;
}
catch (NullPointerException e)
{
System.out.println("\tDateifehler ! - " + e) ;
} ;
} ;
return myString ;
} ;
/** @param filename - Dateiname, Quelldatei
* @return myFile - Referenz,FileReader auf Quelldatei */
private static FileReader openFileReader(String filename)
{
FileReader myFile = null ;
if (filename != null)
{
try
{
myFile = new FileReader(filename) ;
}
catch (FileNotFoundException e)
{
System.out.println("\tDateifehler ! - Datei nicht gefunden !") ;
myFile = null ;
} ;
} ;
return myFile ;
} ;
/** @param filename - Dateiname, Zieldatei
* @param bufferedText - Text das geschrieben werden soll
* @return myString - bei Fehler null, sonst "OK" */
public static String writeFile(String filename, String bufferedText)
{
String myString = null ;
FileWriter myFile = null ;
if (filename != null)
myFile = openFileWriter(filename) ;
if (myFile != null)
{
try
{
myFile.write(bufferedText) ;
myFile.flush() ;
myFile.close() ;
myString = "OK" ;
}
catch (IOException e)
{
System.out.println("\tEingabefehler ! - " + e) ;
}
catch (NullPointerException e)
{
System.out.println("\tDateifehler ! - " + e) ;
} ;
} ;
return myString ;
} ;
/** @param filename - Dateiname, Zieldatei
* @return myFile - Referenz,FileWriter auf Zieldatei */
private static FileWriter openFileWriter(String filename)
{
3 of 4
IO.java
14/Jan/2004
FileWriter myFile = null ;
if (filename != null)
{
try
{
myFile = new FileWriter(filename) ;
}
catch (IOException e)
{
System.out.println("\tEingabefehler ! - Datei kann nicht erzeugt werden !") ;
myFile = null ;
} ;
} ;
return myFile ;
} ;
} ;
4 of 4