string im ganzen file durchsuchen

[paidopoieo]

Hallo Leute,

ich hab folgendes problem, ich habe zwei files, les beim ersten file die erste zeile ein, hol mir dort dann einen substring raus, und such diesen substring im zweiten file, jedoch macht er das nur beim ersten durchgang, zweite zeile vom ersten file einlesen, substring raussuchen und wieder in ganzen zweiten file suchen, wenn match, dann ganze zeile rausschreiben....funkt aber nur beim ersten durchgang....

bin leider anfänger, danke für eure hilfe

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;


public class Compare {

	/**
	 * @param args
	 */
public static void main(String[] args) {
		
	System.out.println("start program:");
	try {
	    System.out.println("Read first file:");    
		BufferedReader first = new BufferedReader(new FileReader("fir.txt"));
		System.out.println("Read second file:");
	    BufferedReader second = new BufferedReader(new FileReader ("sec.txt"));
	        String tokenF;
	        String tokenS;
	        int count = 0;
	        
	        while ((tokenF = first.readLine()) != null) {
	        	
	        	int transidInt = tokenF.lastIndexOf(";");
	        	String transidF = tokenF.substring(transidInt, tokenF.length());
	        	
	        	
		       while (true)	{
				while ((tokenS = second.readLine()) != null) {	
					
					int transidIntS = tokenS.lastIndexOf(";");
			        String transidS = tokenS.substring(transidIntS, tokenS.length());
	        	
					
					if (transidF.compareTo(transidS) == 0) {
						
						count++;
						
					    try {
					        BufferedWriter out = new BufferedWriter(new FileWriter("matches.txt", true));
					        out.write(tokenF);
					        out.write("\n");
					        out.write(tokenS);
					        out.write("\n");
					        out.write("\n");
					        
					        
					        out.close();
					    } catch (IOException e) {
					    }
					/*} else {
						
						try {
					        BufferedWriter outFirst = new BufferedWriter(new FileWriter("outFirst.txt", true));
					        outFirst.write(tokenF);
					        outFirst.write("\n");
					        outFirst.close();
					        
					    } catch (IOException e) {
					    }
						
					    try {
					        BufferedWriter outSecond = new BufferedWriter(new FileWriter("outSecond.txt", true));
					        outSecond.write(tokenF);
					        outSecond.write("\n");
					        outSecond.close();
					    } catch (IOException e) {
					    }*/
						
					}//end else

					
	        	}//end if
	        first.close();
	        }
	        }
	    } catch (IOException e) {
	    }
	}
}

 

[SlaterB]

wenn second durchlaufen ist, dann ist es durchlaufen,
nur weil du nochmal eine while-Schleife startest
wird Java nicht durch Zauberhand zurück zum Anfang gehen

also:
entweder den Reader neu aufmachen oder die Zeilen in einer Liste speichern und diese wieder von vorne durchlaufen
(z.B. neuer Iterator oder Index wieder auf 0 setzen)

 

[paidopoieo]

ich will jedesmal das ganze zweite file durchlaufen, mach das zeile für zeile, und hol mir auch den substring raus den ich mit dem ersten vergleiche....

 

[mikachu]

BufferedReader lesen als Stream... -> wenn am ende angelangt, wird stream geschlossen.
du müsstest den 2. stream am schluss wieder resetten

oder eine von beiden dateien (die kleinere) erst vollständig in liste einlesen, dann schließen und die andere datei gegen diese liste prüfen

#edit 1:
war zu langsam mit schreiben... SlaterB war schneller :wink:

 

[paidopoieo]

Hi

Vielen Dank für eure Hilfe. Hab das matchen jetzt hinbekommen. Nur will ich jetzt wenn eine Zeile gematched ist in beiden files rauslöschen und dann die untere nachschieben. Sodass dann nur noch die nicht gematchen drinnen stehen in den beiden files. hab das mit replace gemacht, scheint aber nicht zu funktionieren. Danke

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;


public class Compare {

	/**
	 * @param args
	 */
/**
 * @param args
 */
public static void main(String[] args) {
		
	System.out.println("start program:");
	try {
	    System.out.println("Read first file:");    
		BufferedReader first = new BufferedReader(new FileReader("fir.txt"));
		
	        String tokenF;
	        
	        int count = 0;
	        
	        while ((tokenF = first.readLine()) != null) {
	        	
	        	int transidInt = tokenF.lastIndexOf(";");
	        	String transidF = tokenF.substring(transidInt, tokenF.length());
	        	
	        	
	        	System.out.println("Read second file:");
	    	    BufferedReader second = new BufferedReader(new FileReader ("sec.txt"));
	    	    String tokenS;
	    	    
	    	    while ((tokenS = second.readLine()) != null) {	
					
					int transidIntS = tokenS.lastIndexOf(";");
			        String transidS = tokenS.substring(transidIntS, tokenS.length());
	        	
					
					if (transidF.compareTo(transidS) == 0) {
						
						count++;
						
					    try {
					        BufferedWriter out = new BufferedWriter(new FileWriter("matches.txt", true));
					        out.write(tokenF);
					        out.write("\n");
					        out.write(tokenS);
					        out.write("\n");
					        out.write("\n");
					        System.out.print(count);
					        
					        out.close();
					        
					        tokenF.replace(tokenF, " ");
					        tokenS.replace(tokenS, " ");
					        
					    } catch (IOException e) {
					    }
					/*} else {
						
						try {
					        BufferedWriter outFirst = new BufferedWriter(new FileWriter("outFirst.txt", true));
					        outFirst.write(tokenF);
					        outFirst.write("\n");
					        outFirst.close();
					        
					    } catch (IOException e) {
					    }
						
					    try {
					        BufferedWriter outSecond = new BufferedWriter(new FileWriter("outSecond.txt", true));
					        outSecond.write(tokenF);
					        outSecond.write("\n");
					        outSecond.close();
					    } catch (IOException e) {
					    }*/
						
					}

					
	        	}//end if
	    	    
	    	    
	    	    second.close();
	        
	        }
	        first.close();  
	    } catch (IOException e) {
	    }
	}
}

 

[SlaterB]

ein String ist unveränderlich,
wenn du etwas replacen willst, dann mache
string = string.replace(..,..);

sowas testet man übrigens in einem kleinen TestProgramm mit 3 Zeilen,
nicht inmitten eines riesigen unübersichtlichen Kopierprogrammes.....

 

[paidopoieo]

Hallo Slater,

Ich weiß sorry, hab das jetzt probiert, kriegs aber nicht hin....
mit:

tokenF = tokenF.replace(tokenF, " ");

muss ich da dann den buffered reader wieder aufmachen und nochmal reinschreiben?

 

[SlaterB]

mit Reader kannst du überhaupt nicht schreiben,
mit Writer kannst du schreiben,

ich erkläre das aber nicht alles , lies erstmal 20 Seiten im Buch dazu,
um überhaupt eine Ahnung zu haben, was Reader + Writer sind

 

[Guest]

sorry, sorry....

meinte ja writer...

 

[SlaterB]

ok, du hast ja sogar schon Writer im Code

aber mit so allgemeinen Fragen a la 'wieder aufmachen' kommst du kaum weiter,
ich weiß ja gar nicht was dein ganzes Programm machen soll

 

[paidopoieo]

Ok, sorry für meine unfähigen ausführungen

also, ich habe zwei files, die ich zeile für zeile einlese, dort einen bestimmten substring raushole, den dann miteinander vergleiche, wenn der stimmt, die jeweilige ganze zeile aus beiden files in ein anderes schreiben. Und dann die zeilen die matchen rauslöschen, sodass nur noch die drinnen bleiben, die keinen match haben....

ich wolle das so machen, das ich das grössere file hernehme, dort zeile für zeile auslese und dann im anderen file suche, ob ich finde

Ich hoffe das war mehr verständlicher

danke

 

[SlaterB]

so, dann fange mit zwei Dateien an,
eine enthält
a
b

die andere
c
b
d

oder was immer du für Beispiele brauchst,
ein Vorschlag in diesem Thread ist immer noch, eine Datei als String-Liste einzulesen und jedes Mal durchzulaufen,
du willst ja jedes Mal die Datei neu einlesen?
dann musst du wohl auch jedes Mal die Datei neu schreiben,

gleichzeitig lesen + schreiben dürfte schwer sein, da brauchst du dann wohl auf jeden Fall einen zweiten Dateinamen,
oder eben die Datei komplett einlesen

wenn du 'b' und 'b als Match findest,
dann darfst du die Zeile b eben nicht abspeichern, diese Zeile auslassen, oder die Zeile erst nach einem replace speichern

 

[paidopoieo]

Hi,

hab das ganze jetzt wie vorgeschlagen mit einer linked list gemacht, jedoch wird vom buffered reader nur jede zweite zeile eingelesen und ich weiß nicht warum
ausserdem bekomm ich aus irgendeinem grund out of memory, heap size

danke für eure hilfe

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.LinkedList;
import java.util.List;


public class Compare {

	/**
	 * @param args
	 */
/**
 * @param args
 */
public static void main(String[] args) {
		
	System.out.println("start program:");
	try {
	    System.out.println("Read first file:");    
		BufferedReader first = new BufferedReader(new FileReader("Kopie von sns_report_ie_july_cleaned.log"));
		
		System.out.println("Read second file:");
	    BufferedReader second = new BufferedReader(new FileReader ("Kopie von sns_IE_July.txt"));
		
	        
	        List listFirst = new LinkedList();
	        List listSecond = new LinkedList();
	        List matchedList = new LinkedList();
	        List nonmatchedList = new LinkedList();
	        
	        while (first.readLine() != null) {
	        
	        	String tempF = first.readLine();
	        	listFirst.add(tempF);
	        	System.out.println ("added first");
	        	System.out.println(tempF);
	        	
	        }
	        
	        
	        while (second.readLine() != null) {
		        
	        	String tempS = second.readLine();
	        	listSecond.add(tempS);
	        	System.out.println ("added second");
	        }
	        
	        first.close();
	        second.close();
	        
	        System.out.println ("added finished and closed");
	        
	        int count = 0;
	        
	        for (int i=0; i <= listFirst.size(); i++) {
	        	
	        	String str = (String) listFirst.get(i);
	        	String matchStr = str.substring(str.lastIndexOf(";")+1, str.length());
	        	
	        	System.out.println(matchStr);
	        	
	        	for (int j=0; j <= listSecond.size(); j++) {
	        		
	        		String strSec = (String) listSecond.get(i);
		        	String matchStrSec = strSec.substring(strSec.lastIndexOf(";")+1, strSec.length());
		        	
		        	System.out.println(matchStrSec);
		        	
		        	if (matchStr.equals(matchStrSec)) {
		        		
		        		count++;
		        		System.out.println (count);
		        		System.out.println ("matched Yes");
		        		matchedList.add(str);
		        		matchedList.add(strSec);
		        	
		        	} else {
		        		
		        		nonmatchedList.add(str);
		        	}
	        		
	        	}

	        }
	        	
	       for(int i =0; i <= matchedList.size(); i++) {
	    	   
	    	   String tempMatch = (String) matchedList.get(i);
	    	   
	    	   System.out.println ("starting adding to matched list");
	    	   
	    	   BufferedWriter matchedFile = new BufferedWriter(new FileWriter("matchedFile"));
	    	   matchedFile.write(tempMatch);
	    	   matchedFile.close();
	    	   
	       }  	
	        	
	        
	        	
	     } catch (Exception e) {
	    	e.printStackTrace(); 
	     }
	     
	     
	     
}
}

 

[SlaterB]

while (first.readLine() != null) { // erste Zeile eingelesen
           
              String tempF = first.readLine(); // zweite Zeile eingelesen

}

wie immer: wenn du noch Probleme hast, überhaupt Dateien einzulesen,
dann man das doch erstmal in einem einzelnen Testprogramm..

und wie gesagt: nimm Testdateien mit 2-3 Zeilen mit jeweils nur wenigen Buchstaben

---------

> ausserdem bekomm ich aus irgendeinem grund out of memory, heap size
wann, wo?
bei deinen Schleifen mache überall System.out.println rein um zu erkennen ob irgendeine endlos läuft