Split + Zeilen einer Datei mit bestimmtem Inhalt löschen

[Lanzettlich]

Hallo!

1) Ich verstehe nicht ganz, wie man einen String aufteilen kann mit .split.
zB:

String s = "Hallo hallo | HALLO";

Wie "teile" ich den String s auf?
Also zB dass alles vor dem |-Zeichen in String s1 gespeichert wird, und alles nach dem |-Zeichen in String s2 gespeichert wird.

2) Wie kann man alle Zeilen einer Textdatei löschen, in denen ein bestimmter Inhalt vorkommt?
Ich weiß leider nur, wie ich den bestimmten Inhalt aus allen Zeilen entferne, aber nicht die ganze Zeile, in der der bestimmte Inhalt vorkommt.

MfG
Lanzettlich!

 

[Coold0wn]

1. String[] SplittArray = text.split("|");

sollte klappen

2. kein peil

 

[Lanzettlich]

1. String[] SplittArray = text.split("|");

sollte klappen

2. kein peil

Danke!
Und wie bekomme ich jetzt alles was vor | war in String s1, und alles was nach | war in String s2?

 

[Volvagia]

Du bekommst bei split() ja schon ein Array mit n Strings zurück.

2) Lesen, ändern, neue Datei schreiben. Die Zeilen werden ja durch \n(\r) getrennt.

 

[Lanzettlich]

Hallo!

Und wie wandle ich dann den Array in 2 "selbstständige" Strings um?
Also: String s1 = "Hallo"; String s2= "HALLO";
Vielleicht mit einer for-Schleife und einem StringBuilder?

Meine Idee funktioniert leider nicht so ganz:
"SplittArray[0] + SplittArray[1] + SplittArray[2] + SplittArray[3]"
Die Ausgabe ist dann: Hal

MfG
Lanzettlich

 

[Volvagia]

Du kennst den StringBuilder, weißt aber nicht wie man mit Arrays hantiert? Oo
Galileo Computing :: Java ist auch eine Insel – 3.7 Arrays

Verwende split("[|]").

 

[Lanzettlich]

Hallo!
Ich habe jetzt mal das ausprobiert:

		String text = "Hallo | HALLO";
		String[] SplittArray = text.split("|");
		for(String s : SplittArray)
		{
			System.out.println(s);
		}

Allerdings bekomme ich da als Ausgabe:
H
a
l
l
o

|

H
A
L
L
O

Wie bekomme ich denn jetzt das "Hallo" (was vor | steht) in String s1 und "HALLO" (was nach | steht) in String s2?

 

[ssoul26]

Hallo!
Ich habe jetzt mal das ausprobiert:

		String text = "Hallo | HALLO";
		String[] SplittArray = text.split("|");
		for(String s : SplittArray)
		{
			System.out.println(s);
		}

Allerdings bekomme ich da als Ausgabe:
H
a
l
l
o

|

H
A
L
L
O

Wie bekomme ich denn jetzt das "Hallo" (was vor | steht) in String s1 und "HALLO" (was nach | steht) in String s2?

Achte auf die "\\". Was das konrket bedeutet, kannst du ja googlen

  String text = "Hallo | HALLO";
      String[] SplittArray = text.split("\\|");
      for(String s : SplittArray)
      {
          System.out.println(s);
      }

 

[shishigami]

String text = "Hallo|HALLO";
String[] textArray = text.split("\\|");
String s1 = textArray[0]; // Hallo
String s2 = textArray[1]; // HALLO

Wegen \\| : java - Why does String.split need pipe delimiter to be escaped? - Stack Overflow

 

[Lanzettlich]

Danke, darauf bin ich auch selbst draufgekommen ;P

Und zu meiner 2. Frage:
Wie löscht man alle Zeilen einer Textdatei mit einem bestimmten Inhalt?
Also nicht nur den bestimmten Inhalt aus allen Zeilen, sondern gleich alle Zeilen mit diesem Inhalt löschen.

MfG
Lanzettlich!

 

[Volvagia]

Du gehst mit einer Schleife durch, prüfst ob die Zeile einen bestimmten Inhalt hast und entfernst sie. Zeilen sind durch (char)13 oder durch (char)13(char)10 getrennt. (Das sind zumindest die Standart-Zeilenumbrüche von Linux und Windows, wie es sich mit Mac oder anderen OSen verhält weiß ich nicht.)

Kannst ja einfach mit nen BufferedReader zeilenweiße lesen, und wenn sie die Needle nicht enthalten fügst du sie zu einen StringBuilder hinzu und schreibst ihn wieder in einen runter in eine Datei.

Ich bevorzuge [|] statt \\|, das läuft aber auf das selbe raus. Bei den einen wird es als Zeichen und nicht als Regex interpretiert, bei den anderen nicht als Regex. (Also als Zeichen. ^^)

 

[Lanzettlich]

Wie überprüfe ich denn, ob eine Zeile einen bestimmten Inhalt enthält?

Mein aktueller Code:

                BufferedReader in = new BufferedReader(new FileReader(file));
	        String str;
	        while ((str = in.readLine()) != null)
	        {
	        	
	        	String str1 = str;
	        	List<String> list = new ArrayList<String>();
	        	list.add(str1);
	        	for(String s : list)
	        	{

	        	}
	        }

 

[Volvagia]

Warum legst du bei jedem neuen Schleifendurchgang eine neue Liste an, fügst etwas hinzu und willst dann darüber iterieren?
String enthält die Methode contains. Wenn du nichts extra brauchst (z. B. Case-Insensitive Suche) kannst du diese verwenden um festzustellen, ob der String eine genaue Zeichenfolge enthält.

 

[Trolllllll]

So!?!

            BufferedReader in = new BufferedReader(new FileReader(file));
            String str;
            String newString;
            while ((str = in.readLine()) != null)
            {
                if (str.contains("wenn das enthalten dann nicht)){
                   //do nothing
                }else{
                    newString=newString+str+"\n\r";
                }
            }
            // nun den neuen String (newString) in deine Datei schreiben

 

[Volvagia]

Noch nicht ganz. Es fehlt ein Anführungszeichen (deshalb wird der restliche Code blau) und durch das Zusammenfügen der Strings wird am Anfang immer null stehen (da du damit den String intialisieren musst, das kannst du aber mit newString = ""; umgehen).
Außerdem wird am Ende immer eine Leerzeile hinzugefügt, ich denke das ist aber das unwichtigste daran.

Du solltest zum Zusammensetzen des Strings einen StringBuilder nehmen, Strings sollte man niemals in einer Schleife zusammensetzen.
Und du solltest die Intialisierung von in und das Erzeugen des Readers in 2 Zeilen verteilen, sonst kann du es nicht mehr im finally-Block der zur try/catch gehört schließen.

 

[hüteüberhüte]

Zu 2): So auf die schnelle:

    public static String removeLines(String str, String regex) throws IOException {
        Pattern pattern = Pattern.compile(regex);
        StringWriter stringWriter = new StringWriter(str.length());
        PrintWriter printWriter = new PrintWriter(stringWriter);
        BufferedReader reader = new BufferedReader(new StringReader(str));
        String line;
        while ((line = reader.readLine()) != null) {
            if (!pattern.matcher(line).find()) {
                printWriter.println(line);
            }
        }
        return stringWriter.toString();
    }

    public static void main(String[] args) throws IOException {
        System.out.print(removeLines("hallo\n"
                                   + "Hallo\n"
                                   + "hAllo\n"
                                   + "haLlo\n"
                                   + "halLo\n"
                                   + "hallO", "ha(Ll)|(lL)o"));
    }

Müsstest nur noch was zum einlesen einer Datei schreiben. (Haut mich nicht, wenn man das so nicht machen würde )

 

[mla.rue]

[...] Strings sollte man niemals in einer Schleife zusammensetzen.
[..]

Warum?

 

[Trolllllll]

So jetzt sollten die Bugs drausen sein und es ist ziemlich so wie es der TO gemacht hat und nicht ein komplett anderer code, obwohl deiner hüteüberhüte schick aussieht, so auf den ersten blick, im gegensatz zu meinem

            BufferedReader in = new BufferedReader(new FileReader(file));
            String str;
            String newString="";
            boolean first=true;
            while ((str = in.readLine()) != null)
            {
                if (str.contains("wenn das enthalten dann nicht")){
                   //do nothing
                }else{
                    if(first){
                        newString=newString+str
                    }else{
                       newString=newString+"\n\r"+str;
                    }
                }
            }
            // nun den neuen String (newString) in deine Datei schreiben

 

[mla.rue]

            BufferedReader in = new BufferedReader(new FileReader(file));
            String str;
            String newString="";
            boolean first=true;
            while ((str = in.readLine()) != null)
            {
                if (!str.contains("wenn das enthalten dann nicht")){
                    if(first){
                        newString=newString+str;
                        first = false; //was willst damit eigentlich? das Problem ist die letzte Zeile, nicht die erste
                    }else{
                       newString=newString+"\n\r"+str;
                    }
                }
            }
            // nun den neuen String (newString) in deine Datei schreiben

 

[hüteüberhüte]

@Trolllllll: Mein Problem, warum ich so viele Klassen verwendet habe, war, das ich String-Konkatenation und

System.getProperty("line.separator");

umgehen wollte, und eine Systemunabhängige Lösung zu basteln

 

[Volvagia]

Warum?

Strings sind nach der Intitalisierung nicht mehr veränderbar (immutable).
Deshalb werden bei Schleifen viele String erzeugt.
Um das zu vermeiden verwendet man einen StringBuilder. An den heftet man jeden Schleifendurchgang den nächsten String an und holt sich nach der Schleife den endgültigen String per toString.

public static void main(String[] args) {
	useNoBuilder();
	//useBuilder();
}
private static void useNoBuilder() {
	String s = "";
	for(int i = 0; i < Short.MAX_VALUE * 2; i++) {
		s+= i;
	}
	System.out.println(s);
	System.out.println("Done (noBuilder)");
}
private static void useBuilder() {
	StringBuilder builder = new StringBuilder();
	for(int i = 0; i < Short.MAX_VALUE * 2; i++) {
		builder.append(String.valueOf(i));
	}
	System.out.println(builder.toString());
	System.out.println("Done (Builder)");
}

useBuilder() ist um ein vielfaches schneller als useNoBuilder().

 

[Trolllllll]

first = false; //was willst damit eigentlich? das Problem ist die letzte Zeile, nicht die erste

Stimmt, die Zeile habe ich vergessen ;-)
Mhh kommt drauf an, wenn du dir den Code durchließt, siehst du warum die erste Zeile ;-)
Die erste Zeile hat keinen Zeilenumbruch, und der wird jetzt vor jeder Zeile eingefügt und nicht dannach, außer halt bei der ersten Zeile

 

[Firephoenix]

@Trolllllll: Mein Problem, warum ich so viele Klassen verwendet habe, war, das ich String-Konkatenation und

System.getProperty("line.separator");

umgehen wollte, und eine Systemunabhängige Lösung zu basteln

Wenn du einen Printwriter erzeugst wird intern ebenfalls das Property line.separator abgefragt und bei allen Methoden verwendet die eine neue Zeile schreiben (z.B. println()).

Ich hab mal einen kleinen Grundriss für das Filtern geschrieben den man beliebig erweitern kann (Filterstrategien einbauen statt dem contains, alte Datei behalten, Fehlerbehandlung falls temporäre Datei existiert, etc...)
Vorteil von der Methode ist, dass du nie die komplett Datei im Speicher halten kannst und so auch eine Datei filtern kannst die mehrere Gigabyte groß ist.

import java.io.BufferedReader;
import java.io.Closeable;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class FileFilter {

	public static void main(String[] args){
		FileFilter f = new FileFilter();
		f.filter("test.txt");
	}
	
	public void filter(String filename){
		File original_file = new File(filename);
		File temp_file = new File(filename+".tmp");
		BufferedReader in = null;
		PrintWriter out = null;
		try {
			in = new BufferedReader(new FileReader(original_file));
			out = new PrintWriter(new FileWriter(temp_file));
			String line = null;
			while((line = in.readLine())!=null){
				if(!matchFilter(line)){
					out.println(line);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			closeClosable(in);
			closeClosable(out);
		}
		if(original_file.delete()){
			temp_file.renameTo(new File(filename));
		}

	}
	private boolean matchFilter(String line) {
		return line.contains("blub");
	}
	private void closeClosable(Closeable c){
		if(c != null){
			try {
				c.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

test.txt vorher

12398124

blub
afdsadf
asdfjlkasdblubasfdsdfa
ssadfkljkasdjf

981743214

blub lbuasdf

fsadfe  blub

bß0989787^1c2


sadfsdaf


...

test.txt nachher:

12398124

afdsadf
ssadfkljkasdjf

981743214



bß0989787^1c2


sadfsdaf


...

Gruß

 

[hüteüberhüte]

Schöne Lösung. Arbeitet nur noch nicht mit Regex Thx