Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
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.
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
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
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
Code:
.nextLine()
den in der Console eingegebenen Text einliest und in die Textdatei schreibt.
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
}
}
Wie willst du denn die Datentypen abspeichern? Als eine einfache String-Representation?
Dann kannst du diese einfach über die Kommandozeile einlesen:
Java:
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.
}
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.
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.
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
Java:
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.
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.
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.
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.
Java:
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();
}
}
}
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:
Java:
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();
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
Code:
.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.