# [JAVA] mehrere Leerzeichen auf einen reduzieren



## Wincenty (4. Dezember 2012)

Hallo,
ich muss einen Text normieren, d.h. das Programm soll eine Text.txt lesen, wenn mehrere Leerzeichen aufeinander folgen sollen diese durch ein Leerzeichen ersetzt werden. Wenn es keine doppelten Leerzeichen mehr gibt soll der normierte Text in eine TextOut.txt geschrieben werden.

Ich habe ein Struktogramm erstellt (ob jetzt die Symbolik stimmt weiß ich nicht, da ich Struktogramme eher als "Hilfsmittel" oder "Leitfaden" verwende)




			Dieser Inhalt steht nur eingeloggten Mitgliedern zur Verfügung.
        



Ich habe bisschen gegoogelt und für die Funktion replaceAll muss ich einen String haben der gebuffert ist, nur bekomme ich das buffern nicht auf die Reihe, da ich aus einer bestehenden Textdatei das machen soll und google nur Engl. Sachen ausspuckt und ich die meisten nicht verstehe und mein Buch Einstieg in Java 6 ist mir im moment auch nicht sehr klar.

Bissheriger Code:

```
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;

public class TextNormieren {

            public static void main(String[] args) {
                
                try{
                    File f = new File("Text.txt");
                    FileReader fr = new FileReader(f);
                    int i; //Zeichen das gelesen wurde
                    String text = "";
                
                    while ((i = fr.read())!=-1) { //-1 == ende der Datei
                        //System.out.print(i);
                        //System.out.print((char)i);
                        if (i == ' '&& i+1 == ' ') {
                            String replaceAll("  "," ");
                        }
                        else {
                            File fo = new File("TextOut.txt");
                            FileOutputStream fw = new FileOutputStream(fo);
                            
                            /*Schreibfunktion aus dem Tutorium entnommen was in der Uni war:
                             *  try{
        File f = new File("Text2.txt");
        FileOutputStream fw = new FileOutputStream(f);
        fw.write(new byte [] {32,33,34});
        for (int i=30;i<250;i++) {
        fw.write(i);
            }
        String text = "What are U doing brain??";
        fw.write(text.getBytes());
        fw.close();
        }
        catch (Exception e){}
                        }
                }
                fr.close();
                
                }
                catch (Exception e){} */
                

    }
}
```


----------



## -Phoenix- (4. Dezember 2012)

Moin,
  mit replaceAll kommst du aber auch nicht weit sobald du 3 oder mehr  Leerzeichen hast, weil du dann nach dem replace immer noch 2 oder  mehrere Leerzeichen hintereinander hast. Ich habe mal schnell etwas  gecodet, das funktioniert auch aber ist nicht wirklich schön, geht auch  nur für die erste Zeile aber es wir dir auf jeden Fall weiterhelfen.


```
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;

public class TextNormieren {

    public static void main(String[] args) {

        char output[] = null;
        
        try {
            File f = new File("Text.txt");
            FileReader fr = new FileReader(f);
            BufferedReader br = new BufferedReader(fr);

            
            String zeile1 = br.readLine(); // eine Zeile einlesen
            char[] text = zeile1.toCharArray();  //Zeile in Char array umwandeln 
            output = new char[zeile1.length()];   //ein Zweites Char array fuer das Ergebnis ohne mehrfache Leerzeichen
            int a = 0;
            int b = 0;
            while (text[a] != '\0')   //bis zum Ende der Zeile 
            {
               if (!(text[a] == ' ' && text[a+1] == ' ')) {    //wenn an dieser Position und an der Position eins weiter rechts kein Leerzeichen ist 
                 output[b] = text[a];       //Buchstaben übernehmen
                 b++;
               }
               a++;
            }
            

        }
        catch (Exception e)
        {
            
        }    
        
        String ausagbe ="";
        for (int i = 0; output[i] != '\0';i++) // Ergebnis Buchstabenweise ausgeben
        {
            System.out.print(output[i]);
        }

    }
    
}
```
Man muss das Char[] noch in einen String umwandeln und das ganze in eine Schleife packen damit jede Zeile durchlaufen wird. 

Lg.


----------



## xReadme (4. Dezember 2012)

Nabend,

der gute phoenix war wohl schneller als ich 

hier trozdem mein lösungs vorschlag... quick'n'dirty aber vll. hilfts dir ja weiter.


```
public class Starter {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Starter s = new Starter();
		System.out.println(s.zeichenRaus("Hallo Welt", ' '));
	}

	/* 
	 * Datum	:	4.12.2012
	 * 				
	 * Übergabe	:
	 * 			- Zu bearbeitender string
	 * 			- zu löschendes zeichen
	 * 
	 * Rückgabe	: 
	 * 			- ergebnisstring ohne zeichen
	 * 
	 * TODO		Bis lastIndexOf(zeichen) länge begrenzen... optimierung
	 */
	String zeichenRaus(String inputString,  char zeichen){
		String erg = "";
		if(!inputString.equals(""))
		{
			char[] inputCharArray = inputString.toCharArray(); //für einfacheres handling
			
			boolean charFound = false; 				//zum schauen ob char schonmal gefunden wurde
			int i = inputString.indexOf(zeichen); 	//bis zum ersten vorkommen des zeichens springen 
			erg = inputString.substring(0, i);    	//text übernehmen
			for (; i < inputCharArray.length; i++) {//rest durchgehen
				if(inputCharArray[i] == zeichen){
					charFound = true; 				//wenn gefunden dann markieren und nicht hinzufügen
				}else{
					if(charFound){					//wenn der char vorhin gefunden wurde, nachträglich wieder anhängen
						charFound = false; 
						erg += zeichen;
					}
					erg += inputCharArray[i]; 		//wenn char nicht gefunden, normalen text hinzufügen  
				}
			}
		}
		return erg;
	}
}
```


----------



## Wincenty (4. Dezember 2012)

-Phoenix- schrieb:


> Moin,
> 1. mit replaceAll kommst du aber auch nicht weit sobald du 3 oder mehr  Leerzeichen hast, weil du dann nach dem replace immer noch 2 oder  mehrere Leerzeichen hintereinander hast. Ich habe mal schnell etwas  gecodet, das funktioniert auch aber ist nicht wirklich schön, geht auch  nur für die erste Zeile aber es wir dir auf jeden Fall weiterhelfen.
> 
> 2. Man muss das Char[] noch in einen String umwandeln und das ganze in eine Schleife packen damit jede Zeile durchlaufen wird.



1. Kann man nicht eine Schleife um replaceAll machen damit er den Vorgang solange wiederholt bis die Bediungen  _if (!(text[a] == ' ' && text[a+1] == ' '))  _nicht mehr erfüllt ist?

2. Das verstehe ich nicht ganz - ich versuch grad unter _BufferedReader br = new BufferedReader(fr);_ eine Schleife einzubauen damit ich _String zeile = br.readLine(i);_ nutzen kann und _output = new char[zeile.length()];_ ein _i++ _setzen kann (ist das zulässig oder BuSh/Falsch?)

3. Wo du _System.out.print(output); platziert hast, muss ich ja einen Filewriter setzen damit eine TextOut.txt mit der Verbesserung erstellt und es sieht irgendwie so aus:


		Code:
	

for (int i = 0; output[i] != '\0';i++) {
                    try {
                        File f2 = new File("TextOut.txt");
                        FileWriter fw = new FileWriter(f2);
                        fw.write(output[i]);
                            fw.close();
                        } catch (IOException e) {
                            e.printStackTrace();


Nur steht aber in der TextOut.txt NUR ein n ich weiß nicht was da falsch ist_


----------



## xReadme (4. Dezember 2012)

Nabend,

1. du müsstest den String sowieso parsen. Daher ist es schneller und einfacher direkt alle Leerzeichen bis auf eines rauszuschneiden.

2. Er macht das damit er einfacher durch den String iterieren kann. Das ginge auch mit String.charAt(i); die Funktion sollte letztendlich im hintergrund das selbe machen...
 Wenn du das Zeile für Zeile machen willst dann setz einfach die while Schleife um die ganze Funktion...
 Vll etwas in der Form:
 while(fr.ready()){
    String zeile = br.getLine();

    //ursprünglicher code hier
 }

3. das einzige was du mit output machen musst ist 
 File f2 = new File("TextOut.txt");
 FileWriter fw = new FileWriter(f2);
 fw.write(new String(output)); //charkette wieder zu string, dann schreiben
 fw.close();

wobei new String() nur dazu da ist den output ganz klar wieder als String zu konvertieren damit du nach dem eigendlichen String keinen abfall in deiner Datei stehen hast  (Ich bin mir gerade nicht sicher ob es ohne auch geht, so gehst du eben auf Nummer sicher).

Hoffe ich konnte helfen.


----------



## Wincenty (4. Dezember 2012)

jetzt gibt er richtig die TextOut.txt aus nur geht er noch nicht zeile für Zeile, wahrscheinlich wegen 
	
	



```
readLine()
```
 denn 
	
	



```
String zeile = br.[U][COLOR=red]getLine[/U]();
```
 wird mir als Fehler angegeben da die Methode getLine() für den Typ BufferredReader undefiniert ist (eclispe Ganymed)


----------



## xReadme (4. Dezember 2012)

ja, es ist readLine()  
habs nicht getestet sorry


----------



## Wincenty (4. Dezember 2012)

wie kann ich die anzahl zeilen aus der txt finden? ich habe 2 int erstellt vor der while schleife: einmal z die gerade bearbeitende zeile, welche mit 0 initalisiert wird und ze, welches die gesamtanzahl der Zeilen darstellt. Die While Schleife hat als Bediungen das es solange wiederholt wird solange z <= ze ist. 
Das ganze sieht jetzt so aus:

```
try{
                    File f = new File("Text.txt");
                    FileReader fr = new FileReader(f);
                    BufferedReader br = new BufferedReader(fr);
                    int z = 0;
                    int ze;
                    while (z< = [U][COLOR=red]ze[/U]) { //ze als Fehler gemldet da es noch keinen Wert besitzt
                    String zeile = br.readLine();
                    char[] text = zeile.toCharArray();
                    output = new char[zeile.length()];
                    int a = 0;
                    int b = 0;
                    
                    while (text[a] != '\0') {
                        if (!(text[a] == ' ' && text[a+1] == ' ')) {
                            output[b] = text[a];
                            b++;
                            }
                        a++;
                            }
                        }
                    }
```
EDIT: ok ich hab jetzt was endlich gefunden um die Zeilenzahl zu finden aber er gibt mir dan das aus:
1234567


```
try {
        BufferedReader in1 = new BufferedReader(new FileReader("Text.txt"));
        int nLineCount = 0;
        while (in1.readLine() != null)
        {
        nLineCount++;
        System.out.print(nLineCount);
        }
        } catch(Exception e) {

        }
```
jetzt müsste ich nur die 7 bekommen 

EDIT2:
Jetzt hab ich auch endlich den Zähler auf die Reihe gebracht nur weiß ich nicht wie es implementieren muss:

Dass


```
try {
                        BufferedReader in1 = new BufferedReader(new FileReader("Text.txt"));
                        int nLineCount = 0;
                        while (in1.readLine() != null)
                        {
                            nLineCount++;
                        }
                        int resulat = nLineCount;
                    } 
                        catch(Exception e) {}
                    
                    int ze = resultat;
                    try {
                        BufferedReader in1 = new BufferedReader(new FileReader("Text.txt"));
                        int nLineCount = 0;
                        while (in1.readLine() != null)
                        {
                            nLineCount++;
                        }
                        System.out.print(nLineCount);
                    } 
                        catch(Exception e) {}
```
muss da rein:


```
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;

public class TextNormieren {
    
    

            public static void main(String[] args) {
                
                char output[] = null;
                
                try{
                    File f = new File("Text.txt");
                    FileReader fr = new FileReader(f);
                    BufferedReader br = new BufferedReader(fr);
                    int z = 0;
                    
                    while (z <= ze) {
                    String zeile = br.readLine();
                    char[] text = zeile.toCharArray();
                    output = new char[zeile.length()];
                    int a = 0;
                    int b = 0;
                    
                    while (text[a] != '\0') {
                        if (!(text[a] == ' ' && text[a+1] == ' ')) {
                            output[b] = text[a];
                            b++;
                            }
                        a++;
                            }
                        }
                    }
                catch (Exception e) {}    
                String ausagbe ="";
                for (int i = 0; output[i] != '\0';i++)
                {
                    System.out.print(output[i]);
                }

             {for (int i = 0; output[i] != '\0';i++) {
                    try {
                        File f2 = new File("Textbetatest.txt");
                        FileWriter fw = new FileWriter(f2);
                        fw.write(new String (output));
                            fw.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                }
             }
         }
    }
}
```
EDIT3:

So jetzt hab ich hier irgenwas geschustert, macht aber nicht das was es soll -.-


```
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;

public class TextNormieren {
    
    

            private static int resultat() {
                int zeilenzahl = 0;
                try {
                    BufferedReader in1 = new BufferedReader(new FileReader("Text.txt"));
                    int nLineCount = 0;
                    while (in1.readLine() != null)
                    {
                        nLineCount++;
                    }
                    zeilenzahl = nLineCount;
                } 
                    catch(Exception e) {}
                return zeilenzahl;        
            }

            public static void main(String[] args) {
                
                char output[] = null;
                
                
                try{
                    File f = new File("Text.txt");
                    FileReader fr = new FileReader(f);
                    BufferedReader br = new BufferedReader(fr);
                    int z = 0;
                    
                    
                    int ze = resultat();
                    
                    while (z <= ze) {
                    String zeile = br.readLine();
                    char[] text = zeile.toCharArray();
                    output = new char[zeile.length()];
                    int a = 0;
                    int b = 0;
                    
                    while (text[a] != '\0') {
                        if (!(text[a] == ' ' && text[a+1] == ' ')) {
                            output[b] = text[a];
                            b++;
                            }
                        a++;
                            }
                        }
                    }
                catch (Exception e) {}    
                String ausagbe ="";
                for (int i = 0; output[i] != '\0';i++)
                {
                    System.out.print(output[i]);
                }

             {for (int i = 0; output[i] != '\0';i++) {
                    try {
                        File f2 = new File("Textbetatest.txt");
                        FileWriter fw = new FileWriter(f2);
                        fw.write(new String (output));
                            fw.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                }
             }
         }
    }
}
```


----------

