# Lesen ein txt datei zu Array



## koddy013 (26. April 2010)

Hallo zusammen,

ich möchte ein TXT Datei durch Java einlesen und für weitere Verwendung benutzen. Also für die I/O habe ich "Scanner" anstatt BuffererReader benutzt. Aber genauer weiss ich immerhin noch nicht, ob ich die Richtige Klasse gewählt habe 
Also meine Problem ist nun liegt bei der TXT Datei. Die TXT Datei sieht wie folgt:


```
**********************************************************************
* SIDAK 					        *
**********************************************************************
* MISS RATIO: 4.15                                                                                * 
* SHOOT RANGE: 36.2 [mm]                                                               *
**********************************************************************
* No.:  Z [mm]   Y [mm]   F [mm/1000]                                                *
**********************************************************************
Name: KIRA;
Try: 1 of 36;
Load: 3;
    1:  36.200  172.200      9.2 
    2:  36.200  172.095      8.9 
    3:  36.200  171.990      8.1 
Name: KIRA;
Try: 2 of 36;
Load: 3;
    1:  35.166  172.200     81.7 
    2:  35.166  172.095    109.9 
    3:  35.166  171.990    130.9
```

Was ich bis jetzt wissen ist nur die gesamte Daten in eine ListArray zu laden, wie folgende Code.


```
import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

public class ReadSortiere {

    public static void main(String[] args) {
		try {
			List <Double> a = new ArrayList<Double>();
			Scanner sc2 = new Scanner(new File("test.TXT"));
			while(sc2.hasNextLine()) {
				a.add(sc2.nextLine());
			}
			sc2.close();			

			Collections.sort(a);
			Iterator it = a.iterator();
 
			while(it.hasNext()) {
				System.out.println(it.next());
			}
 
		} catch(FileNotFoundException e) {
			System.out.println("Fehler: Quelldatei existiert nicht");
			System.exit(1);
		} catch(Exception e) {
			System.out.println("Fehler: Ein unbekannter Fehler ist aufgetreten");
			System.exit(1);
		}

    }
}
```

Aber die Daten ist nicht lesbar. Und eigentlich aus der Daten brauche ich die (Z)(Y)(F) für jeden Try.
Also wie in der Daten, für jeden Try sind mehrere Textzeile da.
Weiss jemand, wie ich am besten für diesen Aufforderung einen Code schreibe?

Danke im voraus.

Liebe Grüsse,


----------



## vfl_freak (26. April 2010)

Moin,

wenn Du die gesamte Datei einlesen willst, dann solltest Du für Deine ArrayList auch den Typ "String" wählen und nicht "double" !

Gruß
Klaus


----------



## koddy013 (26. April 2010)

Hallo,

ich habe den Code verändern wie folgendes:

```
import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class ReadSortiere {

   public static void main(String[] args) {
               try {
                     List <Data> a = new ArrayList<Data>();
	Scanner sc2 = new Scanner(new File("test.TXT"));
	while(sc2.hasNextDouble()) {
                            double y = sc2.nextDouble();
                            double z = sc2.nextDouble();
                            double f = sc2.nextDouble();

            Data data = new Data(y,z,f);

            a.add(data);

            System.out.println(y + " " + z + " " + f);   
            }
			sc2.close();			
 
		} catch(FileNotFoundException e) {
			System.out.println("Fehler: Quelldatei existiert nicht");
			System.exit(1);
		} catch(Exception e) {
			System.out.println("Fehler: Ein unbekannter Fehler ist aufgetreten");
			System.exit(1);
		}

    }

}

class Data {
private double mZ;
private double mY;
private double mF;

public Data(double z, double y, double f) {
            mZ = z;
            mY = y;
            mF = f;
        }

public double getZ() {
return mZ;
}
public double getY() {
return mY;
}
public double getF() {
return mF;
}
}
```

Die gesamte Daten ist nun lesbar. Aber ich brauche nicht alle Daten, sondern nur die (Y,Z,F). Da beim nächsten Schritt werde ich ein Grafik aus diese (Y,Z,F)-Punkte für jede "Try" zeichnen.
Wie kann ich nur die benutzte Daten nehmen und die unbenutzen Daten weglassen, ohne die TXT Datei zu ändern? Hat jemand Ideen?


----------



## koddy013 (29. April 2010)

Hallo zusammen,

ich habe für Einlesen den txt-Datei mehrere Klasse geschrieben. Dann kommt jetzt meine Probleme beim parsen den Daten.

Also sag mal hier ist die Code von meine Methode:


```
public static void readTextFile(String fileName)
    {
    StringBuffer contents = new StringBuffer();
    BufferedReader reader = null;
    String text = null;

    try
    {
        reader = new BufferedReader(new FileReader(fileName));

        while( (text = reader.readLine()) != null )
        {
            if (!text.trim().equals("")) continue;

            if (!text.startsWith(NAME))
            {
                parseName();
                
                String name = reader.readLine();
                String spasi = "[ ]+";
    
                if (name.equals(name))  continue;
                else 
                { 
                    reader.close();
                    addShooter(name);
                    new Shooter(name);
                }
            }
}
```

und hier ist die Beispiel von meine parseName-Methode:

```
private static void parseName() throws FileNotFoundException, IOException{
        BufferedReader reader = new BufferedReader(new FileReader(fileName));        
        String name = reader.readLine();
        String spasi = "[ ]+";
    }
```

also... das Ziel ist, ich möchte den Name parsen und dann in eine ListArray speichern.
Aber ich weiss nicht mehr, was soll ich dazu noch schreiben.
Kann jemand mir helfen?

Danke im voraus für eure Hilfe 

Liebe Grüße,


----------



## Franz Degenhardt (29. April 2010)

Hallo, 

anbei, kompilierbarer code, der zumindest die Namen parsed.
Schau dir mal an, wie innerhalb der Schleife mit den einzelnen Zeilen der Datei verfahren wird. Analog können dann auch die restlichen Zeilen geparsed werden.


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

public class Sidak {

	List<String> shooter = new ArrayList<String>();

	public Sidak(String fileName) {
		readTextFile(fileName);
		Iterator<String> iterator = shooter.iterator();
		while (iterator.hasNext()) {
			String string = (String) iterator.next();
			System.out.println(string);

		}
	}

	public void readTextFile(String fileName) {
		BufferedReader reader = null;
		String text = null;
		try {
			reader = new BufferedReader(new FileReader(fileName));
			while ((text = reader.readLine()) != null) {
				if (text.trim().startsWith("*")) {
					continue;
				}
				if (text.startsWith("Name")) {
					String name = parseName(text);
					if (!shooter.contains(name)) {
						shooter.add(name);
					}
				}
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				reader.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	protected String parseName(String _s) {
		int b = _s.indexOf(':');
		int e = _s.indexOf(';');
		return _s.substring(b + 1, e).trim();
	}

	public static void main(String[] args) {
		new Sidak("C:/ws/spielwiese/sidak.txt");
	}
}
```


----------



## koddy013 (29. April 2010)

Vielen Dank erstmal für die Antwort.
Also wenn ich fragen darf, kann ich diese parsen-Methode wie folgendes schreiben?

```
private static void parseName(String aName) {
        Scanner scanner = new Scanner(aName);
        if ( scanner.hasNext() ){
            String nameindex = scanner.next();
            String name = scanner.next();
            System.out.println(name);
            Shooter.setName(name);
        }        
        scanner.close();      
    }
```

oder darf ich so was schreiben?

```
private void parseName(String aName){
        StringTokenizer tokenizer = new StringTokenizer(aName," ");
        String s0;
        s0 = tokenizer.nextToken();
        System.out.println(s0);
}
```

Ich frage nur, da mit deinem Weg habe ich Schwierigkeiten beim parsen von Zahlen (Z, Y, F).

Danke noch mal im voraus.


----------



## Franz Degenhardt (29. April 2010)

Die Klassen Scanner und Shooter kenn ich noch nicht.
Die Methode public String parseName(String _s) hatte ich speziell für das parsen einer Zeile, die den Namen eines Shooters(?) enthält gebaut. Diese sollte einfach aus dem String "Name: MyName;" den Spielernamen rausparsen.

Um die restlichen Zeilen zu parsen kannst du entweder eine intelligente Parsingmethode schreiben, die mit sämtlichen Zeilen klarkommt, oder du rufst passend zu der bekannten Struktur verschiedene Parsingmethoden auf.

Dann läuft man zeilenweise den String ab und füllt dabei die eigenen Ojekte mit den Daten. Eine Objektstruktur, die den Daten entspricht, wäre also gut:

```
class ShooterRepository {
		Map<String, Shooter> allShooters = new HashMap<String, Shooter>();
	}

	class Shooter {
		List<Try> tries = new ArrayList<Try>();
	}

	class Try {
		List<Load> loads = new ArrayList<Load>();
	}

	class Load {
		double Z;
		double Y;
		double F;
	}
```

Dann fehlt noch die Fleissarbeit, beim iterieren über die Zeilen die Strings auseinander zu fummeln. Für das Parsen einer Zeile ist der StringTokenizer eine gute Idee.

Zum Parsen von Datentypen findet man meistens in der Klasse des Zielformates eine passende Methode. Für primitive Typen muss man dabei die Klassen des zugehörigen komplexen Typ nehmen.

```
String doubleStr = "123.45";
		String intStr = "123";
		double d = Double.parseDouble(doubleStr);
		int i = Integer.parseInt(intStr);
		String dStr = String.valueOf(d);
		String iStr = String.valueOf(i);
		System.out.println(doubleStr.equals(dStr));
		System.out.println(intStr.equals(iStr));
```


----------



## koddy013 (29. April 2010)

danke noch mal für die Antwort.

Hier sind die Klasse, die ich bis jetzt geschrieben habe:

```
public class Shot {

    private double z;
    private double y;
    private double f;

    public Shot(double z, double y, double f){
        this.z = z;
        this.y = y;
        this.f = f;
    }

    public double getZ() {
        return  z;
    }

    public double getY() {
        return  y;
    }

    public double getF() {
        return  f;
    }
}
```


```
import java.util.ArrayList;
import java.util.List;

public class Try {
    private int load;
    private List<Shot> shots = new ArrayList<Shot> ();

    public Try(){
    }

    public void setLoad(int value){
        load = value;
    }
            
    private int getLoad() {
        return load;
    }

    public List<Shot> getShot(){
        return shots;
    }

    public void addShot(double z, double y, double f){
        this.shots.add(getZ(), getY(), getF());
    }
}
```


```
import java.util.ArrayList;
import java.util.List;


public class Shooter {
    private String name;
    private List<Try> tries = new ArrayList<Try> ();
    
    public Shooter(){
    }
    
    public void setName(String str){
        name = str;
    }
            
    private String getName() {
        return name;
    }

    public List<Try> getTry(){
        return tries;
    }

    public void addTry(Try coba){
        this.tries.add(coba);
    }
}
```

Und hier ist die main methode:

```
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Read {

    private static final String STAR = "*";
    private static final String NAME = "Name: ";
    private static final String TRY = "Try: ";
    private static final String LOAD = "Load: ";
        
    private List<Shooter> shooters = new ArrayList<Shooter>();
    private List<Try> tries = new ArrayList<Try> ();
    private List<Shot> shots = new ArrayList<Shot> ();

    public static void main(String[] args) throws Exception {
        new Read("test.txt");
    }

    public Read(String fileName){
        readTextFile(fileName);       
    }

    private void readTextFile(String fileName)
    {
    StringBuffer contents = new StringBuffer();
    BufferedReader reader = null;
    String text = null;

    try
    {
        reader = new BufferedReader(new FileReader(fileName));
        while( (text = reader.readLine()) != null )
        {
            if (text.trim().equals("")) continue;
            if (text.trim().startsWith(STAR)) continue;           
            if (text.startsWith(NAME))
            {
                String name = parseName(text);
                if ((name).equals(name))
                { 
                    continue;
                }
                else 
                { 
                    finalize();
                    System.out.println(name);
                    shooters.add(name);
                    new Shooter();
                }
            }

            if (text.startsWith(TRY))
            {
                int coba = parseTry(text);
                finalize();
                new Try();
            }
                
            if (text.startsWith(LOAD))
            {
                parseLoad(reader.readLine());               
            }

            else
            {
                parseShot(reader.readLine());
                reader.close();
            }
        }
    }   
    catch (FileNotFoundException e) {
        	e.printStackTrace();
    }

    catch (IOException e)
    {
        e.printStackTrace();
    }
    finally
    {
        try
        {
            if (reader != null)
            {
                reader.close();
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }

    // show file contents here
    System.out.println(reader);
    }

    protected String parseName(String aName) {
        int e = aName.indexOf(';');
		return aName.substring(0, e).trim();
    }

    private int parseTry(String aTry){
        StringTokenizer tokenizer = new StringTokenizer(aTry," ");
        String s0, s1, s2;
        s0 = tokenizer.nextToken();
        s1 = tokenizer.nextToken();
        s2 = tokenizer.nextToken();

        System.out.println(s0);
        return aTry.indexOf(s0);
    }

    private void parseLoad(String aLoad) {
        Scanner scanner = new Scanner(aLoad);
        scanner.useDelimiter(";");
        if ( scanner.hasNext() ){
            int load = scanner.nextInt();
            System.out.println(load);
            Try.setLoad(load);
        }
        scanner.close();
    }

    private void parseShot(String aShot) {
        Scanner scanner = new Scanner(aShot);
        if ( scanner.hasNext() ){
            double z = scanner.nextDouble();
            double y = scanner.nextDouble();
            double f = scanner.nextDouble();

            System.out.println("Z= " + z + "Y= " + y + "F= " + f );
            Shot currentshot = new Shot (z,y,f);
            shots.add(currentshot);
        }
        scanner.close();
    }

    public List<Shooter> getShooter(){
        return shooters;
    }

    public void addShooter(Shooter name){
        this.shooters.add(name);
    }
}
```

Haben Sie Ideen wie ich diesen Code verbessern soll?

Danke im voraus noch mal.
Liebe Grüße,


----------



## Franz Degenhardt (29. April 2010)

Kannst ruhig Du sagen ;-)


```
public void addShot(double z, double y, double f){
        this.shots.add(getZ(), getY(), getF());
    }
```

Da wird kein sinvolles Element bei rauskommen, denn welche Werte würden denn durch getZ() hier angezogen? Vgl:


```
public void addShot(double z, double y, double f){
        shots.add(z, y, f);
    }
```

grundsätzliche Tipps:
- anständiges IDE besorgen (http://www.eclipse.org/)
- Funktionalität in Methoden verpacken und diese geziehlt durch Aufrufe auf Funktionalität testen (z.B. die Parsingmethoden).
- das ReaderObjekt ist evtl etwas unhandlich, erstmal alle Zeilen in eine Liste zu packen erleichtert vielleicht das handling.


----------



## Franz Degenhardt (29. April 2010)

Da es keine konkrete Frage gibt, habe ich ein bischen gebastelt, sorry, wenn ich dir den ganzen Spass genommen habe ;-)

Für leichteres copypasten&ausführen habe ich die Klassen Shot, Try usw in die Klasse Read mit reingepackt. 
Man kann noch gut daran rumspielen und Sachen schön machen. Die toString Methoden sind noch recht grob z.B.


```
package de.tutorials.fde;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;

public class Read {

	private static final String STAR = "*";
	private static final String NAME = "Name: ";
	private static final String TRY = "Try: ";
	private static final String LOAD = "Load: ";

	private Map<String, Shooter> shooters = new HashMap<String, Shooter>();

	public static void main(String[] args) throws Exception {
		new Read("C:/tools/workspaces/test/Spielwiese/file.txt");
	}

	public Read(String fileName) {
		readTextFile(fileName);
		Set<String> keySet = shooters.keySet();
		for (Iterator<String> iterator = keySet.iterator(); iterator.hasNext();) {
			String name = (String) iterator.next();
			Shooter s = shooters.get(name);
			System.out.println(s);
		}
	}

	private void readTextFile(String fileName) {
		BufferedReader reader = null;
		String text = null;
		try {
			reader = new BufferedReader(new FileReader(fileName));
			while ((text = reader.readLine()) != null) {
				if (text.trim().equals("")) { // Leerzeile
					continue;
				}
				if (text.trim().startsWith(STAR)) { // Kommentar
					continue;
				}
				if (text.startsWith(NAME)) { // Namenszeile
					String name = parseName(text);
					Shooter s = null;
					if (shooters.containsKey(name)) {
						s = shooters.get(name);
					} else {
						s = new Shooter(name);
					}
					shooters.put(name, s);

					// Tryzeile
					text = reader.readLine();
					if (!text.startsWith(TRY)) {
						throw new NumberFormatException(
								"nach Name muss Try kommen, es kam: " + text);
					}
					String tryStr = parseTry(text);
					Try t = new Try(tryStr);
					s.addTry(t);

					// Loadzeile
					text = reader.readLine();
					if (!text.startsWith(LOAD)) {
						throw new NumberFormatException(
								"nach Try muss Load kommen, es kam: " + text);
					}
					int lAnz = parseLoad(text);
					for (int i = 0; i < lAnz; i++) {
						// Doublezeile
						text = reader.readLine();
						t.addShot(parseShot(text));
					}
				}
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (reader != null) {
					reader.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	protected String parseName(String aName) {
		int b = aName.indexOf(':');
		int e = aName.indexOf(';');
		return aName.substring(b + 1, e).trim();
	}

	private String parseTry(String aTry) {
		StringTokenizer tokenizer = new StringTokenizer(aTry, " ");
		tokenizer.nextToken();
		return tokenizer.nextToken().toString();
	}

	private int parseLoad(String aLoad) {
		StringTokenizer tokenizer = new StringTokenizer(aLoad, " ");
		tokenizer.nextToken();
		return Integer.parseInt(tokenizer.nextToken().substring(0, 1));
	}

	private Shot parseShot(String aShot) {
		StringTokenizer t = new StringTokenizer(aShot, " ");
		t.nextToken();
		double z = Double.valueOf(t.nextToken());
		double y = Double.valueOf(t.nextToken());
		double f = Double.valueOf(t.nextToken());
		return new Shot(z, y, f);
	}

	public Map<String, Shooter> getShooters() {
		return shooters;
	}

	public void addShooter(Shooter s, String name) {
		shooters.put(name, s);
	}

	class Shooter {
		private String name;
		private List<Try> tries = new ArrayList<Try>();

		public Shooter() {
		}

		public Shooter(String _name) {
			name = _name;
		}

		public void setName(String str) {
			name = str;
		}

		public String getName() {
			return name;
		}

		public List<Try> getTry() {
			return tries;
		}

		public void addTry(Try coba) {
			this.tries.add(coba);
		}

		public String toString() {
			StringBuilder sb = new StringBuilder();
			sb.append("Shooter:\n");
			sb.append("[name:");
			sb.append(name);
			sb.append("]\n");
			for (int i = 0; i < tries.size(); i++) {
				sb.append(tries.get(i));
			}
			return sb.toString();
		}
	}

	class Shot {

		private double z;
		private double y;
		private double f;

		public Shot(double z, double y, double f) {
			this.z = z;
			this.y = y;
			this.f = f;
		}

		public double getZ() {
			return z;
		}

		public double getY() {
			return y;
		}

		public double getF() {
			return f;
		}

		public String toString() {
			StringBuilder sb = new StringBuilder();
			sb.append("Shot:\n");
			sb.append("[z:");
			sb.append(z);
			sb.append("], [y:");
			sb.append(y);
			sb.append("], [f:");
			sb.append(f);
			sb.append("]\n");
			return sb.toString();
		}
	}

	class Try {
		private String tryId;
		private int load;
		private List<Shot> shots = new ArrayList<Shot>();

		public Try(String _id) {
			tryId = _id;
		}

		public void setLoad(int value) {
			load = value;
		}

		public int getLoad() {
			return load;
		}

		public List<Shot> getShot() {
			return shots;
		}

		public void addShot(double z, double y, double f) {
			shots.add(new Shot(z, y, f));
		}

		public void addShot(Shot s) {
			shots.add(s);
		}

		public String getTryId() {
			return tryId;
		}

		public void setTryId(String tryId) {
			this.tryId = tryId;
		}

		public String toString() {
			StringBuilder sb = new StringBuilder();
			sb.append("Try:\n");
			sb.append("[id:");
			sb.append(tryId);
			sb.append("]\n");
			for (int i = 0; i < shots.size(); i++) {
				sb.append(shots.get(i));
			}
			return sb.toString();
		}
	}
}
```

Ergebniss:

```
Shooter:
[name:KIRA]
Try:
[id:1]
Shot:
[z:36.2], [y:172.2], [f:9.2]
Shot:
[z:36.2], [y:172.095], [f:8.9]
Shot:
[z:36.2], [y:171.99], [f:8.1]
Try:
[id:2]
Shot:
[z:35.166], [y:172.2], [f:81.7]
Shot:
[z:35.166], [y:172.095], [f:109.9]
Shot:
[z:35.166], [y:171.99], [f:130.9]
Try:
[id:3]
Shot:
[z:35.166], [y:172.2], [f:81.7]
Shot:
[z:35.166], [y:172.095], [f:109.9]
Shot:
[z:35.166], [y:171.99], [f:130.9]

Shooter:
[name:Arnold]
Try:
[id:1]
Shot:
[z:36.2], [y:172.2], [f:9.2]
Shot:
[z:436.2], [y:2172.095], [f:8.9]
Try:
[id:2]
Shot:
[z:1337.0], [y:1337.0], [f:1337.0]
```

Ich habe dazu die Datei nach Gutdüngen angereichert.

```
**********************************************************************
* SIDAK 					        *
**********************************************************************
* MISS RATIO: 4.15                                                                                * 
* SHOOT RANGE: 36.2 [mm]                                                               *
**********************************************************************
* No.:  Z [mm]   Y [mm]   F [mm/1000]                                                *
**********************************************************************
Name: KIRA;
Try: 1 of 36;
Load: 3;
    1:  36.200  172.200      9.2 
    2:  36.200  172.095      8.9 
    3:  36.200  171.990      8.1 
Name: KIRA;
Try: 2 of 36;
Load: 3;
    1:  35.166  172.200     81.7 
    2:  35.166  172.095    109.9 
    3:  35.166  171.990    130.9
Name: Arnold;
Try: 1 of 36;
Load: 2;
    1:  36.200  172.200      9.2 
    2:  436.200  2172.095      8.9 
Name: KIRA;
Try: 3 of 36;
Load: 3;
    1:  35.166  172.200     81.7 
    2:  35.166  172.095    109.9 
    3:  35.166  171.990    130.9    
Name: Arnold;
Try: 2 of 36;
Load: 1;
    1:  1337  1337 1337
```


----------



## koddy013 (7. Mai 2010)

Vielen Dank für deine Hilfe....

du hast ja meinem ganzen Spass nicht genommen, da was hier handelt ist nur ein Beispiel.
Die richtige Code und Project ist viel komplex und durch diesen Beispiel habe ich was verstanden 

aber jetzt bin ich beim Schwierigkeiten beim zeichnen von den List.

Ich muss erstmal jetzt den List etwas sortiere.
In diesem Fall, muss ich den List auf Name erstmal sortiere.
Unter jeder Name, will ich Linie mit (z,y) zeichnen.
Und ich will nicht alle Linie aus jeder ID zeichnen, sondern nur maximal 4 ID (dies aber später behandeln)

Dafür habe ich eine JFrame mit 2 JPanel nebeneinander gemacht. (da für jede Datei nur 2 Name gibt)

(PANEL 1)                                        ! (PANEL 2)
                                                           !
(zeichne für 1.name)                      ! (zeichne für 2.name)
                                                           !
                                                           !

Das Problem, die ich habe ist, wie kann ich die ListArray erstmal sortieren für den Daten.
Also ich dachte nur, ich lese noch mal den Daten von getZ und getY und in eine neue List für diese 2 Punkte schreiben lassen.
Aber... ich weiss nicht wie kann ich die List von Name sortiere.
Kannst du (oder irgendjemand) mir helfen?

Danke im voraus.

LG,


----------

