# nach wörter in einem textfile suchen



## gazale_m (20. November 2008)

Hi,
ich bin dabei ein Program zu schreiben (ich bin kein Profi) der ein beliebiges File aufmacht und den vorgegebenen Wort drinnen findet.
Mit meinem Programm habe ich das File aufmachen können aber wie kann ich es parsen und die Wörter die ich festlege drinnenl finden? für jeder Hilfe bin ich sehr dankbar.


```
public class findMatches {
    //main method
	public static void main(String[] args) throws Throwable {
             //Stream to read file
		FileInputStream fis = null;
		BufferedInputStream bis = null;
		DataInputStream dis = null;
		try{
			InputStreamReader inStream =new InputStreamReader( System.in ) ;
		    BufferedReader stdin = new BufferedReader( inStream );
		    String inFile;
		    System.out.println("Geben Sie den Pfad ein wo das File sich befindet:");
		   
		    inFile = stdin.readLine();
			
		    File file = new File(inFile);
		    
		    FileReader reader = new FileReader(file);
		    BufferedReader br = new BufferedReader (reader);
	
		try{
			fis = new FileInputStream(file);
			 // Here BufferedInputStream is added for fast reading.
		      bis = new BufferedInputStream(fis);
		      dis = new DataInputStream(bis);
		      while (dis.available() != 0) {

		          // this statement reads the line from the file and print it to
		            // the console.
		            System.out.println(dis.readLine());
		          }

		          // dispose all the resources after using them.
		          fis.close();
		          bis.close();
		          dis.close();

		}
		catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			
			}
		}
		catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			System.err.println ("Unable to read from file");
			
			}
		

	}
```


----------



## Billie (20. November 2008)

Wie komplex soll die Suche denn sein und wie Groß sind die Dateien? Sollten Wörter über Zeilenumbrüche hinaus erkannt werden?

Eine einfache Suche wäre zB mit BufferedReader.readLine() die Datei Zeilenweise auszulesen und dann mit String.indexOf() nach dem Wort zu suchen. Dann könntest du zB ausgaben wie "Das Wort "abc" wurde in der Zeile 3 zweimal gefunden" machen.


----------



## gazale_m (20. November 2008)

Danke für deine Schnelle Antwort. Die such sollte am anfang von einem gewöhnlichen Text datei mit vilen Zeilen umbruche 30 mögliche wörter finden können. wo muss ich den Suchcode in meinem Program einfugen


----------



## Matze (20. November 2008)

Hallo,

du sollest nicht alles in die main-Methode packen. Die soll nämlich eigentlich nur zum starten des Programms dienen.

Ich würde das Auslesen der Zeilen und den Suchalgorytmus in zwei verschiedene Methoden packen 

Wenn Wörter über Zeilenumbrüche hin getrennt sein können, dann solltest du zusätlich noch prüfen, ob das letzte Zeichen in einer Zeile ein "-" (Trennstrich) ist.


----------



## gazale_m (20. November 2008)

finde ich gut aber ein bissl genauer wird viel hilfreicher sein


----------



## Matze (20. November 2008)

Was genauer? Wo kommst du genau nicht weiter?


----------



## gazale_m (20. November 2008)

mein Program öffnet den File jetzt muss es parsen und die Worter finden. Du hast vorgeschlagen das ich 2 getrennte Methoden schreiben soll. Würdest du mir helfen und sagen WO genau kann ich sie einfügen und wie konnen sie von main ausgeführt werden? Ich danke die viel Mals


----------



## Matze (20. November 2008)

Also, wenn ich das jetzt richtig verstehe, hast du noch nicht so viel Erfahrung in Java, oder?

Also, erstmal legst du eine weiter Klasse an. Die kannst du z.B. Suchalgorytmus nennen.
In dieser Klasse legst du 2 Methoden an:


```
public void auslesen(){
...
  try{
	fis = new FileInputStream(file);
	 // Here BufferedInputStream is added for fast reading.
	bis = new BufferedInputStream(fis);
	dis = new DataInputStream(bis);
	while (dis.available() != 0) {

	  // this statement reads the line from the file and print it to
	  // the console.
	   this.durchsuchen(dis.readLine());
	}
....
}

private void durchsuchen(String _strZeile){
  //Hier den Suchalgorytmus rein und die _strZeile durchsuchen
}
```

Die Main-Methode sollte ungefähr so aussehen:

```
Suchalgorytmus objSuche = new Suchalgorytmus();
objSuche.auslesen();
```

Ich hoffe mal, das hilft dir weiter


----------



## gazale_m (20. November 2008)

Ja, das stimmtbis jetzt habe ich immer kleine Bausteine programmiert. Jetzt will ich aber ein komplete programm selber schreiben.  Aber es ist noch schwer anzufangen.


----------



## Matze (20. November 2008)

Und deshalb baut man sein Programm auch aus kleinen Bausteinen auf. Die nennen sich Klassen und Methoden.

Mit der Aussage: "Aber es ist noch schwer anzufangen" wird es schwer werden, dir zu helfen


----------



## gazale_m (20. November 2008)

ich bin bis jetzt dir SO DANKBAR. ich habe jetzt gelernt was und wofür die Classen da sind. noch Mal danke.
Aber (sich schämen) ich weiss noch nicht wie ich den file nach dem worter suchen muss.


----------



## Matze (20. November 2008)

Da möchte ich auf den Post von Billie verweisen. Dort steht nämlich etwas von der indexOf() Methode, die die Stringklasse anbietet.
Das heist, du musst in der durchsuchen-Methode jetzt die Zeile durchsuchen, die du übergeben hast.
Hier  findest du etwas zu der indexOf Mehtode.

Am besten du löst das erstmal mit einem einzigen im Code festhinterlegetn Suchbegriff. Auf mehrere Wörter ausweiten erst Später, dann lernst du auch besser dabei


----------



## Thomas Darimont (20. November 2008)

Hallo,

schau mal hier:

```
/**
 * 
 */
package de.tutorials;

import java.io.File;
import java.io.FileFilter;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;
import static de.tutorials.SearchTextInFilesExample.SearchTarget.*;

/**
 * @author Tom
 * 
 */
public class SearchTextInFilesExample {

	enum SearchTarget{
		FILES,
		FOLDERS{
			public boolean isTarget(File file){
				return file != null && file.isDirectory();
			}
		},
		IMAGES{
			public boolean isTarget(File file){
				return file.isDirectory() || file.getName().endsWith(".jpg");
			}
		};
		
		public boolean isTarget(File file){
			return file != null;
		}
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		for (File file : new FileFinder().find(FILES).beneath("c:/temp")
				.recursively().containing("1234").named(".*\\.txt")
				.result()) {
			System.out.println(file);
		} 
	}

	static class FileFinder {
		boolean recursively;
		String basePath;
		FileFilter fileFilter;
		String searchPattern;
		String searchString;
		SearchTarget searchTarget;

		public FileFinder containingPattern(String searchPattern) {
			this.searchPattern = searchPattern;
			return this;
		}

		public FileFinder containing(String string) {
			this.searchString = string;
			return this;
		}

		public Iterable<File> result() {
			File base = new File(basePath);
			List<File> results = new ArrayList<File>();

			Stack<File> stack = new Stack<File>();

			stack.push(base);
			while (!stack.empty()) {
				File currentFile = stack.pop();
				if (currentFile != null) {
					if (currentFile.isFile()
							&& matchesSearchCriterias(currentFile)) {
						results.add(currentFile);
					}
					if (currentFile.isDirectory()) {
						for (File file : currentFile.listFiles(fileFilter)) {
							stack.add(file);
						}
					}
				}
			}

			return results;
		}

		private boolean matchesSearchCriterias(File file) {
			boolean matches = false;
			try {
				Scanner scanner = new Scanner(file);
				while (scanner.hasNextLine()) {
					String line = scanner.nextLine();
					if (searchPattern != null) {
						matches = line.matches(searchPattern);
					} else if (searchString != null) {
						matches = line.contains(searchString);
					}
					if (matches) {
						break;
					}
				}
				scanner.close();
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}
			return matches;
		}

		public FileFinder named(final String namePattern) {
			fileFilter = new FileFilter() {
				@Override
				public boolean accept(File pathname) {
					return pathname.isDirectory()
							|| pathname.getName().matches(namePattern);
				}
			};
			return this;
		}

		public FileFinder recursively() {
			recursively = true;
			return this;
		}

		public FileFinder beneath(String path) {
			this.basePath = path;
			return this;
		}

		public FileFinder find(SearchTarget searchTarget) {
			this.searchTarget = searchTarget; 
			return this;
		}
	}
}
```

Gruß Tom


----------



## gazale_m (21. November 2008)

sehr mächtig und profesionell  (WOW)  wo soll ich den SearchPattern angeben was ich in dem text suchen will?


----------



## Thomas Darimont (21. November 2008)

Hallo,


```
....containing("1234")...
```

Gruß Tom


----------

