# TXT nach Zeilenumbruch in Array schreiben



## burny (19. Oktober 2010)

Hallo,

ich bin neu hier und will erst einmal kurz vorstellen. Mein Name ist Christian und ich habe vor kurzem angefangen zu programmieren, bis jetzt nur mit Java. 

Aktuell versuche ich ein kleines Programm zu schreiben, dass ein TXT einließt, dieses mit einer regular exception behandelt und das Ergebnis dann in ein String Array schreibt.

Die regex wird benutz um nach jeden Leerzeichen oder Tab in der TXT einen Zeilenumrbruch zu erzwingen, so dass jedes Wort in einer einzelnen Zeile steht, und diese einezelnen Wörter dann in ein Array zu lesen, welches ich dann für andere Sachen nutzen kann. 

Um das Problem mal anschlaulich zu machen hier folgendes Beispiel:


> Hallo dieses Dokument
> soll
> testen ob


Das ist der Inhalt des TXT, welches ausgelsen werden soll damit es wie folgt in ein Array gespeichert werden kann:



> Hallo
> dieses
> Dokument
> soll
> ...




Das ganze habe ich versucht wie folgt umzusetzen:


```
public static void main (String [] args)
	{
		String line;
		String [] array = new String [6];
		
		try
		{
			FileReader fread = new FileReader("C:\\test\\test.txt"); 
			BufferedReader in = new BufferedReader(fread); 
		
			for(int i = 0;(line = in.readLine())!=null; i++)
			{
				array[i] = line;
				Pattern p = Pattern.compile("[,\\s]+");
				String[] result = p.split(array[i]);

				for (int y=0; y<result.length; y++)
					array[i]=result[y];
			} //endfor
			
			System.out.println(array[0]); 
			System.out.println(array[1]);
			System.out.println(array[2]);
			System.out.println(array[3]);
			System.out.println(array[4]);
			System.out.println(array[5]);			
		} //endtry
		
		catch(IOException e)
		{
			System.out.println("IO-Fehler!");
		} //endcatch
	} //endmain
```

Klappt allerdings nicht so richtig, die Ausgabe ist nähmlich folgenden:


> Dokument
> soll
> ob
> null
> ...



Was mache ich flasch? Kann mir jemand helfen? Ich bin für jeden Tip dankbar!!

Danke und beste Grüße
Christian


----------



## Tim Bureck (19. Oktober 2010)

Naja, du gehst in deiner kleinen Forschleife alle Teilstrings durch und überschreibst immer wieder den Wert von array[i]. So steht in array[i] je der letzte Teilstring der Zeile.

1) Benutze statt String[] array eine ArrayList<String>. Die hat eine Variable Länge:


```
ArrayList<String> array = new ArrayList<String>();
```

2) Füge einfach alle Werte hinzu:


```
for (int y = 0; y < result.length; y++) {
  array.add(result[y]);
}
```

3) Die Ausgabe machst du dann so:


```
for (String s : array) { // lies: for (each) string (named) s (in) array
  System.out.println(s);
}
```


----------



## airtime (19. Oktober 2010)

Hi burny,

das ist ganz einfach. Dein Counter i läuft von 0 bis 2, weil drei zeilen eingelesen werden. Dann nimmst du die jeweiligen Zeilen und splittest sie. Die jeweiligen Ergebnisse pro Zeile schreibst/überschreibst du in dem array an der Stelle i. Somit hast du immer das letzte Wort des jeweiligen Satzes an der entsprechenden Stelle von i.
Das heisst 0 -> Dokument 1-> soll usw.

Um das flexibel zu machen solltest du lieber eine ArrayListe benutzten und einen Counter der ausserhalb der ersten for schleife initialisiert wird und dann immer mitläuft sobald ein Wort eingefügt wird.

Gruß Air


----------



## burny (19. Oktober 2010)

Hey vielen dank für die Antworten!! 

Warum meine Variante nicht funktioniert konnte ich nachvollziehen. Man lernt nie aus!! Aber ich bekomme es immer noch nicht wirklich hin, ich habe es versucht wie Tim es erklärt hat und habe nun folgenden Code:


```
public static void main (String [] args)
	{
		String line;
		ArrayList<String> array = new ArrayList<String>();
		
		try
		{
			FileReader fread = new FileReader("C:\\test\\test.txt"); 
			BufferedReader in = new BufferedReader(fread); 
		
			for(int i = 0;(line = in.readLine())!=null; i++)
			{
				array.add(line);
				Pattern p = Pattern.compile("[,\\s]+");
				String[] result = p.split(array.get(i));

				for (int y = 0; y < result.length; y++) 
				{
					  array.add(result[y]);
				}
			} //endfor
			

			for (String s : array)
			{ 
			  System.out.println(s);
			}			
		} //endtry
		
		catch(IOException e)
		{
			System.out.println("IO-Fehler!");
		} //endcatch
	} //endmain
```

Die Ausgabe ist aber immer noch nicht wie gewünscht, warum kann ich mir nicht erklären. An welcher Stelle im Code hackt es noch?

Folgendes wird ausgegeben:


> Hallo dieses Dokument
> Hallo
> dieses
> Dokument
> ...




Im Voraus schon vielen Dank!!


----------



## Tim Bureck (19. Oktober 2010)

Du solltest die aktuelle Zeile nicht zum Array hinzufügen. Du hast die einzelnen Worte ohnehin in der ArrayListe. Dazu musst du die split-Methode einfach line anwenden. Die for-Schleife mit der Zählervariable erübrigt sich damit auch.


```
while ((line = in.readLine()) != null) {
  String[] result = line.split("[,\\s]");
}
```

Objekt des Typs String haben übrigens auch eine split-Methode. Im Prinzip geschieht im Hintergrund genau das, was du geschrieben hast, aber so ist es doch übersichtlicher.


----------



## burny (19. Oktober 2010)

Super vielen Dank Tim. Klappt einwandfrei!

Danke!


----------



## rhô (20. Oktober 2010)

Hey burny,

du kannst dein Problem auch mit einem Array lösen, wenn du einen Scanner verwendest.


```
Scanner scanner = new Scanner(in);
```

Jetzt kannst du die Methode scanner.next() aufrufen, welche dir den nächsten (String-)Token liefert. Ein Token ist durch whitespace begrenzt, also was deine regex tun sollte.

Deine Schleife sähe dann so aus:


```
int i = 0;
while(scanner.hasNext() && i < array.length){
   array[i] = scanner.next();
   i++;
}
```

Im Schleifenkopf wird auch gleich geprüft, ob du noch in den Array-Grenzen bist.


----------



## Tim Bureck (20. Oktober 2010)

Dazu müsste er aber wissen, wie viele Wörter in der Datei stehen, sonst bekommt er unter Umständen nicht alle Wörter ins Array. Von daher ist der Ansatz der dynamischen ArrayList sicher der bessere Weg.


----------



## rhô (20. Oktober 2010)

Ich stimme dir auf jeden Fall zu, dass es besser ist mit einer ArrayList zu arbeiten. Allerdings hatte burny geschrieben, er möchte es ein einem String-Array speichern.
Die Anzahl der Wörter herauszufinden ist mit einem einfachen Zähl durchlauf kein Problem.


----------



## burny (21. Oktober 2010)

Hi,

der Umgang mit der ArrayList ist aufjeden Fall einfacher. Ich habe zu Beginn nach einem StringArray gefragt, weil ich bis dahin noch nichts von einer ArrayList wusste.

bezüglich des Splitten einer Zeile. Meine Idee war ja, das TXT auszulesen mit einer regex nach jedem vorkommenden Tab zu suchen und dann einen Zeilenumrbuch zu erzwingen und die neuen Zeilen in die ArrayList zu lesen. 

Wenn ich aber folgendes verwende, werden die Zeilen nicht umgebrochen. 

```
while ((line = in.readLine()) != null) 
			{
				String[] result = line.split("[\\t]");

				for (int y = 0; y < result.length; y++) 
				{
					array.add(result[y]);
				}
			}

			for (String s : array)
			{ 
				System.out.println(s);
			}
```

Laut der Dokumentation ist "\t" der Ausdruck für Tabs. Wenn ich Als Regex ein Blank oder irgendwas anderes nahme klappt es, nur mit dem Tab nicht.
Hat das was mit der TXT zu tun, werden hier keine Tabs dargestellt oder warum klappt das nicht so wie ich mir das wünsche?

Danke schon mal!!
Gruß Christian


----------



## burny (21. Oktober 2010)

Mein zweites Problem ist gelöst, liegt an der Formatierung von dem TXT, dort sind keine Tabs. Wenn ich das TXT entsprechend mit Tabs vesehe dann klappt es.


----------



## Herbertus (21. Oktober 2010)

Windows benutzt für ein Zeilenende /r/n. (Carriage-Return ('\r'), ein Line-Feed ('\n'))

ASCII-Zeichen CR und LF.

Wenn du es leer lässt, wird standardmäßig daran ,gebrochen'.


----------

