# Größe von Ordner wiedergeben



## Laren (7. Apr 2011)

Hi,

Ich habe einen FileTree geschrieben, der sich rekursiv aktuallisiert. Jede Wurzel im Tree soll neben der Datei auch noch die Dateigröße anzeigen, das klappt mit "File.length();" recht gut, aber wie bekomme ich die Größe der Ordner in der die Dateien sind.
Also, im Filetree soll neben der Dateigröße auch die Ordnergröße stehen,aber wie

Grüße


```
public static void treeAktualMethode(File uebergabe, DefaultMutableTreeNode wurzel) {


        File[] dateien = uebergabe.listFiles();

        if (dateien != null) {
            for (int i = 0; i < dateien.length; i++) {
                n = new DefaultMutableTreeNode(dateien[i]);
                wurzel.add(n);

                treeAktualMethode(dateien[i], n);
            }
        }
    }
```


----------



## nrg (7. Apr 2011)

du addierst alle dateien in dem ordner zusammen


----------



## Laren (7. Apr 2011)

die Idee hatte ich auch schon, aber da liegt ja das problem, wie setzte ich das um?


----------



## nrg (7. Apr 2011)

wenn die datei ein verzeichnis ist, holste dir mit listFiles() alle datein und addierst das zusammen. machst du doch eh schon.. würde nur den prozess optimieren, dass du nicht alles 2x iterieren musst. man könnte eine komplette verzeichnisstruktur rekursiv von einer root auslesen und dabei alle dateigrößen addieren. ich kenn den aufbau deines programms nicht. also lässt sich schwer sagen, wie das am besten bei dir implementierbar ist


----------



## nrg (7. Apr 2011)

aus langeweile mal was geschrieben:


```
import java.io.File;

public class FileTreeParser {

	public Directory parse(File root) {
		Directory directory = new Directory(root);
		File[] files = root.listFiles();
		if (files != null) {
			for (File f : files) {
				if (f.isDirectory()) {
					directory.addSubDirectory(parse(f));
				} else {
					directory.addFile(f);
				}
			}
		}
		return directory;
	}
}
```


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


public class Directory {
	
	private long length;
	private File directory;
	private List<File> files;
	private List<Directory> subDirectorys;
	
	public Directory(File directory) {
		this.directory = directory;
		this.files = new ArrayList<File>();
		this.subDirectorys = new ArrayList<Directory>();
	}
	
	public List<File> getFiles() {
		return files;
	}
	
	public List<Directory> getSubDirectories() {
		return subDirectorys;
	}
	
	public void addFile(File file) {
		files.add(file);
		length += file.length();
	}
	
	public void addSubDirectory(Directory directory) {
		subDirectorys.add(directory);
		length += directory.length();
	}
	
	public long length() {
		return length;
	}
	
	public File getDirectory() {
		return directory;
	}
}
```


```
import java.io.File;

public class FileTreeParserTest {
	
	public static void main(String[] args) {
		FileTreeParser ftparser = new FileTreeParser();
		Directory directory = ftparser.parse(new File("D:\\Files"));	
		print(directory);
	}
	
	private static void print(Directory directory) {
		System.out.println(directory.getDirectory() + " has " + directory.length() + " bytes");
		printAll(directory);
	}
	
	private static void printAll(Directory directory) {
		for (Directory d : directory.getSubDirectories()) {
			print(d);
		}
	}
}
```

Hab es nur kurz getestet und funktionierte auf den ersten Blick ganz gut. Der FileTreeParser liest dir rekursiv alles durch. Danach kannst du durchiterieren (müsste evtl. auch rekursiv gemacht werden oder du schreibst dir nen iterator oder oder) und die length ausgeben. ob das jetzt in dein prozess passt, weiß ich natürlich nicht 

edit: test bissle erweitert


----------

