Textdatei-Import

[algebraiker]

Hallo,

ich habe eine Textdatei und mich interessieren ausschließlich die Werte und nicht die Spalten. Ich habe die Textdatei angehängt.

Ich möchte nur folgende "Sachen haben":

| 01 |EM |2334454554 |210
| 01 |EM |3432342322 |310
| 01 |SE |3432434566 |310
| 01 |AS |7898797777 |310
| 01 |FK |7687867677 |310
| 01 |EM |2334454554 |210
| 01 |EM |3432342322 |310
| 01 |SE |3432434566 |310
| 01 |AS |7898797777 |310
| 01 |FK |7687867677 |310

.. und diese in ArrayListen speichern, aber first things first.

Wie kriege ich erstmal das

17.11.2011 Test 1
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Ausgaben
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| Spalte 1|Spalte 2|Spalte 3|Spalte 4
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

alles vom Einlesen weg?

Ich dachte an irgendwie sowas wie, dass ich eine boolesche Methode schreibe, die überprüft, ob "Test" auftaucht und dann die nächsten Zeilen auch weghaut. Aber ist das überhaupt der richtige Weg? :bahnhof:

package importer;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class Importer {

	public static void main(String[] argv) {
		csvImport("C:/Daten/Testauszug.TXT");
	}

	public static List<Object> csvImport(String path) {
		FileReader file;
		List<Object> a = new ArrayList<Object>();
		try {
			String line = "";
			file = new FileReader(path);
			BufferedReader reader = new BufferedReader(file);
			int counter = 0;
			while ((line = reader.readLine()) != null) {
				
				if(containsString(line, "Test")) {
					System.out.println(line.trim());
					a.add(line);
				}
				break;

				// counter++;
				// if (counter > 6) {
				// String[] sep = line.split("[|]");
				// if (sep[13].trim().startsWith("000"))
				// {
				//
				// artNum.add(sep[13].trim());
				// artName.add(sep[14].trim());
				// artQuantity.add(Double.parseDouble(sep[17].trim().replaceAll("[,\\.]",
				// "")));
				//
				// String dateString = sep[10].trim();
				// String dateFormatString = "dd.MM.yyyy";
				// SimpleDateFormat format = new
				// SimpleDateFormat(dateFormatString);
				// Date newDate = format.parse(dateString);
				// artDate.add(newDate);
				// }
				// }
			}

		} catch (FileNotFoundException e) {
			throw new RuntimeException("File not found");
		} catch (IOException e) {
			throw new RuntimeException("IO Error occured");
		}

		return a;
	}
	
	private static boolean containsString( String s, String subString ) {
        return s.indexOf( subString ) > -1 ? true : false;
    }

}

 

[Michael...]

Das hängt jetzt vom Aufbau der Textdatei ab. Wenn ausschließlich die relevanten Zeilen alle mit

|

gefolgt von irgendwelchen Ziffern anfangen, kann man das ja gezielt überprüfen.

 

[langhaar!]

ich habe eine Textdatei und mich interessieren ausschließlich die Werte und nicht die Spalten.

Du meinst, du willst nur die in den Spalten enthaltenen Werte, aber nicht die Spaltenüberschriften?
Prüfe ab, ob eine Zeile mit | beginnt und keinen Text enthält; dann ist es eine Zeile mit Werten.

 

[algebraiker]

Du meinst, du willst nur die in den Spalten enthaltenen Werte, aber nicht die Spaltenüberschriften?
Prüfe ab, ob eine Zeile mit | beginnt und keinen Text enthält; dann ist es eine Zeile mit Werten.

Ja genau, das möchte ich. Das ist ein guter Tipp!

Mein Versuch

public class Importer {

	public static void main(String[] argv) {
		csvImport("C:/Daten/Auftrag.TXT");
	}

	public static List<Object> csvImport(String path) {
		FileReader file;
		List<Object> a = new ArrayList<Object>();
		try {
			int counter = 0;
			String line = "";
			file = new FileReader(path);
			BufferedReader reader = new BufferedReader(file);
			while ((line = reader.readLine()) != null) {
				counter++;
				String[] sep = line.split("[|]");
				if(counter > 5) {
					System.out.println(sep[0]);
				}
			}

		} catch (FileNotFoundException e) {
			throw new RuntimeException("File not found");
		} catch (IOException e) {
			throw new RuntimeException("IO Error occured");
		}

		return a;
	}
}

liefert mir Nonsens. Ich dachte ich starte ab der 6. Zeile damit ich auch wirklich da anfange, wo ich es möchte. Aber kommt nicht viel dabei raus.

 

[Michael...]

Ja genau, das möchte ich. Das ist ein guter Tipp!

Hey, den hatte ich zuerst ;-)

Das mit dem split kannst Du (ersteinmal) sparen. Lese erst einmal die Datei zeilenweise ein und prüfe, ob sie mit einem Pipe evtl. gefolgt von einer festen Anzahl an Leerzeichen beginnt. siehe String#startsWith(...).
Dann prüfst Du ob das darauf folgende Zeichen an Stelle x im String eine Ziffer ist...

 

[algebraiker]

Ups, sorry. Habe dein Posting aus Versehen überlesen.

Ich habe zum Testen ersteinmal die unnötigen Sachen entfernt und das hier versucht, was auch perfekt klappt.

package importer;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class Importer {

	public static void main(String[] argv) throws ParseException {
		csvImport("C:/Daten/Auftrag.TXT");
	}

	public static void csvImport(String path) throws ParseException {
		FileReader file;
		ArrayList<String> artNum = new ArrayList<String>();
		ArrayList<String> artName = new ArrayList<String>();
		ArrayList<Double> artPreis = new ArrayList<Double>();
		ArrayList<Date> artDate = new ArrayList<Date>();
		ArrayList<Date> artTime = new ArrayList<Date>();
		ArrayList<Double> artQuantity = new ArrayList<Double>();
		try {
			
			int counter = 0;
			String line = "";
			file = new FileReader(path);
			BufferedReader reader = new BufferedReader(file);
			while ((line = reader.readLine()) != null) {
				counter++;
				if(counter > 6) {
					String[] sep = line.split("[|]");
					if (sep[13].trim().startsWith("000")) 
					{
						artNum.add(sep[13].trim());
						
						artName.add(sep[14].trim());
						
						artPreis.add(Double.parseDouble(sep[16].trim().replaceAll("[,\\.]", "")));
						
						String dateString = sep[10].trim();
						String dateFormatString = "dd.MM.yyyy";
						SimpleDateFormat format = new SimpleDateFormat(dateFormatString);
						Date newDate = format.parse(dateString);
						artDate.add(newDate);
						
						artTime.add(null);
						
						artQuantity.add(Double.parseDouble(sep[17].trim().replaceAll("[,\\.]", "")));
					}
					
				}
			}
		} catch (FileNotFoundException e) {
			throw new RuntimeException("File not found");
		} catch (IOException e) {
			throw new RuntimeException("IO Error occured");
		}
	}
}

In den ArrayListen stecken nun genau die Daten drin, aaaaber ich will die Textdatei ja nicht bearbeiten. Wie würde denn das im Code aussehen Michael, dass ich die unnötigen Sachen einfach nicht betrachte? Ich komm irgendwie nicht drauf. :bahnhof:

 

[langhaar!]

Um unnötige Sachen nicht zu betrachten:

while ((line = reader.readLine()) != null) {
                counter++;
                if (line.indexOf('|') == -1)
                  continue;
                  ...

Bedeutet, wenn in einer Zeile kein | vorkommt, wird die nächste Iteration der while Schleife angesprungen. IndexOf liefert -1 wenn das Zeichen nicht im String ist.

 

[emailundlos]

| 01 |SE |3432434566 |310

So sieht also eine typische Zeile aus. Du musst dir Pattern und Matcher angucken (und vielleicht die String-Klasse), dann ergibt sich:

Patter p = Pattern.compile("(\\d{2})\\W+(\\w{2})\\W+(\\d{10})\\W+(\\d{2,3})");
Matcher m = p.matcher(irgendeinString);
if (m.find()) {
  // eine gültige Zeile
  // rausgeben: System.out.println(m.group(1) + "\t" + m.group(2) + "\t" + ......);
}

d: digit
w: word character
W: gegenteil
{}: eine Art Quantifizierer
(): match groups

 

[algebraiker]

Yes Baby, so funktioniert es perfekt.

package importer;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;

public class Importer {

	private static List<String> SKIP_STRINGS = new ArrayList<String>();

	public static void main(String[] argv) throws ParseException {

		SKIP_STRINGS.add("|  Spalte1");

		csvImport("C:/Daten/text.TXT");
	}

	public static void csvImport(String path) throws ParseException {
		FileReader file;

		try {
			String line = "";
			file = new FileReader(path);
			BufferedReader reader = new BufferedReader(file);

			FileWriter writer = new FileWriter("C:/Daten/out.csv");
			writer.write("Nr;Name;Price;Date;Time;Quant\r\n");

			while ((line = reader.readLine()) != null) {
				// skip
				if (line.indexOf('|') == -1) {
					continue;
				}

				boolean isSkip = false;
				for (String s : SKIP_STRINGS) {
					if (line.startsWith(s)) {
						isSkip = true;
					}
				}
				if (isSkip) {
					continue;
				}
				
				System.out.println(line);

				String[] sep = line.split("[|]");
				if (sep[13].trim().startsWith("000")) {
					String a = sep[16].trim().replaceAll(
							"[.]", "");
					
					a = a.replaceAll("[,]", ".");
					
					String dateString = sep[10].trim();
					writer.write(sep[13].trim()
							+ ";"
							+ sep[14].trim()
							+ ";"
							+ Double.parseDouble(a)
							+ ";"
							+ dateString
							+ ";;"
							+ Double.parseDouble(sep[17].trim().replaceAll(
									"[,\\.]", "")) + "\r\n");
				}
			}
			writer.flush();
			writer.close();
		} catch (FileNotFoundException e) {
			throw new RuntimeException("File not found");
		} catch (IOException e) {
			throw new RuntimeException("IO Error occured");
		}
	}
}