Tyler-Durden
Grünschnabel
Benutzung des Programms über Kommandozeile:
(CLASSPATH muss auf das Verzeichnis mit der Klasse Search verweisen)
java Search <Datei> <Such-String>
Die Datei kann mit relativem oder absolutem Pfad angegeben werden.
Die grobe Vorgehensweise ist im Quelltext kommentiert:
(CLASSPATH muss auf das Verzeichnis mit der Klasse Search verweisen)
java Search <Datei> <Such-String>
Die Datei kann mit relativem oder absolutem Pfad angegeben werden.
Die grobe Vorgehensweise ist im Quelltext kommentiert:
Java:
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.Vector;
public class Search {
public static void main(String[] args) {
/*
* Hier wird die Datei, die im gleichen Verzeichnis wie die Klasse
* "Search" ist ausfindig gemacht. Leerzeichen im Pfadnamen (Windows)
* tauchen als "%20" auf und werden durch ein Leerzeichen ersetzt.
*/
if (args.length < 2) {
System.out.println("Usage: Search <FILE> <SEARCH-STRING>");
System.exit(0);
}
/*
* Benutzereingaben checken (relativer Pfad zur Datei oder absoluter)
*/
URL url = Search.class.getResource(args[0]);
String path = "";
try {
path = url.getPath();
} catch (NullPointerException ex) {
path = args[0];
}
path = path.replace("%20", " ");
File file = new File(path);
/*
* Vektoren:
* strings --> eingelesene Wörter/Namen
* locations --> wird im Algorithmus verwendet um Positionen
* zu speichern, wo ein Zeichen gefunden wurde
*/
Vector<String> strings = new Vector<String>();
Vector<Integer> locations = new Vector<Integer>();
String searchString = "";
/*
* Einlesen der Datei mit Hilfe von BufferedReader
*/
BufferedReader reader = null;
try {
reader = new BufferedReader(new InputStreamReader(
new FileInputStream(file)));
} catch (FileNotFoundException e) {
System.out.println("Could not find File " + file.getName());
e.printStackTrace();
}
try {
String str = null;
while ((str = reader.readLine()) != null) {
strings.add(str);
}
} catch (IOException e) {
System.out.println("Could not read from File " + file.getName());
e.printStackTrace();
}
/*
* Die Eingaben vom Benutzer (der Such-String) wird gespeichert
*/
for (int i = 1; i < args.length; i++) {
searchString += args[i];
}
// s ist immer ein Wort aus der Liste der Datei. z.B. "Woodrow Wilson"
for (String s : strings) {
/*
* Hier kommt der eigentliche Algorithmus:
*
* - der Such-String wird Zeichenweise durchlaufen
*
* - wenn das Zeichen aus dem Such-String im Wort vorkommt, wird die
* Position in einem Vector(hier: locations) gespeichert
*
* - sind alle Positionen gespeichert, wird das Wort durchlaufen und
* immer an den Positionen geteilt und entweder "<" und ">"
* eingefügt oder nur "<" oder nur ">"
*
* - jedes Mal wenn Klammern eingefügt werden, werden auch die
* Positionen im Vector (hier: locations) verschoben
*
* - wenn alle Klammern eingefügt sind wird der gefundene String mit
* geklammerten Stellen ausgegeben
*/
int y = 0;
for (int i = 0; i < searchString.length(); i++) {
char chr = searchString.charAt(i);
boolean found = false;
for (int n = y; n < s.length(); n++) {
if (chr == s.charAt(n)) {
found = true;
locations.add(n);
y = n + 1;
break;
}
}
if (!found) {
break;
}
if (i == searchString.length() - 1) {
for (int a = 0; a < s.length(); a++) {
if (locations.contains(a)) {
String part1 = s.substring(0, a);
String part2 = s.substring(a + 1, s.length());
if (locations.contains(a - 1)
&& locations.contains(a + 1)) {
s = part1 + s.charAt(a) + part2;
} else if (!locations.contains(a - 1)
&& !locations.contains(a + 1)) {
s = part1 + "<" + s.charAt(a) + ">" + part2;
for (int x = 0; x < locations.size(); x++) {
int b;
if ((b = locations.get(x)) == a) {
locations.set(x, b + 1);
} else if ((b = locations.get(x)) > a) {
locations.set(x, b + 2);
}
}
a++;
} else if (!locations.contains(a - 1)) {
s = part1 + "<" + s.charAt(a) + part2;
for (int x = 0; x < locations.size(); x++) {
int b;
if ((b = locations.get(x)) >= a) {
locations.set(x, b + 1);
}
}
a++;
} else if (!locations.contains(a + 1)) {
s = part1 + s.charAt(a) + ">" + part2;
for (int x = 0; x < locations.size(); x++) {
int b;
if ((b = locations.get(x)) > a) {
locations.set(x, b + 1);
}
}
}
}
}
System.out.println(s);
}
}
locations.clear();
}
}
}
Anhänge
Zuletzt bearbeitet: