Hallo Zusammen,
Mein Ziel ist es, eine Klasse zu schreiben, die mehrere Strings in ein Dokument schreibt und wieder auslesen kann.
Dafür verwende ich in ein String[].
Es sind die Zeilen 103, 123 sowie die Methode saveData(), die Probleme machen:
Zeile 103/123: Liefert trotz Datentypkonvertierung null zurück
saveData(): Speichert die Strings nicht in das Dokument ab.
Des weiteren wäre ich dankbar, wenn ihr mir Tipps geben könntet, wie ich Zeilenumbrüche des String[] so zu verändern, dass sie beim erneuten Einlesen wieder in den gleichen Index des String[] kommen.
Zusätzlich habe ich das Gefühl, dass die Klasse createNewFile() ihre Aufgabe nicht richtig ausführt.
Hier mal die komplette Klasse:
Mein Ziel ist es, eine Klasse zu schreiben, die mehrere Strings in ein Dokument schreibt und wieder auslesen kann.
Dafür verwende ich in ein String[].
Es sind die Zeilen 103, 123 sowie die Methode saveData(), die Probleme machen:
Zeile 103/123: Liefert trotz Datentypkonvertierung null zurück
saveData(): Speichert die Strings nicht in das Dokument ab.
Des weiteren wäre ich dankbar, wenn ihr mir Tipps geben könntet, wie ich Zeilenumbrüche des String[] so zu verändern, dass sie beim erneuten Einlesen wieder in den gleichen Index des String[] kommen.
Zusätzlich habe ich das Gefühl, dass die Klasse createNewFile() ihre Aufgabe nicht richtig ausführt.
Hier mal die komplette Klasse:
Java:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
* Diese Klasse speichert Variablen des Datentyps String in Doukente ab, erzeugt bei Bedarf dementsprechende Datei.
*/
public class Speichern {
private String nameOfData;
public int numberOfLines;
private File data;
private String[] stringArray;
/**
*TODO write text
*/
// BUG!
private void saveData(){
BufferedWriter out;
try {
out = new BufferedWriter(new FileWriter(nameOfData));
// Erste Zeile enthält die Anzahl der Zeilen
out.write(String.valueOf(numberOfLines));
out.newLine();
for (int i = 0; i < numberOfLines; i++){
out.write(stringArray[i]);
out.newLine();
}
out.close();
} catch (IOException e) {
}
}
/**
* TODO write text
*/
private void createNewFile(){
data = new File(nameOfData + ".txt");
}
/**
* TODO write text
* @param newNumberOfLines
*/
private void copyArrayWithAttributes(int newNumberOfLines){
countLinesOfArray();
if (!(numberOfLines == 0)) {
String[] bufferArray = new String[numberOfLines];
for (int i = 0; i < numberOfLines; i++){
bufferArray[i] = stringArray[i];
}
stringArray = new String[newNumberOfLines];
for (int i = 0; i > numberOfLines; i++){
stringArray[i] = bufferArray[i];
}
}
numberOfLines = newNumberOfLines;
}
/**
* TODO write text
* @return
*/
public boolean deleteData(){
return data.delete();
}
/**
* TODO write text
* @return
*/
public int getNumberOfLinesOfArray(){
return stringArray.length;
}
/**
* TODO write text
*/
//TODO try out
private void countLinesOfArray(){
numberOfLines = getNumberOfLinesOfArray();
}
/**
* TODO write text
* @return
*/
// BUG!
public int getNumberOfLinesOfDocument(){
BufferedReader in;
try {
in = new BufferedReader(new FileReader(nameOfData));
return Integer.parseInt(in.readLine()); //TODO: bug Datentypkonvertierung
} catch (FileNotFoundException e) {
return -1;
} catch (NumberFormatException e) {
return -1;
} catch (IOException e) {
return -1;
}
}
/**
* TODO write text
*/
// BUG!
private void readFile(){
if (! (getNumberOfLinesOfDocument() == -1)){
BufferedReader in;
try {
in = new BufferedReader(new FileReader(nameOfData));
numberOfLines = Integer.parseInt(in.readLine());
stringArray = new String[numberOfLines];
for (int i = 0; i < numberOfLines; i++){
stringArray[i] = in.readLine();
}
in.close();
} catch (FileNotFoundException e) {
} catch (NumberFormatException e) {
} catch (IOException e) {
}
}
}
/**
* Appends the Array with the given String.
* <br> Hängt den übergebenen String an das Array an.
* @param stringToAppend String that is being appended <br> String, der angehängt wird
*/
public void appendString(String stringToAppend){
copyArrayWithAttributes(numberOfLines+1);
stringArray[numberOfLines-1] = stringToAppend;
saveData();
}
/**
* Replaces a String at given Index of the Array.
* <br> Ersetzt einen String an der angegbenen Stelle des Arrays.
* @param replacingString String that replaces <br> String, der ersetzt
* @param atIndex Index of the Array <br> Stelle des Arrays
*/
public void replaceString(String replacingString, int atIndex){
if ((atIndex <= numberOfLines) && (atIndex > 0)) {
stringArray[atIndex-1] = replacingString;
saveData();
}
}
/**
* Return the Sting of the Array, that is stored at given Line.
* <br> Liefert den Sting des Arrays, der am eingegeben Zeile gespeichert ist.
* @param atIndex Line of the String <br> Zeile des Strings
* @return String of the Array stored at given Line <br> String des Arrays der eingegbenen Zeile
*/
public String getString(int atIndex){
if (atIndex <= numberOfLines){
return stringArray[atIndex];
} else return null;
}
/**
* TODO write text
* @param newNumberOfLines
*/
public void setNewNumberOfLines(int newNumberOfLines){
if ((numberOfLines < newNumberOfLines) || (numberOfLines > newNumberOfLines)) {
copyArrayWithAttributes(newNumberOfLines);
}
}
/**
* TODO write text
* @param newStringArray
*/
public void setNewStringArray(String[] newStringArray){
stringArray = new String[newStringArray.length];
for (int i = 0; i < newStringArray.length; i++){
stringArray[i] = newStringArray[i];
}
numberOfLines = newStringArray.length;
}
/**
* TODO write text
* @param dataName
*/
public Speichern(String dataName){
// Objekt wird beendet, sofern kein DateiName übergeben wird.
if (dataName == null) return;
nameOfData = dataName + ".txt";
data = new File(nameOfData);
if (data.exists()){
readFile();
} else {
createNewFile();
numberOfLines = 0;
stringArray = new String[numberOfLines];
}
}
}
Zuletzt bearbeitet:
