# Datei-Manager programmieren



## Sindbad1983 (7. Apr 2005)

Hi Leute!

Die Osterferien sind vorbei und ich hab eine neue Aufgabe aufbekommen!
Da hats mich heut ordentlich aus den Socken gerissen, wie ich dich gelesen hab!
Finde, da ist eine gewaltige Steigerung zur letzten Übung sichtbar, oder was meint ihr?
Ich hoffe dieses Mal wieder sehr auf eure tatkräftige Unterstützung!

Also hier mal die Angabe, damit jeder weiß, worum es geht:
Es geht um einen Datei-Manager:

-----------------------------------------------------------------------
Teil 1: Verwaltung von Dateien und Verzeichnissen 

Implementieren Sie eine Klassenhierarchie für die Repräsentation von Dateien (Klasse FileNode) und
Verzeichnissen (Klasse DirectoryNode). Dateien haben einen Namen und eine Länge, Verzeichnisse
einen Namen und weitere Unterelemente (Dateien und Verzeichnisse). Diese sollen in einer gemeinsamen,
sortierten Liste verwaltet werden. Verwenden Sie dazu Klassen und Interfaces aus dem Java Collection
Framework. Erklären Sie in der Prosabeschreibung, warum Sie diese Klassen gewählt haben.

Implementieren Sie alle nötigen get- und set-Methoden für die Felder. Die Liste mit den Unterelementen
soll nicht direkt zugänglich sein, sondern es soll beim Zugriff ein Array mit allen Unterelementen geliefert
werden.

Dateien und Verzeichnisse sollen nach folgenden Kriterien sortiert werden (angelehnt an die Sortierung
im Explorer von Windows XP):

• Verzeichnisse vor Dateien.
• Verzeichnisse alphabetisch.
• Dateien, deren Name mit einer Zahl beginnt, aufsteigend nach dieser Zahl. Negative Zahlen
können ignoriert werden.
• Wenn die Zahl am Beginn gleich ist, oder wenn am Beginn keine Zahl steht, alphabetisch.

Bei der alphabetischen Sortierung soll die Groß- und Kleinschreibung ignoriert werden. Es soll nicht
möglich sein, dass ein Verzeichnis zwei Elemente enthält, die nach diesen Kriterien gleich sind.
Beispiel für eine korrekte Sortierung von Dateinamen: "2 ab", "2 Ac", "10 ab", "ab", "aC".

Um die Klassenhierarchie flexibel einsetzen zu können, sollen alle Dateien und Verzeichnisse ein Feld
userData besitzen. Verwenden Sie dazu einen generischen Typ-Parameter.

Versuchen Sie, Compiler-Warnungen möglichst zu vermeiden. Wenn sich eine Warnung nicht vermeiden
lässt, muss diese in einem Kommentar gerechtfertigt werden.

Teil 2: Datei-Manager 
Verwenden Sie die Klassen aus dem vorigen Teil, um eine Datei- und Verzeichnis-Liste für ein
Verzeichnis der Festplatte auszugeben. Bauen Sie dazu die entsprechende Struktur aus FileNodes und
DirectoryNodes auf.
Verwenden Sie das Feld userData, um das Datum der letzten Änderung zu speichern (als Objekt der
Klasse java.util.Date)!

Für den Zugriff auf das Dateisystem bietet Java die Klasse java.io.File an. Die Methode
getName() liefert den Dateinamen, length() liefert die Dateigröße und lastModified() das
Änderungsdatum. Mit isDirectory() können Sie feststellen, ob es sich um eine Datei oder ein
Verzeichnis handelt, und listFiles() liefert eine Liste mit allen Dateien und Unterverzeichnissen
eines Verzeichnisses.

Geben Sie dann die Struktur mit allen Feldern auf der Konsole aus. Das Wurzel-Verzeichnis soll dem
Programm als Parameter übergeben werden.
Das folgende Beispiel zeigt eine mögliche Testausgabe für ein Verzeichnis mit einigen Dateien und
Unterverzeichnissen:

Test Fri Apr 01 07:00:00 CEST 2005 [DIR]
100 abc Fri Apr 01 08:00:00 CEST 2005 [DIR]
file 1 in dir Fri Apr 01 08:00:01 CEST 2005 (10 bytes)
file 2 in dir Fri Apr 01 08:00:02 CEST 2005 (20 bytes)
20 abc Fri Apr 01 08:01:00 CEST 2005 [DIR]
3 abc Fri Apr 01 08:02:00 CEST 2005 [DIR]
abc Fri Apr 01 08:03:00 CEST 2005 [DIR]
file 1 in dir Fri Apr 01 08:03:01 CEST 2005 (30 bytes)
file 2 in dir Fri Apr 01 08:03:02 CEST 2005 (40 bytes)
3 abc.txt Fri Apr 01 08:04:00 CEST 2005 (10 bytes)
20 abc.txt Fri Apr 01 08:05:00 CEST 2005 (20 bytes)
100 abc.txt Fri Apr 01 08:06:00 CEST 2005 (30 bytes)
-1 abc.txt Fri Apr 01 08:07:00 CEST 2005 (40 bytes)
-20 abc.txt Fri Apr 01 08:08:00 CEST 2005 (50 bytes)
-abc.txt Fri Apr 01 08:09:00 CEST 2005 (60 bytes)
abB.txt Fri Apr 01 08:10:00 CEST 2005 (70 bytes)
abc.txt Fri Apr 01 08:11:00 CEST 2005 (80 bytes)
abc1.txt Fri Apr 01 08:12:00 CEST 2005 (90 bytes)
abD.txt Fri Apr 01 08:13:00 CEST 2005 (100 bytes)
---------------------------------------------------------------------------

Also ich werd jetzt mal für den Anfang  :autsch:  mit Teil 1 beginnen!
Momentan kann ich mir noch nicht viel drunter vorstellen!
Ich glaub, ich beginn mal damit, die Klassenhierarchie aufzubauen!
Welche Klassen brauch ich da?
Hat jemand einen Vorschlag?
Ich glaub ich nehm hier das Pattern Composite, oder? ...also mit einer abstrakten Überklasse, von der sich dann 
FileNode und DirectoryNode ableiten!
Dann könnte ich noch eine SortedSet verwenden für das Ordnen der Elemente! Ordnen tu ich das mit der Methode compareTo()!
Hat jemand einen besseren Vorschlag für den Anfang?
Oh Mann..du Generics sind dann natürlich oben drein noch ein anderes Thema! :### 
Also ihr seht, ich hab viel zu tun bis nächsten Dienstag!
Ich hoffe, ihr zeigt wieder so viel Hilfsbereitschaft wie bisher!

Danke!
ciao,Tommy


----------



## Wildcard (7. Apr 2005)

> Versuchen Sie, Compiler-Warnungen möglichst zu vermeiden. Wenn sich eine Warnung nicht vermeiden
> lässt, muss diese in einem Kommentar gerechtfertigt werden.


Was ist denn das für ne Formulierung? Einfach alle Warnungen in Eclipse ausschalten  :wink: 
Versteh ich das richtig? Das wird ne Konsolenanwendung?  :autsch: 
Mir ist nicht so ganz klar für was der Teil1 gut ist, wenn man in Teil 2 sowieso einen Tree aufbaut!?
Hab ich da was falsch verstanden?


----------



## Sindbad1983 (7. Apr 2005)

Oje...naja..du bist der Spezialist..wos soll denn ich sagen, wenn du schon sagst, dass dir die Formulierung unklar ist!
Also ich habs einfach reinkopiert...es ist genauso gegeben!  :cry: 
Das mit dem Compiler ist mir auch unverständlich! Aber das werd ich noch klären!
Wie könnt ich am besten da dran gehn..? :autsch: 

Die gesamte Angabe ist ein bissl unverständlich find ich!
Kannst du mir jetzt nicht weiterhelfen? 
 :bahnhof:


----------



## Wildcard (7. Apr 2005)

> Das mit dem Compiler ist mir auch unverständlich! Aber das werd ich noch klären!


damit ist wohl gemeint generics verwenden und so... fand's nur irgendwie lustig!   
Also ich versteh Teil 1 so:
Mach eine Liste in der Verzeichnisse und Dateien geordnet sind.
Über get Methoden komme ich allerdings nur an eine Array darstellung dieser Liste.
In dem Array stehen dann FileNode's und Directory-Nodes drin.
Ein Directory node ist dann wieder eine Liste aus File und DirectoryNodes usw...
Du brauchst also zuerstmal eine Superklasse davon...
So versteh ich's zumindest.


----------



## Sindbad1983 (7. Apr 2005)

ok...ich werd gleich morgen früh damit beginnen!
Ja..kann sein..Generics müssen wir ja verwenden!
Mal schaun...wir schon irgendwie gehn!   

Gute Nacht,ciao,Tommy


----------



## mic_checker (7. Apr 2005)

Wie man rekursiv die Verzeichnisse durchgeht und so einen "Verzeichnisbaum" erstellt weisst du?

Im Forum müssten dazu eigentlich noch Beiträge sein, ansonsten kannst du mal im Handbuch der Java Programmierung gucken oder auch hier:

http://www.javaalmanac.com/egs/java.io/TraverseTree.html?l=rel

Btw. ihr dürft wenigstens Programme mit halbwegs Sinn programmieren, wir machen oft nur Programme die fernab jeglicher Realität sind


----------



## Sindbad1983 (8. Apr 2005)

Hi!

Also wie man rekursiv die Verzeichnisse durchgeht, weiß ich leider nicht, nein...!

Aber ich bin jetzt eh erstmal dabei, die Klassenheirarchei aufzubauen!
Ich hab schon mal mit den Klassen begonnen!

Das ist glaub ich mal kein schlechter Anfang, oder?:




```
import java.util.*;


public class Node<UserData> implements Comparable<Node>{


	private String name;

	public String getName(){
		return name;
	}

	public void setName(String name){
		this.name=name;
	}

	private UserData userData;

	public UserData getUserData(){
		return userData;
	}

	public void setUserData(UserData userData){
		this.userData=userData;
	}

	public int compareTo(Node n) {
		 if (this instanceof DirectoryNode && !(n instanceof FileNode)){
			 return -1;
		 }
		 else if(!(this instanceof FileNode) && n instanceof DirectoryNode) {
			 return 1;
		 } else {
		 	return this.getName().compareTo(n.getName());
		 	//da kommen dann natürlich noch weitere else if -Varianten!!
		}
	 }

}
```

---------------------------------


```
import java.util.*;


public class DirectoryNode <UserData> extends Node<UserData>{

	private SortedSet <Node<UserData>> elems;


	public DirectoryNode(){
		this.elems=new TreeSet<Node<UserData>>();
	}



}
```

-----------------------------------


```
public class FileNode<UserData> extends Node<UserData>{

	private int length;

	public int getLength(){
		return length;
	}

}
```


Der nächste Schritt ist, glaub ich, dass ich die verschiedenen Elemente in die Liste einfüge(also in die SortedSet) oder? bzw. diese dann wieder ausgib?!!?


----------



## Sindbad1983 (11. Apr 2005)

hi..ich häng grad ein bissl beim compareTo()..
könnte mir bitte jemand helfen?

Nochmal zur Errinnerung:

Dateien und Verzeichnisse sollen nach folgenden Kriterien sortiert werden (angelehnt an die Sortierung 
im Explorer von Windows XP): 

• Verzeichnisse vor Dateien. 
• Verzeichnisse alphabetisch. 
• Dateien, deren Name mit einer Zahl beginnt, aufsteigend nach dieser Zahl. Negative Zahlen 
können ignoriert werden. 
• Wenn die Zahl am Beginn gleich ist, oder wenn am Beginn keine Zahl steht, alphabetisch. 

Bei der alphabetischen Sortierung soll die Groß- und Kleinschreibung ignoriert werden. Es soll nicht 
möglich sein, dass ein Verzeichnis zwei Elemente enthält, die nach diesen Kriterien gleich sind. 
Beispiel für eine korrekte Sortierung von Dateinamen: "2 ab", "2 Ac", "10 ab", "ab", "aC". 



```
public class Node<UserData> implements Comparable<Node>{


	private String name;

	public String getName(){
		return name;
	}

	public void setName(String name){
		this.name=name;
	}

	private UserData userData;

	public UserData getUserData(){
		return userData;
	}

	public void setUserData(UserData userData){
		this.userData=userData;
	}

	public int compareTo(Node n) {
		 if (this instanceof DirectoryNode && !(n instanceof FileNode)){
			 return -1;
		 }
		 else if(!(this instanceof FileNode) && n instanceof DirectoryNode) {
			 return 1;
		 }
		 else if(this instanceof DirectoryNode && n instanceof DirectoryNode){
			 String s=this.getName();
			 String s2=n.getName();
			 char a='a';
			 int index1=s.indexOf(' ');
			 int index2=s2.indexOf(' ');
			 String t=s.substring(0, index1);
			 String t2=s2.substring(0,index2);
			 int ergebnis1=Integer.parseInt(t);
			 int ergebnis2=Integer.parseInt(t2);

				if(ergebnis1<ergebnis2){
					return -1;
				}
				else if(ergebnis1>ergebnis2){
					return 1;
				}
				else{
					return 0;
				}
	 	 }
	 	 else if(this instanceof FileNode && n instanceof FileNode){
		 			 String s=this.getName();
		 			 String s2=n.getName();
		 			 char a='a';
		 			 int index1=s.indexOf(' ');
		 			 int index2=s2.indexOf(' ');
		 			 String t=s.substring(0, index1);
		 			 String t2=s2.substring(0,index2);
		 			 int ergebnis1=Integer.parseInt(t);
		 			 int ergebnis2=Integer.parseInt(t2);

		 				if(ergebnis1<ergebnis2){
		 					return -1;
		 				}
		 				else if(ergebnis1>ergebnis2){
							return 1;
						}
						else{
							return 0;
						}

	 	 }
		 else {
		 	return this.getName().compareTo(n.getName());
		}
	 }

}
```

---------------------------
Die anderen Klassen sind gleich geblieben bis jetzt...
Macht das Sinn, was ich da mache?
Oder muss ich die if...else Schleifen anders anordnen?
Und wie bzw. wo bekomm ich das ignoreCase rein??


----------



## mic_checker (11. Apr 2005)

> else if(this instanceof DirectoryNode && n instanceof DirectoryNode){
> String s=this.getName();
> String s2=n.getName();
> char a='a';
> ...



Wofür genau soll das gut sein? WIllst du damit kontrollieren welche Zahl am Anfang größer ist?

Ich denke das mit der Zahl am Anfang des Strings hat sich im andern Thread ja jetzt geklärt...

edit:
btw. kannst du davon ausgehen dass nachdem eine Zahl kommt ein Leerzeichen steht?


----------



## SebiB90 (11. Apr 2005)

eh...
wieso diese Generics da???
so wie ich das verstanden hab muss die variable userData von Typ Date sein und das Datum der letzten änderung sein. für was sind dann die generics da da?
und mit dem Compareto da kannst du nicht in der klasse node machen da musst du in den klassen machen die von node erben. Ich würd Node abstract machen und dort eine abstracte methode compareTo().


----------



## Sindbad1983 (11. Apr 2005)

ja...wenn Zahlen vorkommen, dann ist ein Leerzeichen dazwischen!

also:   

abc
2 abc
10 abc  etc.

und in der Methode hol ich mir die Zahlen bis zum Leerzeichen raus und vergleich sie dann auf Gleichheit bzw. welche größer ist! Das geht..ist aber vielleicht ein bissl umständlich!   :roll: 

Die Generics müssen wir so verwenden..also das stimmt schon so! Und die compareTo-Methode gehört auch in die Klasse Node..so wurde es zumindest gesagt...!   
Das dürft schon funktionieren!


----------



## Sindbad1983 (11. Apr 2005)

also dein Beispiel im anderen Thread hat mich ein wenig verwirrt..
3abc
2abc

? was kommt jetzt vorher? wie wird sortiert?
also im oberen Falle gibt er +1 zurück und sortiert 3abc vor 2abc oder umgekehrt?  ???:L 

was ist, wenn die Zahlen aufsteigend sortiert werden sollten?


```
if (this instanceof DirectoryNode && !(n instanceof FileNode)){ 
          return -1; 
       }
```

also hier wird DirNode vor FileNode sortiert, weil D kleiner ist als F, oder?
aber wieso gibt der überhaupt -1 zurück? hat das eine Auswirkung auf die Sortierreihenfolge?
Ich steh wohl grad auf der Leitung!  :bahnhof:


----------



## SebiB90 (12. Apr 2005)

Sindbad1983 hat gesagt.:
			
		

> Die Generics müssen wir so verwenden..also das stimmt schon so! Und die compareTo-Methode gehört auch in die Klasse Node..so wurde es zumindest gesagt...!


kannst du mal die komplette aufgabe posten, wo das steht?


----------



## Sindbad1983 (12. Apr 2005)

das steht nicht auf dem Angabezettel..wir haben vorher in der Stunde eine Beispiel exemplarisch durchexerziert!


----------



## SebiB90 (12. Apr 2005)

irgendwie idiotisch
was für klassen sollen das angegeben werden bei den generics???
userData is doch das letzte änderungsdatum oder hab ich falsch verstanden?
woher soll ne oberklasse von seinen unterklassen wissen compareTo kann nicht in der oberklasse sein höchsten den namen kannst du überprüfen aber das mit datei oder ordner das musst du in den unterklassen machen. this instanceof ... das hab ich bisher noch nirgends gesehen.


----------



## Sindbad1983 (12. Apr 2005)

naja..ich find die ganze Aufgabe idiotisch!  :lol: 

Wir haben wie gesagt vorher nur ein vergleichbares beispiel gemacht..ich kann dir das mal posten wenn du willst...!



```
abstract public class GraphObject<UserData> implements Comparable<GraphObject> {
    private UserData userData;
    
    public UserData getUserData() {
        return userData;
    }
    
    public void setUserData(UserData userData) {
        this.userData = userData;
    }
    
    
    abstract public void draw();

    public int compareTo(GraphObject o) {
        return getMinimumX() - o.getMinimumX();
    }

    protected abstract int getMinimumX();
}
```

--------------------------------------------------


```
package graphical;

import java.util.SortedSet;
import java.util.TreeSet;

public class GraphComposite<UserData> extends GraphObject<UserData> {
    private SortedSet<GraphObject<UserData>> elems; 

    public GraphComposite() {
        this.elems = new TreeSet<GraphObject<UserData>>();
    }
    
    public GraphComposite(GraphObject<UserData>[] elems) {
        this();
        
        for (int i = 0; i < elems.length; i++) {
            this.elems.add(elems[i]);
        }
    }
    
    public void addElem(GraphObject<UserData> elem) {
        elems.add(elem);
    }
    
    public void removeElem(GraphObject<UserData> elem) {
        elems.remove(elem);
    }
    
    public GraphObject<UserData>[] getElems() {
        return elems.toArray((GraphObject<UserData>[])new GraphObject[elems.size()]);
    }
    
    public void draw() {
        for (GraphObject elem : elems) {
            elem.draw();
        }
    }

    protected int getMinimumX() {
        return elems.first().getMinimumX();
    }
}
```

-------------------------------------------------------


```
package graphical;

abstract public class GraphPrimitive<UserData> extends GraphObject<UserData> {
    private int x;
    private int y;

    public GraphPrimitive(int x, int y) {
        this.x = x;
        this.y = y;
    }

    protected int getX() {
        return x;
    }

    protected int getY() {
        return y;
    }
}
```

-----------------------------------------------------


```
package graphical;

import inout.Window;

import java.awt.Color;

public class Circle<UserData> extends GraphPrimitive<UserData> {
    private int r;

    public Circle(int x, int y, int r) {
        super(x, y);
        this.r = r;
    }

    protected int getR() {
        return r;
    }

    
    public void draw() {
        Window.fillCircle(getX(), getY(), getR(), Color.LIGHT_GRAY);
    }

    protected int getMinimumX() {
        return getX() - getR();
    }
}
```


----------------------------------------------------------


```
package graphical;

import inout.Out;
import inout.Window;

public class Snowman {
	public static void main(String args[]) {
		GraphObject<String> hut1 = new Rectangle<String>(130, 120, 40, 10);
		GraphObject<String> hut2 = new Rectangle<String>(140, 90, 20, 30);
		GraphComposite<String> hut = new GraphComposite<String>();
        hut.addElem(hut1); 
        hut.addElem(hut2); 
		
		Rectangle<String> beinL = new Rectangle<String>(100, 300, 45, 100);
		Rectangle<String> beinR = new Rectangle<String>(155, 300, 45, 100);
		Circle<String> body = new Circle<String>(150, 250, 60);
		Circle<String> kopf = new Circle<String>(150, 160, 30);
		Rectangle<String> armL = new Rectangle<String>(60, 210, 40, 30);
		Rectangle<String> armR = new Rectangle<String>(200, 210, 40, 30);
		
		GraphComposite<String> snowMan = new GraphComposite<String>();
        snowMan.addElem(hut);
        snowMan.addElem(armL);
        snowMan.addElem(armR);
        snowMan.addElem(kopf);
        snowMan.addElem(body);
        snowMan.addElem(beinR);
        snowMan.addElem(beinL);

		Window.open();
		
		snowMan.draw();
        Out.println("Minimum X: " + snowMan.getMinimumX());
	}
}
```


------------------------------------------------------------


Es wurde uns gesagt, wir sollen uns an diesem Beispiel orientieren!
Mehr weiß ich auch nicht!

Und der komplette Angabezettel steht ganz oben im ersten Post!  :### 

Das mit dem Generics ist mir nicht wirklich klar, aber ich glaub, wie ichs gemacht hab, müsste es schon halbigs hinhaun!

Das mit dem this instanceof hat mir der LVA-Leiter gesagt..das dürfte stimmen!    :wink: 

Wieso wo möchtest denn du die compareTo-Methode implementieren???
Glaubst stimmt das nicht so, wie ichs gemacht hab?


----------



## Sindbad1983 (12. Apr 2005)

naja..ich hab mich jetzt erkundigt, und es hat geheißen, dass UserData erst für Teil B der Aufgabe relevant ist.. also dass man darin dann einen bestimmten Typ speichern kann! ..wie du richtig gesagt hast, um das Änderungsdatum darin zu speichern-> Type date!! ..also dazu verwende ich UserData! Aber von Teil B bin ich leider noch ein bissl entfernt!

Beim Vorzeigebeispiel haben die String reingespeichert in userData...um den Namen der einzelnen Teile des Schneemanns zu benennen, denk ich mal...!

Ehrlich gesagt, steh ich jetzt an!
Ich weiß nicht, wie ich das jetzt ausprobieren kann, obs funktioniert!
Wie könnt ich da weitermachen?
Brauch ich eine neue Klasse zum Testen?
Kann mir  bitte jemand helfen?  :autsch: 

Ich möcht einfach nur mal ausprobiern, ob er die verschiednen Elemente in der Liste speichert und sie auch richtig ausgibt!


Das hab ich bisher gemacht:







```
public class Node<UserData> implements Comparable<Node>{


   protected String name;

   public String getName(){
      return name;
   }

   public void setName(String name){
      this.name=name;
   }

   private UserData userData;

   public UserData getUserData(){
      return userData;
   }

   public void setUserData(UserData userData){
      this.userData=userData;
   }

   public int compareTo(Node n) {
       if (this instanceof DirectoryNode && !(n instanceof FileNode)){
          return -1;
       }
       else if(!(this instanceof FileNode) && n instanceof DirectoryNode) {
          return 1;
       }
       else if(this instanceof DirectoryNode && n instanceof DirectoryNode){
          String s=this.getName();
          String s2=n.getName();
          char a='a';
          int index1=s.indexOf(' ');
          int index2=s2.indexOf(' ');
          String t=s.substring(0, index1);
          String t2=s2.substring(0,index2);
          int ergebnis1=Integer.parseInt(t);
          int ergebnis2=Integer.parseInt(t2);

            if(ergebnis1<ergebnis2){
               return -1;
            }
            else if(ergebnis1>ergebnis2){
               return 1;
            }
            else{
               return 0;
            }
        }
        else if(this instanceof FileNode && n instanceof FileNode){
                 String s=this.getName();
                 String s2=n.getName();
                 char a='a';
                 int index1=s.indexOf(' ');
                 int index2=s2.indexOf(' ');
                 String t=s.substring(0, index1);
                 String t2=s2.substring(0,index2);
                 int ergebnis1=Integer.parseInt(t);
                 int ergebnis2=Integer.parseInt(t2);

                   if(ergebnis1<ergebnis2){
                      return -1;
                   }
                   else if(ergebnis1>ergebnis2){
                     return 1;
                  }
                  else{
                     return 0;
                  }

         }
         else {
          		return this.getName().compareTo(n.getName());
         }
    }


    public String toString(){
		//die brauch ich wahrscheinlich auch noch...
			String s1="  ";
			return s1;
	}
}
```

-------------------------------------


```
import java.util.*;


public class DirectoryNode <UserData> extends Node<UserData>{



	private SortedSet <Node<UserData>> elems;


	public DirectoryNode(){
		this.elems=new TreeSet<Node<UserData>>();
	}

	public DirectoryNode(Node<UserData> [] elems){
		this();

		for(int i=0;i<elems.length;i++){
			this.elems.add(elems[i]);
		}
	}

	public void addElem(Node <UserData> elem){
		elems.add(elem);
	}

	public void removeElem(Node <UserData> elem){
		elems.remove(elem);
	}

	public Node<UserData> [] getElems(){
		return elems.toArray ((Node <UserData>[]) new Node[elems.size()]);
	}



}
```

---------------------------------------------------------------


```
class FileNode<UserData> extends Node <UserData>{

	int length;


	public FileNode(String name, int length){
		this.name=name;//da bin ich mir auch nicht sicher, ob das geht..
		this.length=length;
	}


	public int getLength(){
		return length;
	}


}
```

Danke für die Hilfe!


----------



## SebiB90 (12. Apr 2005)

um das zu testen musst du halt ne main methode einbauen und die methoden der funktionen aufrufen
oder du baust ne methode ein das einen ordner inclusive unterordner ausließt. Musst du das nicht auch noch machen oder ist das teil b?


----------



## SebiB90 (12. Apr 2005)

das mit dem auslesen ist teil b wie ich grad gesehen habe.
was dir fehlt ist eine toString methode in den unterklassen und eine methode zum sortieren, die vor der ausgabe aufgerufen werden muss.

wo ich mir grad die aufgabe mal näher angesehen habe, ist die ganz einfach. Die Sortierung hast du schon also compareTo mein ich und das war eingetlich das schwierigste find ich. jetzt brauchst du nur noch ne klasse mit einer main methode die ein Verzeichnis ausließt.


----------



## Sindbad1983 (12. Apr 2005)

ja..das gehört schon zu Teil B..
aber ich weiß nicht, wie das geht?
Datei- und Verzeichnis-Liste für ein Verzeichnis der Festplatte ausgeben.. keine Ahnung! :-(

Naja..für die main-Methode brauch ich eine eigene neue Klasse...aber ob das dann mit der Generizität auch schon funktioniert, wenn ich nur die Methoden aufruf...??
Weißt du, wie das funktioniert?


----------



## Sindbad1983 (12. Apr 2005)

ganz einfach...na dann! ;-)
Ich programmier leider noch nicht so lang!


----------



## SebiB90 (12. Apr 2005)

also das mit dem auslesen
du bekommst ja einen Pfad mit dem erstellt du ein File object. mit listFiles kannst du alle Dateien auflisten mit isDirectory() kannst du überprüfen ob es ein ordner ist oder nicht

```
public DirectoryNode<Date> auslesen(File directory) {
DirectoryNode<Date> directory = DirectoryNode<Date>(directory.getName());
File[] list = directory.listFiles();
for(File file: list) {
  if(file.isDirectory()) {
    DirectoryNode<Data> temp_directory = this.auslesen(file);
    directory.addElem(temp_directory);   
  }else {
    FileNode<Date> temp_file = new FileNode<Date>();
    //..daten auslesen name, letzte änderung, größe
    directory.addElem(temp_file);  
  }
}
return directory;
```
so hab jetzt keine zeit mehr code zu erklären, muss jetzt weg
erklär es später


----------



## Sindbad1983 (12. Apr 2005)

Ich habs jetzt mal mit String probiert....weil Date nimmt er nicht! Oder geht das anders?  


```
public class TestNode{

	public static void main(String [] args){


		Node <String> verzeichnis1=new DirectoryNode<String>();
		Node <String> verzeichnis2=new DirectoryNode<String>();
		Node <String> datei1=new FileNode<String>("dat",100);

		verzeichnis1.addElem(datei1);

	}


}
```


10: cannot find symbol
symbol  : method addElem(Node<java.lang.String>)
location: class Node<java.lang.String>
		verzeichnis1.addElem(datei1);
                            ^
1 error

Prozess beendet mit Exit-Code 1



ok..das geht schon mal nicht!  :cry:


----------



## Sindbad1983 (12. Apr 2005)

wahnsinn...das schaut stark aus!
ich muss eh auch dann schnell weg!
Danke, dass du mir hilfst!
ciao


----------



## mic_checker (12. Apr 2005)

Sindbad1983 hat gesagt.:
			
		

> also dein Beispiel im anderen Thread hat mich ein wenig verwirrt..
> 3abc
> 2abc
> 
> ...



Weiss net genau wie aktuell diese Frage von dir noch ist, aber ich beantworte sie einfach mal 

Du hast z.B. folgenden Input:

- 3SBC
- 2SBC
- SBC
- sbc

2SBC < 3SBC < SBC < sbc

Demnach kriegst du bei der Sortierung (mit compareTo()):

2SBC
3SBC
SBC
sbc

Btw. zum Thema Verzeichnisse auflisten etc. Hab schon in meiner ersten Antwort geschrieben:
http://www.javaalmanac.com/egs/java.io/TraverseTree.html?l=rel 

Oder im Handbuch der Java Programmierung siehst auch ein Beispiel dazu.


----------



## SebiB90 (12. Apr 2005)

Sindbad1983 hat gesagt.:
			
		

> Ich habs jetzt mal mit String probiert....weil Date nimmt er nicht! Oder geht das anders?


vllt. import vergessen? 
java.util.Date 


			
				Sindbad1983 hat gesagt.:
			
		

> ```
> public class TestNode{
> 
> public static void main(String [] args){
> ...


das ist weil die klasse Node gar keine methode addElem hat nur DirectoryNode hat diese, deshalb muss der Variablen Typ auch DirectoryNode sein.


----------



## Sindbad1983 (13. Apr 2005)

hi!
mir sind  die Konstruktoren  nicht ganz klar! Die unten stehenden Methoden habe ich ja vom Probebeispiel übernommen und adaptiert:
-mit SortedSet kann ich die Elemente sortiert einfügen;
- wenn ich den leeren Konstruktor aufrufe (also wenn ich ein neues Directory-Objekt instanzieren möchte), dann macht  er eine neue Liste, in der ich die weiteren Unterverzeichnisse und Files darin speichern kann;
-im 2.Konstruktor übergib ich ihm ein Array mit Node-Elementen, dann ruf ich den parameterlosen Konstruktor auf und in der for-Schleife durchlauf ich das array und füge Elemente an der Stelle i an!!???? Wozu brauch ich das?
Ich hab ja eh unten die addElem-Methode!?
- außerdem bräuchte ich ja noch einen Konstruktor, in dem ich den Namen des Verzeichnisses angib, oder nicht?


weil danach beim Aufruf:


```
DirectoryNode <Date> verzeichnis1=new DirectoryNode<Date>();
```

muss ich ihm ja den Namen übergeben..


also z.B. könnte er so aussehen oder?

```
public DirectoryNode(String name){
this.name=name;
this.elems=new TreeSet<Node<UserData>>();
}
```


also hier nochmal der Code zu den obigen fragen:


```
public class DirectoryNode <UserData> extends Node<UserData>{



	private SortedSet <Node<UserData>> elems;


	public DirectoryNode(){
		this.elems=new TreeSet<Node<UserData>>();
	}

	public DirectoryNode(Node<UserData> [] elems){
		this();

		for(int i=0;i<elems.length;i++){
			this.elems.add(elems[i]);
		}
	}
```

Ich hoffe, die Fragen sind nicht zuu verwirrend!  :autsch:


----------



## SebiB90 (13. Apr 2005)

also mit dem namen übergeben ist schon richtig.
bei dem mit dem Node array würd ich es so machen

```
public DirectoryNode(Node<UserData> [] elems){ 
      this.elems=new TreeSet<Node<UserData>>(); 

      for(Node<UserData> elem: elems){ 
         this.elems.add(elem); 
      } 
   }
```


----------



## Sindbad1983 (13. Apr 2005)

ja und wozu brauch ich das?
warum füg ich da im Konstruktor ein Element hinzu?
und vor allem welches? :-(
also das versteh ich überhaupt nicht!


----------



## SebiB90 (13. Apr 2005)

ob du diesen konstrucktor überhaupt brauchst weiß ich nicht, glaub ich eher nicht.
du übergibst ein arrey mit nodes und diese nodes werden hinzugefügt.


----------



## Sindbad1983 (13. Apr 2005)

also ich glaub ich nehm diesen Konstruktor wieder raus!
Den check ich nicht!
So ist es weitaus verständlicher!


```
public class DirectoryNode <UserData> extends Node<UserData>{



	private SortedSet <Node<UserData>> elems;


	public DirectoryNode(String name){
		this.name=name;
		this.elems=new TreeSet<Node<UserData>>();
	}


	public void addElem(Node <UserData> elem){
		elems.add(elem);
	}
```

Wenn ich ein neues Verzeichnis erstelle, dann gib ich den Namen an und der Konstruktor erstellt mir dann automatisch eine Liste, der ich  diesem Verzeichnis  zugehörige Unterverzeichnisse und dateien hinzufügen kann!
Das müsste so passen, oder?


```
import java.util.*;

public class TestNode{

	public static void main(String [] args){


		DirectoryNode <Date> verzeichnis1=new DirectoryNode<Date>("abc");
		DirectoryNode <Date> verzeichnis2=new DirectoryNode<Date>("bcd");
		Node <Date> datei1=new FileNode<Date>("dat",100);
		Node <Date> datei2=new FileNode<Date>("dat2",100);



		verzeichnis1.addElem(verzeichnis2);
		verzeichnis1.addElem(datei1);
		verzeichnis1.addElem(datei2);


	}


}
```

PS:Find ich sehr cool, dass du immer so schnell zurückschreibst! Danke!  :applaus:


----------



## SebiB90 (13. Apr 2005)

soweit ich es sehen kann, hast du jetzt den 1.teil fertig.
jetzt nur noch das auslesen der dateien.

ah ne du musst noch ne sortier methode einbauen oder macht SortedSet das alleine?
und die toString() methode fehlt noch.


----------



## Sindbad1983 (13. Apr 2005)

also wie ich das sehe, brauch ich da keine Methode mehr zum Sortieren!
Weil mit "implements Comparable" müsste die Sortierfunktionalität in der SortedSet gegeben sein!

Jetzt fehlt glaub ich nur noch die toString()-Methode...

ich würd vorschlagen, dass sie nur in DirectoryNode implementiert wird, weil ich ja in dieser Klasse Zugriff auf "elems" hab, oder? ???:L


----------



## SebiB90 (13. Apr 2005)

bei FileNode doch auch oder warum nicht?


----------



## Sindbad1983 (13. Apr 2005)

naja..weil ein File ohne Verzeichnis nicht sein kann!
Und in File hab ich da nichts, worauf ich zugreifen kann!
In DirectoryNode kann ich auf die Elemente der SortedSet zugreifen, über diese iterieren und sie dann ausgeben!
Naja..ich weiß es auch nicht..habs halt mal so probiert!
Geht natürlich nicht!  :cry: 


in der Klasse DirectoryNode:


```
public String toString(){

		StringBuffer sb=new StringBuffer();

			Iterator it=elems.iterator();

			while(it.hasNext()){
				sb=sb.append(it.next());
			}


			return sb.toString();


	}
```


----------



## SebiB90 (13. Apr 2005)

ich würd in FileNode eine toString() methode die name, letzte änderung und größe in einem string zurück gibt.
und dann so in DirectoryNode

```
public String toString(){ 

      StringBuffer sb=new StringBuffer(); 

         Iterator it=elems.iterator(); 

         while(it.hasNext()){ 
            sb=sb.append(it.next().toString()); 
         } 


         return sb.toString(); 


   }
```


----------



## Sindbad1983 (13. Apr 2005)

ja..die Idee ist gut, dass ich 2 verschiedene toString-Methoden implementiere..
ich könnte auch in der Basisklasse eine toString-Methode definieren, die nur den NAmen ausgibt und dann in den 2 anderen Klassen diese toString() erweitern!


in der Klasse Node:

```
public String toString(){

			String s1="";

			s1=s1+getName();
			return s1;
	}
```

Aber wies jetzt weitergeht, weiß ich nicht mehr! Die toString-Methode in DirectoryNode ist glaub ich falsch...
weiß nicht, ob das so stimmt! Denn ich iterier über alle Elemente von elems drüber und das sind ja sowohl Verzeichnisse als auch Files..aber wie weiß der dann welche toString-Methode er aufrufen muss...


bei 


```
while(it.hasNext()){
            sb=sb.append(it.next().toString());
        }
```

gibt er alle aus..egal welchen Typs...da müsst ich dann unterscheiden zw. Verzeichnisse und Files, oder?


Aber das ist mir zu schwer...tut mir leid!  :autsch: 
Keine Ahnung wie das geht...


----------



## SebiB90 (13. Apr 2005)

du musst nicht unterscheiden, das macht er selbst wenn es DirectoryNode ist wird von dem toString() aufgerufen wenns FileNode ist von FileNode die toString() methode, so sollte es jedenfalls sein oder?(frage an andere User)
aber ich mein schon das das so ist, werd ich später ausprobieren

und bei der Klasse Node, wieso noch 2 andere Strings erstellen, das kostet speicher und zeit, mach es so


```
public String toString(){ 
         return getName();  
   }
```


----------



## Sindbad1983 (13. Apr 2005)

also irgendwo muss da noch ein Fehler sein:

denn die Ausgabe ist nicht die gewünschte:
auch wenn ich momentan nur möchte, dass einfach nur der Name des Elements ausgeben wird:



[LNode;@f6a746
Drücken Sie eine beliebige Taste . . .


ich kopier jetzt nochmal den letzten Stand rein:



```
public class Node<UserData> implements Comparable<Node>{


   protected String name;

   public String getName(){
      return name;
   }

   public void setName(String name){
      this.name=name;
   }

   private UserData userData;

   public UserData getUserData(){
      return userData;
   }

   public void setUserData(UserData userData){
      this.userData=userData;
   }

   public int compareTo(Node n) {
       if (this instanceof DirectoryNode && !(n instanceof FileNode)){
          return -1;
       }
       else if(!(this instanceof FileNode) && n instanceof DirectoryNode) {
          return 1;
       }
       else if(this instanceof DirectoryNode && n instanceof DirectoryNode){
          String s=this.getName();
          String s2=n.getName();
          char a='a';
          int index1=s.indexOf(' ');
          int index2=s2.indexOf(' ');
          String t=s.substring(0, index1);
          String t2=s2.substring(0,index2);
          int ergebnis1=Integer.parseInt(t);
          int ergebnis2=Integer.parseInt(t2);

            if(ergebnis1<ergebnis2){
               return -1;
            }
            else if(ergebnis1>ergebnis2){
               return 1;
            }
            else{
               return 0;
            }
        }
        else if(this instanceof FileNode && n instanceof FileNode){

				String s=this.getName();
			    String s2=n.getName();


			if((Character.isDigit(s.charAt(0))) || (Character.isDigit(s2.charAt(0)))){


                 int index1=s.indexOf(' ');
                 int index2=s2.indexOf(' ');
                 String t=s.substring(0, index1);
                 String t2=s2.substring(0,index2);
                 int ergebnis1=Integer.parseInt(t);
                 int ergebnis2=Integer.parseInt(t2);

                   if(ergebnis1<ergebnis2){
                      return -1;
                   }
                   else if(ergebnis1>ergebnis2){
                     return 1;
                  }
                  else{
                     return 0;
                  }
			 }

         }

          		return this.getName().compareTo(n.getName());

    }


    public String toString(){

			return getName();
	}
}
```

----------------------------


```
import java.util.*;


public class DirectoryNode <UserData> extends Node<UserData>{



	private SortedSet <Node<UserData>> elems;


	public DirectoryNode(String name){
		this.name=name;
		this.elems=new TreeSet<Node<UserData>>();
	}


	public void addElem(Node <UserData> elem){
		elems.add(elem);
	}

	public void removeElem(Node <UserData> elem){
		elems.remove(elem);
	}

	public Node<UserData> [] getElems(){
		return elems.toArray ((Node <UserData>[]) new Node[elems.size()]);
	}


	/*public String toString(){

		StringBuffer sb=new StringBuffer();

			Iterator it=elems.iterator();

			while(it.hasNext()){
				sb=sb.append(it.next().toString());
			}


			return sb.toString();


	}*/


}
```

--------------------------------------


```
import java.util.*;


class FileNode<UserData> extends Node <UserData>{

	int length;


	public FileNode(String name, int length){
		this.name=name;
		this.length=length;
	}


	public int getLength(){
		return length;
	}





}
```

-------------------------------------------


```
import java.util.*;

public class TestNode{

	public static void main(String [] args){

		Node [] elems;


		DirectoryNode <Date> verzeichnis1=new DirectoryNode<Date>("abc");
		DirectoryNode <Date> verzeichnis2=new DirectoryNode<Date>("bcd");
		Node <Date> datei1=new FileNode<Date>("dat",100);
		Node <Date> datei2=new FileNode<Date>("dat2",100);



		verzeichnis1.addElem(verzeichnis2);
		verzeichnis1.addElem(datei1);
		verzeichnis1.addElem(datei2);

		elems=verzeichnis1.getElems();
		System.out.println(elems.toString());


	}


}
```

-------------------------------------------
Vielleicht kann uns dabei jemand helfen bitte...!  :roll:


----------



## SebiB90 (13. Apr 2005)

```
elems=verzeichnis1.getElems(); 
      System.out.println(elems.toString());
```
wieso das???
du hast die toString methode in der DirectoryNode Klasse und nicht in einer Array klasse.
so geht das:

```
System.out.println(verzeichnis1.toString());
```


----------



## SebiB90 (13. Apr 2005)

ah ja und diese methode

```
public Node<UserData> [] getElems(){ 
      return elems.toArray ((Node <UserData>[]) new Node[elems.size()]); 
   }
```
was willst du da casten? das array?? wofür?

```
public Node<UserData> [] getElems(){ 
      return elems.toArray (new Node<Date>[elems.size()]); 
   }
```


----------



## Sindbad1983 (13. Apr 2005)

geil!!!
es geht!


aber das Verzeichnis gibt er halt nicht aus


datdat2
Drücken Sie eine beliebige Taste . . .


----------



## SebiB90 (13. Apr 2005)

Sindbad1983 hat gesagt.:
			
		

> aber das Verzeichnis gibt er halt nicht aus


wie meinst du das?
meinst du den pfad?


----------



## Sindbad1983 (13. Apr 2005)

ja


----------



## SebiB90 (13. Apr 2005)

du hast ja auch keinen angegeben
du könntest noch eine variable path machen


----------



## Sindbad1983 (13. Apr 2005)

schon oder:



```
DirectoryNode <Date> verzeichnis1=new DirectoryNode<Date>("abc");
		DirectoryNode <Date> verzeichnis2=new DirectoryNode<Date>("bcd");
		Node <Date> datei1=new FileNode<Date>("dat",100);
		Node <Date> datei2=new FileNode<Date>("dat2",100);



		verzeichnis1.addElem(verzeichnis2);
		verzeichnis1.addElem(datei1);
		verzeichnis1.addElem(datei2);


		System.out.println(verzeichnis1.toString());
```


also soll er ausgeben:


abc 
    bdc
        dat
            dat2

oder täusch ich mich da??


----------



## Sindbad1983 (13. Apr 2005)

```
public Node<UserData> [] getElems(){
	      return elems.toArray (new Node <UserData>[elems.size()]);
	   }


	/*public Node<UserData> [] getElems(){
		return elems.toArray ((Node <UserData>[]) new Node[elems.size()]);
	}*/
```


Fehlermeldung:

27: generic array creation
	      return elems.toArray (new Node <UserData>[elems.size()]);
                                    ^


----------



## SebiB90 (13. Apr 2005)

du hast die toString() methode von DirectoryNode auskommentiert, deshalb wurde die toString() methode von Node nicht überschrieben und die wird ausgegeben


----------



## SebiB90 (13. Apr 2005)

Sindbad1983 hat gesagt.:
			
		

> ```
> public Node<UserData> [] getElems(){
> return elems.toArray (new Node <UserData>[elems.size()]);
> }
> ...


oder lass das wie es vorher war, damit kenn ich mich nicht so gut aus.


----------



## Sindbad1983 (13. Apr 2005)

nein...die hab ich schon wieder "in Betrieb" genommen!
Geht trotzdem nicht!
Und die Vergleiche haun auch nicht hin!


bei dat und dat2 passt alles
hingegen bei 2dat und 3 dat 


```
DirectoryNode <Date> verzeichnis1=new DirectoryNode<Date>("abc");
		DirectoryNode <Date> verzeichnis2=new DirectoryNode<Date>("bcd");
		Node <Date> datei1=new FileNode<Date>("2dat",100);
		Node <Date> datei2=new FileNode<Date>("3dat",100);
```

gibts eine 


Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String ind
ex out of range: -1
        at java.lang.String.substring(String.java:1768)
        at Node.compareTo(Node.java:63)
        at Node.compareTo(Node.java:1)
        at java.util.TreeMap.compare(TreeMap.java:1093)
        at java.util.TreeMap.put(TreeMap.java:465)
        at java.util.TreeSet.add(TreeSet.java:210)
        at DirectoryNode.addElem(DirectoryNode.java:19)
        at TestNode.main(TestNode.java:19)
Drücken Sie eine beliebige Taste . . .

 :cry: 


Mensch, du brauchst dich aber echt nicht den ganzen Tag mit meinen blöden Fragen herumschlagen...


----------



## SebiB90 (13. Apr 2005)

```
int index1=s.indexOf(' '); 
                 int index2=s2.indexOf(' '); 
                 String t=s.substring(0, index1); // <-fehler ensteht hier, weil index1 = -1
                 String t2=s2.substring(0,index2);
```
wieso suchst du hier ein leerzeichen bzw den index von einem leerzeichen?
du musst gucken wie lang die zahl ist.
vllt. per for schleife den string durchgehen und kontrollieren bis isDigit() = false


----------



## Sindbad1983 (13. Apr 2005)

naja..ich hätt ma eigentlich gedacht, dass die Idee nicht so schlecht ist
weil wie du unten siehst, können Zahlen auch davor stehen

z.B. 
abc
2 abc
100 abc

ich such immer bis zum Leerzeichen, lass mir dann die Zahl zurückgeben, vergleich die beiden Zahlen und dann werden sie sortiert..eigentlich müsste das funktionieren..


Fri Apr 01 07:00:00 CEST 2005 [DIR] 
100 abc Fri Apr 01 08:00:00 CEST 2005 [DIR] 
file 1 in dir Fri Apr 01 08:00:01 CEST 2005 (10 bytes) 
file 2 in dir Fri Apr 01 08:00:02 CEST 2005 (20 bytes) 
20 abc Fri Apr 01 08:01:00 CEST 2005 [DIR] 
3 abc Fri Apr 01 08:02:00 CEST 2005 [DIR] 
abc Fri Apr 01 08:03:00 CEST 2005 [DIR] 
file 1 in dir Fri Apr 01 08:03:01 CEST 2005 (30 bytes) 
file 2 in dir Fri Apr 01 08:03:02 CEST 2005 (40 bytes) 
3 abc.txt Fri Apr 01 08:04:00 CEST 2005 (10 bytes) 
20 abc.txt Fri Apr 01 08:05:00 CEST 2005 (20 bytes) 
100 abc.txt Fri Apr 01 08:06:00 CEST 2005 (30 bytes)


----------



## SebiB90 (13. Apr 2005)

aber in deinem beispiel fehlt das leerzeichen zwischen zahl und dem rest. index1 = -1 weil es kein leerzeichen gibt und dann die methode -1 zurück gibt wenn er nix findet.

und sollen dateien im unterverzeichniss nach dem ordner sofort ausgegeben werden? wenn ja dann wird es irgendwie unübersichtlich wenn man nicht den pfad dazu angibt.


----------



## Sindbad1983 (13. Apr 2005)

aja...sorry..habs grad gesehen..mein fehler!   

hab das leerzeichen vergessen;


Node <Date> datei1=new FileNode<Date>("2 bat",100);
Node <Date> datei2=new FileNode<Date>("3 kat",100);


2 bat3 kat
Drücken Sie eine beliebige Taste . . .


Spitze!!Es geht! nur den Verzeichnisnamen gibt er nicht aus!  :cry:


----------



## SebiB90 (13. Apr 2005)

ich weiß jetzt warum
du musst nach dem erstellen des buffers 

```
sb.append(getName());
```
machen


----------



## Sindbad1983 (13. Apr 2005)

du bist gut...sehr gut!

und warum muss man das so machen?


----------



## SebiB90 (13. Apr 2005)

weil halt auch der name des ordners in den string muss und damit fügst du den namen in den string ein


----------



## Sindbad1983 (13. Apr 2005)

also das geht perfekt:


```
import java.util.*;

public class TestNode{

	public static void main(String [] args){

		


		DirectoryNode <Date> verzeichnis1=new DirectoryNode<Date>("abc ");
		DirectoryNode <Date> verzeichnis2=new DirectoryNode<Date>("bcd ");

		Node <Date> datei1=new FileNode<Date>("2 bat ",100);
		Node <Date> datei2=new FileNode<Date>("3 kat ",100);
		Node <Date> datei3=new FileNode<Date>("4 jat ",100);



		verzeichnis1.addElem(datei1);
		verzeichnis1.addElem(datei2);
		verzeichnis2.addElem(datei3);


		System.out.println(verzeichnis1.toString());
		System.out.println(verzeichnis2.toString());



	}


}
```


Ausgabe:

abc 2 bat 3 kat
bcd 4 jat
Drücken Sie eine beliebige Taste . . .


da hingegen passt die Reihenfolge nicht:




```
import java.util.*;

public class TestNode{

	public static void main(String [] args){




		DirectoryNode <Date> verzeichnis1=new DirectoryNode<Date>("abc ");
		DirectoryNode <Date> verzeichnis2=new DirectoryNode<Date>("bcd ");

		Node <Date> datei1=new FileNode<Date>("2 bat ",100);
		Node <Date> datei2=new FileNode<Date>("3 kat ",100);
		Node <Date> datei3=new FileNode<Date>("4 jat ",100);



		verzeichnis1.addElem(verzeichnis2);
		verzeichnis2.addElem(datei3);
		verzeichnis1.addElem(datei1);
		verzeichnis1.addElem(datei2);


		System.out.println(verzeichnis1.toString());
		System.out.println(verzeichnis2.toString());



	}


}
```

Ausgabe:

abc 2 bat 3 kat bcd 4 jat
bcd 4 jat
Drücken Sie eine beliebige Taste . . .
 :cry: 

weiß jemand warum?


----------



## SebiB90 (13. Apr 2005)

das ist auch klar.
verzeichnis2 ist im verzeichnis1 und auch die datei im unterverzeichnis wird ausgegeben. 
also wird auch verzeichnis2 ausgegeben
danach gibts du nochmal verzeichnis2 aus und deswegen die doppelung. also nur das hauptverzeichnis toString() und print() machen.


----------



## Sindbad1983 (13. Apr 2005)

ja..das stimmt, aber die Reihenfolge passt trotzdem nicht!


denn bei:


```
import java.util.*;

public class TestNode{

	public static void main(String [] args){




		DirectoryNode <Date> verzeichnis1=new DirectoryNode<Date>("bcd ");
		DirectoryNode <Date> verzeichnis2=new DirectoryNode<Date>("ecd ");

		Node <Date> datei1=new FileNode<Date>("4 bat ",100);
		Node <Date> datei2=new FileNode<Date>("2 kat ",100);
		Node <Date> datei3=new FileNode<Date>("3 jat ",100);



		verzeichnis1.addElem(verzeichnis2);
		verzeichnis1.addElem(datei1);
		verzeichnis1.addElem(datei2);



		System.out.println(verzeichnis1.toString());




	}


}
```

gibt er :


bcd 2 kat Laenge:100 4 bat Laenge:100 ecd
Drücken Sie eine beliebige Taste . . .

statt 

bcd ecd 2kat 100....... aus!!!


----------



## SebiB90 (13. Apr 2005)

fehler liegt in der compareTO METHODE

```
if (this instanceof DirectoryNode && !(n instanceof FileNode)){ 
          return -1; 
       } 
       else if(!(this instanceof FileNode) && n instanceof DirectoryNode) { 
          return 1; 
       }
```
da stimmt doch was nicht. wenn das ein ordner ist und n *keine* Datei ist dann return -1????
dat muss heißen wenn das ein ordner ist und n *eine* Datei ist dann return -1
das gleiche dadrunter also

```
if (this instanceof DirectoryNode && n instanceof FileNode){ 
          return -1; 
       } 
       else if(this instanceof FileNode && n instanceof DirectoryNode) { 
          return 1; 
       }
```


----------



## Sindbad1983 (13. Apr 2005)

genial...es geht

also das heißt :

-1 wenn das erste vor dem 2. stehen soll
+1 wenns umgekehrt sein soll, oder?


----------



## SebiB90 (13. Apr 2005)

-1 bedeutet kleiner als das object das angegeben wurde
1 bedeutet größer als das object das angegeben wurde
0 beide sind gleich

und es wird von klein nach groß sortiert also ist deine aussage richtig


----------



## SebiB90 (13. Apr 2005)

und jetzt noch zeilenumbrüche einbauen in die ausgabe, denn alles in einer reihe sieht nicht sxchön aus und noch die anderen daten hinzufügen wie im beispiel,also letzte änderung und größe


----------



## Sindbad1983 (13. Apr 2005)

wahnsinn!!!

Danke Mann, es funktioniert einwandfrei!
Hab noch ein bissl was ausprobiert und getestet bzw. verbessert!
Jetzt checkt er auch die meisten Spezialfälle!

Jetzt wär halt noch TEIL B interessant...aber das werd ich heut wohl nicht mehr schaffen;  :roll: 

Bin schon froh, dass TEIL A mal halbigs läuft!  :applaus: 

wo gehört die Methode hin, die den Pfad einliest, etc? in welche Klasse?
oder brauch ich da wieder ne eigene?


da muss ich ja eh nur mehr das lastmodified speichern und dann in der toString-Methode ausgeben oder?


----------



## SebiB90 (13. Apr 2005)

in teil b musst du "nur" die datei auslesen mit name, größe und letzte änderung und alle unterordner auch durchgehen.
ich würd diese methode statisch machen und die in die klasse mit der main methode packen.
und wieso heute nicht mehr geht doch schnell, ich hab doch schon ein kleines beispiel gepostet.


----------



## Sindbad1983 (13. Apr 2005)

ich bin noch hoch motiviert! 

 :bae: 

und jetzt erst ...nach dieser Ausgabe:


abc
ecd
11 fbc Laenge:100
100 abc Laenge:100
100 ebcLaenge:100

gcd
13 ubc Laenge:100
18 zbc Laenge:100
Drücken Sie eine beliebige Taste . . .

 :lol:


----------



## SebiB90 (13. Apr 2005)

sieht doch gut aus nur noch die "letzte änderung" fehlt da.

ich mach für heute schluss. gn8


----------



## Sindbad1983 (13. Apr 2005)

ok..danke nochmal für deine Hilfsbereitschaft heut!
Du hast mir sehr geholfen!

Ich werd auch Schluss machen!
Aber bei TEIL B fehlt mir irgendwie jegliche Verständnis!
Aber vielleicht wirds ja noch! 
GN8


----------



## SebiB90 (14. Apr 2005)

für teil b schau dir die Klasse java.io.File an.
mit isDirectory() und isFile() kannst du unterscheiden ob es eine datei ist oder nicht.
mit listFiles() bekommst du ein File array mit allen dateien in dem ordner, wenn es ein ordner ist.
mit lastModified() bekommst du die letzte änbderung raus und mit length() die datei größe
und dann würd ich die ordner rekrusiv auslesen, beispiel hab ich ja schon gegeben(paar seiten vorher)

so ich hoffe das hilft dir zunächst weiter.


----------



## Sindbad1983 (15. Apr 2005)

Hi Sebi!

Ich werd erst am WE wieder dazukommen!
Hab aber schon mit Teil B begonnen!
Da fehlt echt nimmer viel!
Aber leider wartet die neue HÜ schon wieder!
Mal schaun, wie es sich ausgeht!
Also bis bald!
Danke für deine Hilfe!Kennst du dich aus mit JUNIT?
ciao,Tommy


----------



## SebiB90 (15. Apr 2005)

ich weiß nicheinaml was JUnit ist.  
Da kann ich dir glaub ich nicht helfen.


----------



## Sindbad1983 (16. Apr 2005)

wer kennt sich mit JUNIT aus?  :roll:


----------

