Datei-Manager programmieren

[Sindbad1983]

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]

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]

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]

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]

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]

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]

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]

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]

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;
}

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]

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]

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]

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]

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]

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

 

[SebiB90]

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]

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]

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]

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]

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]

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]

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

 

[SebiB90]

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]

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]

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

 

[mic_checker]

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?

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]

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

vllt. import vergessen?
java.util.Date

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:

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

 

[Sindbad1983]

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]

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]

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]

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]

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]

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]

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]

bei FileNode doch auch oder warum nicht?

 

[Sindbad1983]

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]

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]

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]

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]

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]

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]

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]

geil!!!
es geht!


aber das Verzeichnis gibt er halt nicht aus


datdat2
Drücken Sie eine beliebige Taste . . .

 

[SebiB90]

aber das Verzeichnis gibt er halt nicht aus

wie meinst du das?
meinst du den pfad?

 

[Sindbad1983]

ja

 

[SebiB90]

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

 

[Sindbad1983]

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]

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]

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

 

[SebiB90]

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()]);
^

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

 

[Sindbad1983]

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...