# Scanner + Stringbuilder geben leeren String aus wenn Umlaute enthalten sind



## Framehacker (1. Dez 2013)

Hallo Java Community  

Ich habe das Problem das der aus einer Textdatei mittels Scanner und Stringbuilder
eingelesene Text nicht in einer String Variable Gespeichert wird wenn er umlaute enthält.


```
package scannertest;

import java.io.File;
import java.util.Scanner;


public class ScannerTest {


    public static void main(String[] args) throws Exception {
        // TODO code application logic here
        StringBuilder sb = new StringBuilder();
        String messageContent;
        
        Scanner smas = new Scanner(new File("test2.txt"));
        while(smas.hasNextLine()) {
            sb.append(smas.nextLine()+ "\r\n");
        }
        messageContent = sb.toString();
        System.out.println(messageContent);
        
    }
}
```
Wenn die Textdatei keine umlaute enthält funktioniert es. ansonsten ist die Ausgabe leer.

Wie kann ich ihn dazu bringen mir einen Text mit umlauten auszugeben?


----------



## kaoZ (1. Dez 2013)

hast du mal versucht diese durch 
	
	
	
	





```
.replace()
```
 zu ersetzen 

sprich , so in der art, (hier ohne abfrage,ob Umlaute vorhanden)

```
String s = sc.nextLine().replace("ä","ae");
```


----------



## Framehacker (1. Dez 2013)

geht leider auch nicht

Nach Möglichkeit hätte ich das ä aber schon gerne in der Variable und kein ae.


----------



## kaoZ (1. Dez 2013)

liest er einfach nichts ein, oder bekommst du eine Fehlermeldung ?

hast du die Variable mal per sysout. oder per debugger geprüft, ob überhaupt etwas in der variable speichert wird?

[EDIT]
gibt es einen besonderen grund warum du hier eine lösung über einen Stringbuilder gewählt hast / wählen möchtest ?
[/EDIT]


----------



## turtle (1. Dez 2013)

Woraus meinst du zu erkennen, das Scanner nicht richtig arbeitet?

Ich habe deinen Code gerade mal 1:1 ausprobiert und bei mir läuft es problemlos.


----------



## kaoZ (1. Dez 2013)

Wie schon gesagt wäre mal interessant was in deiner Variable gespeichert wird wenn du es mal debuggst

funktioniert bei mir nämlich auch ohne Probleme.


----------



## Framehacker (1. Dez 2013)

In meiner Text datei steht imo 





> Das ist ein Text
> ohne Umlaute


 Der wird auch ausgegeben. Bau ich aber einen Umlaut ein in etwa so


> Das ist ein Text
> mit den Umlaut ä


 gibt er mir einen leeren String zurück. Ich hänge die Datei mal an.



kaoZ hat gesagt.:


> [EDIT]
> gibt es einen besonderen Grund warum du hier eine Lösung über einen Stringbuilder gewählt hast / wählen möchtest ?
> [/EDIT]


Bis auf das ich noch ein ziemlicher Java Anfänger bin und ich derzeit keine andere Lösung dafür finde eigentlich nicht.


----------



## kaoZ (2. Dez 2013)

Wenn du noch erklärungen brauchst einfach fragen ich erkläre es gern 


```
package versuche;

import java.io.File;
import java.util.ArrayList;
import java.util.Scanner;


public class Foo{
	
	Scanner sc;
	File file;
	ArrayList<String> output;
	final static String LINEBREAK = "\r\n"; // <-- Konstante , insofern ein Zeilenumbruch nötig sein sollte. ( Hier nicht notwendig )

	//Konstruktor
	Foo() throws Exception{
		
		file = new File("H:/Apps/Test.txt");
		sc = new Scanner(file);
		output = new ArrayList<String>();
		
		String line="";
	
		//Liest das Dokument ein 
		while(sc.hasNextLine()){
			
			line = sc.nextLine();
			output.add(line);
			
		}
		sc.close(); // scanner schließen
	}
	
	//Datei in der Konsole ausgeben 
	void ausgeben(){
		
		String out="";
		
		for(String s : output){
			out = s; 
			System.out.println(out);
		}
		
	}
	
	// Code Testen
	public static void main(String[]args){
		
		// Try & Catch Block da java.io eine Exception auslösen kann 
		try{ 
		new Foo().ausgeben();
		}
		catch(Exception ex){
			System.out.println("Etwas ist schief gegangen ?!");
			ex.printStackTrace();
		}
	}
}
```

Ausgabe ist folgende ( mit meinem Beispieltext ) :


```
Dieser Text beinhaltetet viele Sonderzeichen und Umlaute,
trotzdem wird der Text einwandfrei eingelesen 
äöü:_*`!"§$%&&/()
```

[TIPP]Aus performancegründen würde ich allerdings empfehlen das ganze , je nach länge deiner Datei, mit einem BufferedReader zu machen , anstatt mit einem Scanner [/TIPP]


----------



## Framehacker (2. Dez 2013)

Danke für deine Mühe ich habe den code mal so bei mir umgesetzt

```
package scannertest;

import java.io.File;
import java.util.ArrayList;
import java.util.Scanner;

public class ScannerTest {
    
    Scanner sc;
    File file;
    ArrayList<String> output;
    final static String LINEBREAK = "\r\n";
    
    ScannerTest() throws Exception {
        file = new File("test2.txt");
        sc = new Scanner(file);
        output = new ArrayList<String>();
        
        String line = "";
        while (sc.hasNextLine()){
            line = sc.nextLine();
            output.add(line);
        }
        sc.close();
    }
    void ausgabe(){
        String out = "";
        for (String s: output){
            out = s;
            System.out.println(out);
        }
    }
    
    public static void main(String[] args) throws Exception {
        // TODO code application logic here
            new ScannerTest().ausgabe();
        
    }
}
```
Problem ist aber leider das selbe ohne Umlaut erscheint der Text in der Ausgabe und mit Umlaut bleibt der String und mit ihn die Ausgabe leer.


----------



## rme (2. Dez 2013)

Welches Encoding hat deine Textdatei eigentlich? Wenn es nicht Unicode ist, musst du die Strings erstmal umwandeln.. vielleicht ist deine Datei z.B. mit ISO-8859-1 codiert?


----------



## kaoZ (2. Dez 2013)

Setz mal ein Unterbrechungspunkt und debug an der stelle dein Programm mal , am besten machst du einen Screenshot und postest den hier mal, dann kann man mal sehen warum er bei deiner datei keine Sonderzeichen zulässt , funktioniert eigentlich reibungslos

ggf. stimmt auch die Codierung deiner Textdatei nicht .


----------



## Framehacker (2. Dez 2013)

Sry verstehe gerade irgendwie nur Bahnhof . Underbrechungspunkt? Debug? und das ich Einfluss auf die Codierung einer Textdatei nehmen kann wusste ich bis heute auch nicht.

falls es von Interesse ist ich nutze Netbeans


----------



## kaoZ (2. Dez 2013)

Du solltest dich ggf. erstmal damit auseinandersetzen wie man per debugging Fehler in einem Programm erkennt, dazu gibt es genügend tutorials im Netz

Hier ein kleines Bsp. wie es in Eclipse aussehen kann :

Ein String der über erzeugen eines neuen Foo Objectes mit einem Text initialisiert wird, wird über die Methode print ausgegeben, per Debugging kann man einen Breakpoint setzen um zu prüfen ob der String bei der erstellung z.B des Objectes auch mit dem gewünschten Text initialisiert wird.

Der Breakpoint (hier leider nicht erkennbar) ist in der main Methode beim erstellen des Objektes gesetzt und unterbricht die Ausführung des Programms um z.B auf einen vorhandenen String , wie in unserem Fall zu prüfen.


----------



## kaoZ (2. Dez 2013)

hier nochmal ein Beispiel beim debuggen wenn der String zwar deklariert aber nicht initialisiert wird :





Java initialisiert Strings die keinen "Wert(Text)" enthalten, standartmäßig mit Null.

[TIPP]Dies kann je nach Situation auch zu einer NpE führen![/TIPP]

Hier gut zu erkennen ist der gesetzte Breakpoint, an welchem die Ausführung des Programmes unterbrochen wird.

Demnach wird das Programm in der main Methode *nach * erzeugen eines (in diesem Fall) referenzlosen Foo objektes, *beim* aufrufen der print Methode unterbochen.


----------



## Framehacker (2. Dez 2013)

das ist dabei raus gekommen








bis auf die final Variable erscheint irgendwie nichts im Variablen Reiter. Keine Ahnung warum :bahnhof: . Und wenn ich das + bei class drücke kommt nur das ganze zeug was wohl zur class klasse gehört und mit meinen Problem wohl nichts zu tun hat.


----------



## kaoZ (2. Dez 2013)

Setz den Breakpoint mal vor deine Methode Ausgabe , so wird zumindest der Konstruktor der Klasse aufgerufen , also in Zeile 41, und geh mit deinem Mauszeiger mal auf den String wie in meinem Beispiel, dann zeigt er dir an was in diesem String den du über deine Methode ausgabe ausgeben möchtest zu dem zeitpunkt gespeichert ist 

du kannst auch mal schauen was passiert wenn du die eingelesene Zeile während der Schleife direkt ausgibst:

so in der art 

```
package versuche;

import java.io.File;
import java.util.Scanner;

public class Foo{

	
	Foo() throws Exception{
		
		File file = new File("H:/Apps/Test.txt");
		String output ="";
		Scanner sc= new Scanner(file);
		
		while(sc.hasNext()){
			output = sc.nextLine();
			
			System.out.println(output); // <-- Hier wird direkt das Ausgegeben was der Scanner einliest!
		}
		sc.close();	
				
	}
	
	public static void main(String[]args){
		try{
		new Foo();
		}catch(Exception ex){
			System.out.println("fehler !");
		}
	}
	
	
}
```

dies führt bei mir zu folgender Ausgabe :


```
öäöäöäööööööö.,-p?§$"%$/&%(/)/(/()"!§!"§"!$§$%ÖÄÖÄÖÄÖÄÖÄ
öÄÖÄÖÄ
ÖÄÖÄ
ÖÄ
ÖÄ
ÖÄ
ÖÄ&/(/&(/=)()=
```


----------



## Framehacker (3. Dez 2013)

ok danke das sieht schon besser aus was der debugger nun ausgibt.




das kommt raus wenn keine umlaute enthalten sind



und das passiert wenn ich den Inhalt der Textdatei nach


> Das ist ein Text
> mit den Umlaut ä


 umändere


----------



## njans (3. Dez 2013)

Ehm bei ausgabe(), wieso weist du out immer nur den String zu ?


----------



## kaoZ (3. Dez 2013)

An dieser Stelle , wenn es nur um Ausgabe in der konsole geht, kannst du auch einfach nur 
das hier Schreiben:


```
for(String s : output){
  System.out.println(s);
}
```
 
, die lokale Variable String out war nur falls du mit den Strings noch weiter arbeiten wollen würdest, ist hier aber nicht notwendig da du schon in der Schleife den Text Zeilenweise ausgibst. 

Dennoch ist es schon komisch das er , insofern ein Sonderzeichen enthalten ist, nichtmal den Rest der Datei einliest.

Wenn die Codierung nicht stimmen sollte, müsste ja im normalfall trotzdem der Text in der Datei eingelesen werden der keine Sonderzeichen enthält.

In seinem Fall bleibt aber die ArrayList komplett leer so wie es aussieht.

gib mal in Ausgabe bitte noch die länge der Arraylist mit 
	
	
	
	





```
System.out.Println(output.length);
```
 aus

und poste mal welche zahl dann in der konsole Steht wenn du mit / und ohne Sonderzeichen einliest.

[TIPP]
Steck mal das einlesen in einen Try/Catch block und versuch mal die Textdatei mit Sonderzeichen dann einzulesen .
[/TIPP]

Ändere dazu mal Zeile 34-40 folgendermaßen :


```
sc = new Scanner(file);

try{
while(sc.hasNext()){
 output.add(sc.nextLine());
}
catch(Exception ex){
  ex.printStackTrace(); // <- Falls jetzt eine Exception geworfen werden sollte, steht dies in deiner konsole und ist für uns sichtbar
}
sc.close();
}
```

da bei dir der Konstruktor zwar durch(*throws Exception*) deklariert das er eine Exception werfen kann , aber keine Ausnahmebehandlung durch einen catch - Block angegeben ist, ändere den Code mal wie oben beschrieben, und poste mal das was beim/nach ausführung in deiner Konsole steht.


----------



## turtle (3. Dez 2013)

Ich habe gerade mal mit NetBeans 7.4 das Programm laufen lassen.. Ohne Pobleme.

Im Debugger hält das Programm an und ich sehe die Umlaute in der Variables-View.

Bei mir ist (natürlich) das Encoding des Projekts (unter Properties/Sources auf UTF-8) gestellt.

Leider weiss ich nicht, ob und wie man das in Netbeans nur für einige Dateien oder ein ganzes Projekt ändert. Ich verwendet Eclipse.


----------



## kaoZ (3. Dez 2013)

kaoZ hat gesagt.:


> gib mal in Ausgabe bitte noch die länge der Arraylist mit
> 
> 
> 
> ...



mein Fehler diesbezüglich, es ist natürlich 
	
	
	
	





```
System.out.println(output.size());
```
 wenn es sich um eine ArrayList handelt

[EDIT]
Ich kann turtle nur zustimmen, da ich auch ausschliesslich mit Eclipse arbeite, kann ich dir auch nicht sagen ob evtl. dein komplettes Projekt durch eine der NetBeans Voreinstellung eine Falsche Codierung verwendet.

Normalerweise klappt das einlesen egal ob mit Scanner oder Reader( in sämlichen abstaktionen) reibungslos, auch mit Sonderzeichen oder Umlauten.
[/EDIT]

[TIPP]
Ich würde ggf. NetBeans mal neu aufsetzen/ zu einer Neuinstallation raten, insofern sich im Netz keine Infos zur Einstellung der Codierung finden lassen.
[/TIPP]


----------



## Framehacker (3. Dez 2013)

Habe mal mein Netbeans und auch das JDK auf den neusten stand gebracht vorher aber Netbeans inklusive seinen Einstellungen gelöscht. Leider ohne Besserung und in den Projekteinstellungen ist auch bei Kodierung UTF-8.

mein code sieht jetzt so aus

```
package scannertest;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Scanner;

public class ScannerTest {

    Scanner sc;
    File file;
    ArrayList<String> output;
    final static String LINEBREAK = "\r\n";
    
    ScannerTest() throws FileNotFoundException {
        file = new File("test2.txt");
        sc = new Scanner(file);
        output = new ArrayList<String>();
        
        String line = "";
        try{
        while (sc.hasNextLine()){
            line = sc.nextLine();
            output.add(line);
        }
        } catch (Exception ex){
            ex.printStackTrace();            
        }
        sc.close();
    }
    void ausgabe(){
        String out = "";
        for (String s: output){
            //out = s;
            System.out.println(s);
        }
        System.out.println("Size: "+output.size());
    }
    
    public static void main(String[] args) {
        try {
            // TODO code application logic here
            new ScannerTest().ausgabe();
        } catch (FileNotFoundException ex) {
            ex.printStackTrace(); 
        }
        
    }
}
```

ausgabe ohne umlaute ist


> Das ist ein Text
> ohne Umlaut
> Size: 2
> BUILD SUCCESSFUL (total time: 0 seconds)


und mit umlaute ist die ausgabe


> Size: 0
> BUILD SUCCESSFUL (total time: 0 seconds)


----------



## kaoZ (3. Dez 2013)

Ok das ist schon irgendwie kurios , wenn die Codierung stimmt , der Scanner komplett text ohne umlaute einliest, und sobald umlaute in der datei vorhanden sind garnichts eingelesen wird.

ich würde einfach mal einen Scanner erstellen der die konsoleneingabe einliest und direkt wieder ausgibt,

und dort einfach mal Umlaute eingeben und schauen ob diese überhaupt ausgegeben werden.

Irgendwie muss man ja dem Problem auf die schliche kommen


----------



## kaoZ (3. Dez 2013)

Was passiert denn wenn du bei dir das mal Kompilierst 


```
public class Foo{

	Foo(){
	
		System.out.println("\u00F6");  // <--- Unicode Escape für ö
	
	}
	public static void main(String[]args){
		new Foo();
	}
}
```

Ausgabe

```
ö
```


----------



## turtle (3. Dez 2013)

Ich schlage vor, vielleicht mal das Mini-programm in Eclipse zu versuchen?


----------



## Framehacker (3. Dez 2013)

das mit den ö funktioniert.



turtle hat gesagt.:


> Ich schlage vor, vielleicht mal das Mini-programm in Eclipse zu versuchen?


damit würde ich vor den Problem ja nur Weglaufen und ich suche ja eine lösung.


habe mal Probiert die kodierung auf "ISO-8859-1" zu stellen und den Funktioniert es und er gibt mir den Text mit umlauten vernünftig aus. UTF-8 unterstützt bei mein Netbeans wohl keine Umlaute???:L

[EDIT]Konnte den ganzen Spaß jetzt auch mit UTF-8 in den Einstellung zum laufen bringen indem ich einfach den scanner das Charset mitgegeben habe[/EDIT]


```
package scannertest;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Scanner;

public class ScannerTest {
    
    Scanner sc;
    File file;
    ArrayList<String> output;
    final static String LINEBREAK = "\r\n";
    
    ScannerTest() throws FileNotFoundException {
        file = new File("test2.txt");
        sc = new Scanner(file, "ISO-8859-1");
        output = new ArrayList<String>();
        
        String line = "";
        try{
        while (sc.hasNextLine()){
            line = sc.nextLine();
            output.add(line);
        }
        } catch (Exception ex){
            ex.printStackTrace();            
        }
        sc.close();
    }
    void ausgabe(){
        String out = "";
        for (String s: output){
            //out = s;
            System.out.println(s);
        }
    }

    public static void main(String[] args) {
        try {
            // TODO code application logic here
            new ScannerTest().ausgabe();
        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        }
        
    
    }
}
```
ausgabe ist jetzt



> Das ist ein Text
> mit den Umlaut ä
> BUILD SUCCESSFUL (total time: 0 seconds)



Danke für die viele Hilfe :toll:


----------



## kaoZ (3. Dez 2013)

Mh, trotzdem Merkwürdig , kannst es ja nochmal mit UTF-16 versuchen und mal schauen ob er die Umlaute dann darstellt, ansonsten einfach den Danke Button nutzen falls es hilfreich war :toll:


----------



## turtle (3. Dez 2013)

> damit würde ich vor den Problem ja nur Weglaufen und ich suche ja eine lösung.


weglaufen würde ich dazu nicht sagen..

Denn Problem war ja eindeutig identifiziert, das das Encoding beim Scanner falsch war. 

Dies kann man auf verschiedene Arten umstellen. Bei mir sind ALLE Workspaces in Eclipse auf UTF-8 gestellt und weiss das NetBeans Probleme mit unterschiedlichen Encodings in einem Projekt hat.

Aber trotzdem schön, das wir helfen konnten


----------



## Framehacker (3. Dez 2013)

Ausgabe mit UTF-16


> 䑡猠楳琠敩渠呥硴�
> 浩琠摥渠啭污畴⃤
> �






> ansonsten einfach den Danke Button nutzen


 gibt selbstverständlich ein danke für euch beide


----------



## kaoZ (3. Dez 2013)

UTF 16 ist doch auch hübsch xD :lol:


----------

