Input/Output Hilfe..txt Datei zeile verändern und Ausgabe ..Hilfe

[cguido]

Hallo Liebe Leute,

Ich suche eine Methode wie ich meine Textdatei durchgehen kann (Config.txt) und meine 2 gespeicherten Pfade ändern kann durch eine externe Klasse.

Also soll meine Klasse eine Methode besitzen (setNextLine(....)) die es mir ermöglicht die txt. datei einen Bestimmten Satz zu ändern(bzw meinen Pfad ändern).

Meine getnextline Methode sieht folgendermaßen aus :

/**
	 * 
	 * @param pattern
	 * @return Array with paths, null if pattern not found
	 * @throws IOException
	 */
	public Vector<String[]> getnextLine(String pattern)
	{
		// EINLESEN DES FILE IN DEN BUFFERED READER FÜR VERWENDEN VON READLINE()

		try
		{
			lR = new LineNumberReader(new FileReader(tmp));
		} catch (FileNotFoundException e)
		{
			// EXEPTION FÜR FEHLER BEIM EINLESEN

			e.printStackTrace();
			System.err.println("Fehler beim Öffnen der Datei!");
			return null;
		}

		String zeile = null;
		String[] tmp =null ;

		do
		{
			try
			{
				zeile = lR.readLine();
			} catch (IOException e)
			{
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			if (zeile != null)
				tmp = zeile.split(delimiter);
		} while (!tmp[0].equals(pattern) && zeile != null);

		Vector<String[]> returnValue = new Vector<String[]>();
		if (zeile != null)
		{
			do
			{
				try
				{
					zeile = lR.readLine();
				} catch (IOException e)
				{
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				tmp = zeile.split(delimiter);
				returnValue.add(tmp);
			} while (tmp[0].charAt(0) == ';');
		} else
			returnValue = null;
		returnValue.remove(returnValue.size() - 1);

		for (Iterator iterator = returnValue.iterator(); iterator.hasNext();)
		{
			String[] strings = (String[]) iterator.next();
			String[] s = strings[0].split("\\;");
			strings[0] = s[1];
		}

		return returnValue;

	}

Hier meine Config Datei:

ApplicationPath
;C:/Users/Christian/Documents/eclipse/workspace neu/GuiKomp
ApiPath
;C:/Users/Christian/Desktop/docs
GUI-Elemente
;JButton,/src/GUI/Button.java,/bin/GUI/Button.class,/api/javax/swing/JButton
;JTextfield,/src/GUI/Textfield.java,/bin/GUI/Textfield.class,/api/javax/swing/JTextfield
;JList,/src/GUI/JList.java,/bin/GUI/JList.class,/api/javax/swing/JList
END

Das ziel ist es auf verschiedene Pfade zuzugreifen auch für andere Nutzer dafür müssen sie aber ihren workspace bzw. ihr apipfad angeben damit sie weiterarbeiten können ....
Deswegen muss ich eine Funktion setnextline schreiben die es mir ermöglicht meinen Pfad zu ändern.. Danke im Vorraus für jede Hilfe Hier schonmal eine Grundlage von setNextLine .
Ich habe es nur Angefangen mit fehlen ein paar Ansätze hoffe ihr könnt mir helfen

	public Vector<String[]> setNextLine(/* boolean append, String pattern,String[] ersetzen, Vector<String> info*/)
	{

		Vector<String[]> vec = new Vector<String[]>();
		String zeile = null;
		String[] arr = null;
		
		try
		{
			lR = new LineNumberReader(new FileReader(tmp));
		} catch (FileNotFoundException e)
		{
			e.printStackTrace();
			System.err.println("Fehler beim Öffnen der Datei!");
			//return false;
		}

	
		do
		{
			try
			{
				zeile = lR.readLine();
			} catch (IOException e)
			{
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			if (zeile != null)
			{
				arr = zeile.split(delimiter);
				vec.add(arr);
				
			}
		} while (zeile != null);
		
		//vec.remove(vec.size() - 1);
		
		
		
		return vec;
	}

 

[cguido]

int i =0;
for (Iterator iterator = vec.iterator(); iterator.hasNext()
{
String[] strings = (String[]) iterator.next();
strings.equals(pattern);
i++;

}

vec.removeElementAt(i);


Ich bräuchte üngefähr sowas aber ich kann es nicht löschen ...ArrayOutOfBoundsException -.-???

 

[Gucky]

Da die Datei nicht sehr groß ist gäbe es auch noch die Möglichkeit die gesamte Datei einzulesen, an den Zeilentrennzeichen zu splitten (

str.split(System.getSystemProperties("line.separator"));

), das zurückgegebene Array in einem solchen speichern und den richtigen Index anzuzapfen. Danach speicherst du das Ganze wieder mit einer Schleife, die alles in einem einzigen String speichert, die fehlenden line Separatoren eingibt und den String dann speichert.

 

[cguido]

Das hatte ich mir auch überlegt bloß ich kann meine Config Datei vom Aufbau nicht ändern weil meine getNextline methode auf diesen aufbau aufbaut..

d.h. wenn ich getnextline("GUI-Elemente"); eingebe dann gibt er mir alle Dateien darunter (JButton,JTextfield,JList....) und das ohne ( ...
Im prinzip sind die Begriffe die Pattern und das was Darunter steht bis zum nächsten (nicht Semikolon sag ich mal) wird alles in String Arrays gespeichert ..

Also muss ich das glaube ich mal ausschließen Aber danke :toll:

 

[Gucky]

Warum ändert die den Aufbau? Ein getter hat nichts zu ändern.

Bleibt die Größe der Datei so oder kann da noch was dazukommen?

 

[cguido]

Es kann noch was dazukommen ... Es soll ein Universelles Programm sein dass jemand weitermachen kann.. deswegen nimmt die Getter Methode alles was unten aufgelistet ist unter den Pattern... d.h. egal welche pfade man noch hinzufügt sie werden mit reingenommen

 

[Gucky]

Um das Zerlegen wirst du ohne riesigen Mehraufwand nicht herumkommen. Es gäbe noch die Möglichkeit eine Map zu benutzen und die Schlüsselwörter als Schlüssel zu verwenden. In dieser Map speicherst du die Strings dann als ArrayList. Über den Schlüssel greifst du auf die passende ArrayList zu und über die Methoden der ArrayList auf den passenden Pfad. Den Editierst du dann. Eine Abspeichern Methode läuft über dieses Konstrukt. Erster Schlüssel, lauf die ArrayList lang und speichere es. Zweiter Schlüssel--> Dasselbe. --> sehr einfach kostet aber Speicher (Heutzutage aber eigentlich egal)

Es gäbe auch noch die Möglichkeit die Datei nur nach Pattern zu splitten und die Teilstrings dann in einer Liste zu speichern und dann mithilfe einer Methode so lange diesen Teilstring langlaufen, bis du die richtige Zeile gefunden hast, den String um diese Zeile in drei Teile teilen, deinen Pfad ändern und den String wieder zusammensetzen. --> sehr fehleranfällig und kompliziert aber speicherschonend

Eine weitere Möglichkeit wäre ein replace. Du gibst den zu ersetzenden Pfad als String ein und den, durch den er ersetzt werden soll auch. den entstehenden String speicherst du unter der Adresse des ursprünglichen ab. Dann wird das aber schwer mit dem einsetzen. Dann musst du deinen String wieder zerlegen und etwas einsetzen und den String wieder zusammensetzen. --> fehleranfällig und kompliziert aber speicherschonend

Die letzte Möglichkeit wäre ein [JAPI]StringBuffer[/JAPI] oder ein [JAPI]StringBuilder[/JAPI]. Mit diesem kannst du Strings mittendrin einsetzen. --> speicherschonend aber auch komplizierter als die erste Methode

 

[dzim]

ok, das ist vielleicht gemein, aber warum willst du das Rad neu erfinden???
Am einfachsten wäre es, Properties zu verwenden. Das sind einfache Schlüssel-Wert-Paare in der Form
<Schlüssel>=<Wert>
Wert kann auch ein string sein, den du dann noch weiter aufsplitten kannst.
Oder du verwendest einen INI-Parser. Gibt es auch für Java...

 

[Gucky]

@dzim
Ich bin ein großer Freund von Selberschreiben. Solche Dinge, wie Listen oder Tonabspieler nehme ich trotzdem aus der API aber solche Tools wie den INI Parser kenne ich gar nicht. Oder die Properties. Da schreibe ich mir das lieber selbst. Dann weiß ich, was mein Code tut und wenn was nicht funktioniert, dann erweitere ich ihn halt oder korrigiere ihn. Bevor ich ein Tool gefunden habe und damit umgehen kann und auch durchdrungen habe, was es da tut habe ich mir meine Methode oder Klasse schon selber geschrieben. Und davon abgesehen: Wie lernt man besser Java programmieren als durch Java programmieren?

Mein Lehrer hatte dazu einen ganz schönen Vergleich.
Wir beide bauen eine Sandburg. Deine Sandburg ist nach wenigen Stunden fertig, sie ist begehbar und hat einen Pool. Dafür hast du Bagger, Kräne und so einen Kram gekauft und dir Bauarbeiter gemietet.
Meine Sandburg ist nach ein paar Tagen fertig und sieht aus, wie eine Sandburg. Dafür habe ich, wenn ich einen Kran brauche, ihn mir selber gebaut. Ich hatte nur Sand, Metall und ein Schweißgerät. Ich finde, man kann mit mehr Stolz auf sein Programm gucken und mit mehr Recht behaupten "Das hab ich geschrieben", wenn man so viel wie möglich selber geschrieben hat. Aber das ist Geschmackssache.

Ich will hier aber keine Grundsatzdiskussion vom Zaun brechen. Per PN hätte ich da nichts gegen.

 

[dzim]

Properties props = new Properties();
propst.load(new FileInputStream("bla.txt"));

String appPath = props.getProperty("ApplicationPath");

bla.txt

ApplicationPath=C:/Users/Christian/Documents/eclipse/workspace neu/GuiKomp

Genau wie deine Liste oder InputStream sind properties teil von Java. Dein Werkzeug-Vergleich hinkt also...

Selber schreiben != guter/besserer/einfach zu verstehender code, jedenfalls solange du noch kein Pro bist (wozu selbst ich mich trotz vieler Erfahrung immer noch nicht zählen wurde). Wo es geht und sinnvoll ist, verwendet man vorhandene und etablierte techniken. Du wirst auch den Zugriff auf Dateien nicht selbst implementieren. Aber nach ruhig, wenn du denkst, das du mit einer selbst gestrickten Lösung besser fährst.

Einstellungen werden in aller Regel entweder in Properties, .ini-Dateien, XML oder Json gespeichert. Oder binär. Alles andere ist einfach nur verschwendete Zeit.

So. Das musste raus!

 

[Gucky]

Ich sage auch nicht, dass ich nichts aus der API nehme. Und hätte ich verstanden, dass ein INI Parser ein Parser für .ini Dateien ist, hätte ich den auch verwendet.

Wenn ich etwas machen will, was ich nicht kann, dann gucke ich immer im Internet und wenn mir dann ein Tool ausgespuckt wird, dass so riesig ist, dass ich damit alles machen kann, dass aber kompliziert wie sonstwas ist, dann schreibe ich es mir selber. Oder wenn ich zu faul bin zu suchen, dann schreibe ich es mir selber. Oder wenn es etwas kleines ist.
Große Dinge, wie eben die Listen nehme ich aus der API.

 

[dzim]

Nennst du Properties jetzt groß? Im wesentlichen sind die nichts weiter als eine Hashtable mit einer API zum Dateien parsen... Unwesentlich größer als die originale Hashtable wurde ich sagen.

Aber wie gesagt: wenn du meinst, das du es selbst schreiben musst, dann tu es! Ich finde hält nur, das es Verschwendung ist... ;-)