# Werte in eine Textdatei schreiben



## Randomat2000 (21. Okt 2013)

Hi,

bisher bin ich auf keine exakte Lösung für mein Problem gestoßen. Folgendes:

Ich muss ein Programm schreiben, mit dem ich eine Textdatei erstellen kann, in die Variablen verschiedener Datentypen hineingeschrieben werden können.

Bisher sieht das Programm bei mir folgend aus:


```
import java.io.*;

public class Textschreiber
{
	String s;
	int i;
	float f;
	char ch;
	
	public void textSchreiben() throws IOException{

		Writer eineTextdatei = null;

		try
		{
			eineTextdatei = new FileWriter("Textdatei.txt");		//neue Textdatei wird erstellt
			eineTextdatei.write();						//eingabe auslesen
		}
		
		catch ( IOException e )
		{
		  System.err.println( "Datei konnte nicht erstellt werden" );	//wenn fehlerhafte eingabe, wir diese Zeile gedruckt
		}
		
		finally
		{
		  if ( eineTextdatei != null )
		    try 
		  	{
		    	eineTextdatei.close();
		    } 
		  	catch ( IOException e )
		  	{
		  		e.printStackTrace();
		    }
		}
    }
	
}
	
}
```

Meine Frage ist: Wie kann ich es ermöglichen, dass beliebig viele Werte verschiedener Datentypen hineingeschrieben werden können?

MfG

Randomat2000

PS: Bin mir nicht ganz sicher ob das noch in die Basics hineingehört sorry wenn ich mich irren sollte^^´


----------



## kaoZ (21. Okt 2013)

mit ArrayLists verschiedener Datentypen , würde ich jetzt einfach mal sagen ^^,

was genau möchtest du denn in die Datei schreiben ?


----------



## Randomat2000 (21. Okt 2013)

Um das bisschen einzuschränken wollte ich ein String, int, char und float hineinschreiben. Und ich sollte noch vielleicht erwähnen dass sie über die Konsole eingelesen werden sollen.


----------



## kaoZ (21. Okt 2013)

dann brauchst du ein Scanner Object der die konsoleneingabe ausließt

problem ist dabei das die Klasse Scanner entweder Strings oder int werte auslesen kann, also müsstest du Strings nehmen und dann jeweils auf den von dir gewünschten wert parsen lassen, und diesen dann einer arraylist hinzufügen


----------



## kaoZ (21. Okt 2013)

oder du erstellst eine abfrage, wo man erst auswählen kann was genau du der "Datei" hinzufügen willst und dann der jeweiligen arraylist den wert, Datentyp hinzufügt, allerdings ist das nicht wirklich flexibel


----------



## kaoZ (21. Okt 2013)

> eineTextdatei.write(); //eingabe auslesen



das liest übrigends keine eingabe aus sondern schreibt in eine Datei, was genau geschriben werden soll ist hier allerdings noch nicht definiert, hier würde jetzt z.B das Scanner objekt benötigt werlches per 
	
	
	
	





```
.nextLine()
```
 den in der Console eingegebenen Text einliest und in die Textdatei schreibt.


----------



## kaoZ (21. Okt 2013)

hier mal ein kleines beispiel

```
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.util.Scanner;

public class Foo
{
	Scanner scan;
	BufferedWriter writer;
	File file;
	
	public static void main(String[]args)
	{
		try
		{
			new Foo().start();
		}
		catch(Exception ex)
		{
			System.out.println("Datei konnte nicht erstellt werden !");
		}
		
	}

	private void start() throws Exception{
		
		file = new File("H:/Apps/text.txt"); 
      /*neue Datei wird angelet in sofern noch nicht vorhanden,
       * mit (text.txt, true) könnte man hier der 
       *datei immer hinzufügen anstatt sie jedesmal zu überschreiben 
       */
		scan = new Scanner(System.in);
		writer = new BufferedWriter(new FileWriter(file));
		
		writer.write(scan.nextLine()); //schreibt die vom Scanner ausgelesene Zeile in die Textdatei
		writer.close(); // schließt den Writer
                scan.close(); // schließt den scanner
		
	
		
	}
	
}
```


----------



## Ikaron (21. Okt 2013)

Wie willst du denn die Datentypen abspeichern? Als eine einfache String-Representation?
Dann kannst du diese einfach über die Kommandozeile einlesen:

```
Scanner sc = new Scanner(System.in);
while(sc.hasNextLine())
{
    String line = sc.nextLine(); // line ist schon die String-Representation der Zahl etc...
    if(line.equalsIgnoreCase("exit")) // Eingabe wird mit "exit" beendet
        break;
    write(line); // Diese Zeile musst du mit der write-Anweisung von deinem OutputStream/Writer ersetzen, die Strings verarbeitet.
}
```


----------



## Randomat2000 (22. Okt 2013)

Genaue Angaben ob sie als String eingelesen werden müssen wurden in der Aufgabenstellung nicht gemacht, allerdings würde ich wenn möglich, nicht allzu kompliziert und vermeidbar typecasting umgehen und die Werte als den Datentyp abspeichern den ich auch eingetippt habe, da ich in einer späteren Methode nochmal die Werte aus der txt-Datei auslesen und als andere Datentypen interpretieren muss.


----------



## kaoZ (22. Okt 2013)

Es kann per Scanner nur als string , oder int eingelesen werden,  insofern Du unbedingt als Datentyp speichern musst wirst du um das Parsen / casten nicht herum kommen. , bedenke aber Wenn du den scanner auf Integer auslegen solltest,  du auch nur ganzzahllen in der console eigeben solltest,  da ohne Ausnahmebehandlung dein program sonst zur Laufzeit hochgeht,  ich würde einfach wie schon  beschrieben Strings einlesen , ggf . Parsen und speichern,  und dann per writer in die Datei ausgeben lassen.


----------



## kaoZ (22. Okt 2013)

Schau dir am besten erstmal die Scanner API an,  da Siehste Schon was machbar ist und was nicht


----------



## kaoZ (22. Okt 2013)

Außerdem tippst Du ja keine Datentypen ein singen Text,  also ebend strings,  die z.b zahlen enthalten, die kannst, wenn du den eingegeben string parst, also auf bestimmte Datentypen prüfst
In den richtigen Typ konvertieren,  bzw casten,  insofern notwendig, angenommen Du gibst "257" in deiner Konsole ein dann müsstest du 

```
int a = Integer.parseInt (sc.nextLine ());
```
In deinem code Schreiben, allerdings muss dir bewusst sein,  dass wenn du jetzt ohne exception handling,  oder if Anweisung für das Parsen arbeitest,  und du keine zahlen eingibst,  das ganze
Eine exception wirft.


----------



## Ikaron (22. Okt 2013)

Da es als TEXT-Datei gespeichert werden soll, muss es nicht erst zu int, etc.. umgewandelt werden. Man kann 1 zu 1 den Input der Kommandozeile kopieren, das Programm muss ja nicht wissen, was für ein Datentyp das jetzt ist.


----------



## kaoZ (23. Okt 2013)

wenn er alles als TEXT speichern will nicht , wenn er allerdings in verschiedenen Datentypen speichern will müsste er den TEXT jeweils auf den von ihm gewünschten Datentyp parsen.


----------



## Ikaron (23. Okt 2013)

Das geht aber aus dem OP hervor...


----------



## Randomat2000 (24. Okt 2013)

Danke für die Hilfe bis hierhin! Das Erstellen der Textdatei und einlesen von Werten geht schon mal, jetzt müsste ich nur wissen wie ich das Programm erkennen lassen kann was der urprüngliche Datentyp des Werts, den ich eingelesen habe, ist, damit ich ihn in einen anderen Datentyp umwandeln kann.


```
import java.io.*;


public class Textleser {
	
	String s;
	int i;
	char c;
	float f;
	
	public void textDateilesen()
	{
		try
		{
            BufferedReader reader = new BufferedReader (new FileReader("Textdatei.txt"));
            s = reader.readLine();

            while ((reader.readLine()) != null)
            {
            	if ()	//Wenn der ursprünglich eingelesene Wert Int ist, ändere ihn in float.
            	{
            		f = new Float(reader.readLine()).floatValue();
            	}
            	else if ()	//Wenn der ursprünglich eingelesene Wert Char ist, ändere ihn in int.
            	{
            		i = new Integer(reader.readLine()).intValue(); 
            	}
           }
		}
    		
		catch (FileNotFoundException e)
    	{
    		System.out.println("IOERROR: Datei nicht gefunden:\n");
    			e.printStackTrace();
    	} 
    	
		catch (IOException e)
    	{
    		System.out.println("IOERROR: " + e.getMessage() + "\n");
    		e.printStackTrace();
    	}
	}

}
```


----------



## Randomat2000 (24. Okt 2013)

also wie tu ich das richtig casten für die Bedingung?


----------



## Ikaron (24. Okt 2013)

Randomat2000 hat gesagt.:


> also wie tu ich das richtig casten für die Bedingung?



Du könntest so etwas machen:


```
public static boolean isNumber(Class<? extends Number> c, String methodName, String in) {

    try {
        c.getMethod(methodName).invoke(null, in);
    } catch(Exception e) {

        return false;
    }
}

// Und dann z.B:
// isNumber(Float.class, "parseFloat", readLine);
```


----------



## eRaaaa (24. Okt 2013)

Uff, hier mit Reflection rum zu werfen ist doch leicht übertrieben!
Vor allem verstehe ich eins nicht, hier ist doch schon das Wort "Scanner-Klasse" gefallen. Habt ihr euch die API Doc mal durchgelesen? Da gibt es auch Methoden wie hasNextInt und hasNextFloat...
Dementsprechend liest der Scanner den Typen dann auch ein, das geht dann von der Konsole genauso wie auch aus der Datei!
Grob:

```
Scanner sc = new Scanner(System.in); //oder eben aus txt-Datei anstelle System.in
		System.out.println("Int, Float oder String eingeben:");
		while(sc.hasNext()){
			if(sc.hasNextInt()){
				System.out.println("INT "+sc.nextInt()); //wichtig dass die Abfrage auf Int vor der Abfrage von Float steht
			}else if(sc.hasNextFloat()){
				System.out.println("FLOAT "+sc.nextFloat());
			}else if(sc.hasNextLine()){
				System.out.println("STRING "+sc.next());
			}
		}
		sc.close();
```


----------



## kaoZ (24. Okt 2013)

komisch, habe ich alles bereits erwähnt .....



kaoZ hat gesagt.:


> Schau dir am besten erstmal die Scanner API an,  da Siehste Schon was machbar ist und was nicht



desweiteren sind die Datentypen die du haben möchtest nur relevant insofern du aus der von dir erstellten Textdatei auslesen willst und dann die dementsprechenden Typen brauchst, in der Textdatei steht halt nur Text, also Strings, welche du beim einlesen(per BufferedReader) in den Richtigen typ casten kannst, um z.B damit zu rechnen etc.

wenn es nur darum geht per konsole in eine Textdatei zu schreiben , reicht es per [c].nextLine()[/code] die eingabe zu erfassen und dann z.B per BufferedWriter 
	
	
	
	





```
.write()
```
 in die Datei zu schreiben.

PS: wenn du deine Daten nur in deinem Programm benötigst und die Werte dieser sich nicht ändern, würde ich auch mal darüber nachdenken mit Serialisierung zu arbeiten (insofern du Deine daten unverändert Zwischenspeichern willst) um sie z.B zu einem späteren Zeitpunkt wieder einzulesen.

andernfalls natürlich in einer xyz.txt Textdatei


----------



## Randomat2000 (24. Okt 2013)

Oh ok allerdings kann ich ja eRaaaas Beispiel benutzen als Alternative für den Bufferedreader? (nur so aus Neugierde)



Ikaron hat gesagt.:


> Du könntest so etwas machen:
> 
> 
> ```
> ...




Ich verstehe ehrlich gesagt nicht was der Code genau bewirken soll...(wozu 
	
	
	
	





```
invoke()
```
 etc..)


----------

