# JTree mit Ordneransicht in JPanel einbinden



## blade_mz (29. Jan 2012)

Moin,

ich schreibe an einem Programm bei dem eine Ordneransicht zum einen als JTable und zum anderen als JTree angezeigt werden soll. Zum Teil funktioniert das auch mit meinem Quellcode. Aber nur manchmal.

Es ist möglich den Inhalt kleinerer Ordner (6 Dateien) darzustellen. Wenn die Ordner aber mehrere 100 Dateien beinhalten bekomme ich keine Anzeige.

Manchmal wird aber auch der kleine Ordner - der sonst angezeigt wird - nicht angezeigt. Manchmal wird zusätzlich nicht das "toplabel" angezeigt.

Irgendwie überlistet mich mein Code und ich komme das ganze Wochenende schon nicht dahinter, warum und wieso.

Ich hoffe, von euch kann mir jemand helfen.


```
public class init {

	public static void main(String[] args) {

		new Gui();

	}

}
```


```
import java.awt.*;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTree;
import javax.swing.SwingConstants;
import javax.swing.tree.DefaultMutableTreeNode;
import java.awt.event.*;
import java.io.File;



public class Gui extends JFrame implements ActionListener{
	
//Variablen deklarieren
	JLabel topLabel;
	JMenuBar jmb;
	JMenu datei;
	JMenuItem beenden;
	JMenuItem einstellungen;
	JMenu hilfe;
	JMenuItem about;
	JPanel centerPanel;
	JTable tableThisPC;
	JTree tree;
	String [][] data;
	String verzeichnis;
	
	public Gui(){
		super("Test Test Test");
				
		tree = new JTree(addNodes());
		
		this.setSize(800,500);
		this.setLocation(100,100);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);
        getContentPane().setLayout(new BorderLayout(5,5));
        
        
        //Menüleiste erzeugen
		jmb = new JMenuBar();
		datei = new JMenu("Datei");
		hilfe = new JMenu("Hilfe");
        beenden = new JMenuItem("Beenden");
        beenden.addActionListener(this);
        einstellungen = new JMenuItem("Einstellungen");
        einstellungen.addActionListener(this);
        about = new JMenuItem("Über");
        about.addActionListener(this);
        jmb.add(datei);
        jmb.add(hilfe);
        datei.add(einstellungen);
        datei.add(beenden);
        hilfe.add(about);
        this.setJMenuBar(jmb);
        
        // NORTH Dialog erzeugen
        topLabel = new JLabel("Test Test Test");
		topLabel.setFont(new Font("Monospaced",Font.BOLD,38));
		topLabel.setHorizontalAlignment(SwingConstants.CENTER);
		this.add(topLabel, BorderLayout.NORTH);		
		
		// CENTER Dialog erzeugen
		centerPanel = new JPanel();
		centerPanel.setLayout(new BorderLayout(5,5));	
		verzeichnis = "C:\\Temp2";
		OrdnerSearch x = new OrdnerSearch(verzeichnis);
		data = x.getOrdnerListe();
		String [] headline = {"Nummer","Datei"};
		tableThisPC = new JTable(data, headline);
		centerPanel.add(new JScrollPane(tableThisPC), BorderLayout.WEST);	
				
		FolderView fv = new FolderView(new File(verzeichnis));
		JPanel testtree = fv.getPanel();
		centerPanel.add(testtree, BorderLayout.EAST);

		this.add(centerPanel, BorderLayout.CENTER);
	}	

	public DefaultMutableTreeNode addNodes(){
		
		String[] datata = {"1","2"};
		
		DefaultMutableTreeNode n = new DefaultMutableTreeNode(datata[0]);
		n.add(new DefaultMutableTreeNode(datata[1]));
		
		return n;
	}
	
	public void actionPerformed(ActionEvent e){
		if(e.getSource() == einstellungen)
		{
			
		}
		if(e.getSource() == beenden)
		{
			System.out.println("Programm wird beendet");
			System.exit(0);
		}
		if(e.getSource() == about)
		{
			
		}
		
	}
}
```


```
import java.awt.*;
import javax.swing.*;
import javax.swing.tree.*;
import javax.swing.event.*;
import java.io.*;
import java.util.*;

public class FolderView  
{ 
	
	private JPanel hilfspanel = new JPanel();
	JScrollPane scrollpane;
	JTree tree;

    public FolderView(File dir) {
        hilfspanel.setLayout(new BorderLayout(5,5));

        // Make a tree list with all the nodes, and make it a JTree
        tree = new JTree(addNodes(null, dir));
        

        // Add a listener
        tree.addTreeSelectionListener(new TreeSelectionListener() {
            public void valueChanged(TreeSelectionEvent e) {
                DefaultMutableTreeNode node =
                    (DefaultMutableTreeNode)e.getPath().getLastPathComponent();
                System.out.println("You selected " + node);
            }
        });

        // Lastly, put the JTree into a JScrollPane.
        scrollpane = new JScrollPane();
        scrollpane.getViewport().add(tree);
        hilfspanel.add(scrollpane, BorderLayout.CENTER);
    }

    /** Add nodes from under "dir" into curTop. Highly recursive. */
    public DefaultMutableTreeNode addNodes(DefaultMutableTreeNode curTop, File dir) {
        String curPath = dir.getPath();
        DefaultMutableTreeNode curDir = new DefaultMutableTreeNode(curPath);
        if (curTop != null) {   // should only be null at root
            curTop.add(curDir);
        }
        Vector ol = new Vector();
        String[] tmp = dir.list();
        for (int i=0; i<tmp.length; i++)
            ol.addElement(tmp[i]);
        Collections.sort(ol, String.CASE_INSENSITIVE_ORDER);
        File f;
        Vector files = new Vector();
        // Make two passes, one for Dirs and one for Files. This is #1.
        for (int i=0; i<ol.size(); i++) {
            String thisObject = (String)ol.elementAt(i);
            String newPath;
            if (curPath.equals("."))
                newPath = thisObject;
            else
                newPath = curPath + File.separator + thisObject;
            if ((f = new File(newPath)).isDirectory())
                addNodes(curDir,  f);
            else
                files.addElement(thisObject);
        }
        // Pass two: for files.
        for (int fnum=0; fnum<files.size(); fnum++)
            curDir.add(new DefaultMutableTreeNode(files.elementAt(fnum)));
        return curDir;
    }
    
    public JPanel getPanel(){
    	return hilfspanel;
    }
}
```


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

public class OrdnerSearch {
	String Ordner;
	File f;
	File[] fileArray;
	ArrayList<String []> liste= new ArrayList<String[]>();
	
	public OrdnerSearch(String o){
		this.Ordner = o;
		f = new File(o);
		listDir(f);
	}
	
	public void listDir(File dir) {
		File[] files = dir.listFiles();
		if (files != null) {
			for (int i = 0; i < files.length; i++) {
				String[] eintrag = {Integer.toString(i), files[i].toString()};
				liste.add(i,eintrag);
			}
		}
	}
	
	public String[][] getOrdnerListe(){
		String[][] o = new String[liste.size()][2];
		for(int i = 0; i<liste.size();i++){
			String[] listenwert = liste.get(i);
			o[i][0] = listenwert[0];
			o[i][1] = listenwert[1];
		}
		return o;
	}
}
```

Achja, ein paar Informationen habe ich vergessen:

- die Klasse FolderView habe ich hierher. Klick Der Rest ist auf meinem Mist gewachsen.

- die Variable tree und die Methode addNodes sind in meinen Augen nutzlos. Wenn ich sie aber lösche, bekomme ich keine Anzeige mehr.

- Ich nutze Eclipse als IDE

- Ich bin ein Java-Anfänger mit sehr wenig Erfahrung also bitte zerreisst mich nicht in der Luft


----------



## KrokoDiehl (30. Jan 2012)

Hallo.
Ich sehe erstmal keine offensichtlichen Fehler, daher die Frage ob irgendwelche Ausnahmen auftreten (mal Eclipse-Konsole anschauen)? Falls nicht dann hilft wohl erstmal nur Debugging und/oder Testausgaben um der Ursache auf die Spur zu kommen.
Vielleicht auch ein Neu-Implementieren einzelner Teile - z.B. des JTrees - zum Üben/Testen.

Was mir aufgefallen ist, ist dass 
	
	
	
	





```
addNodes()
```
-Methode "gefährlich" ist. Sie arbeitet rekursiv und wenn man hier große Verzeichnisse trifft, kann es sicher schnell zum Speicherfresser werden wenn in dem JTree viele Knoten eingefügt werden.
Andererseits ist eine lazy-Lösung (Baum erst dann erweitern, wenn man ein Verzeichnis-Knoten öffnet) auch komplexer.
Daraus folgend kann ich dir sagen, dass die Methode 
	
	
	
	





```
FolderView.addNodes(
```
) sehr wichtig ist, weil sie nämlich erst die Daten (Knoten) in deinen JTree anfügt. Ohne diese ist er natürlich leer.

[EDIT]
Ah - ich denke ich habe doch das offentliche Problem erkannt: Bereits im Konstruktor von Gui:
Du rufst 
	
	
	
	





```
setVisible(true)
```
 früh auf, bevor überhaupt das Layout feststeht. Damit bekommt deine GUI noch nicht alle Änderungen mit. Verschiebe also die Aufrufe wie 
	
	
	
	





```
pack()
```
 und 
	
	
	
	





```
setVisible(true)
```
 ans Ende des Konstruktors, bzw. nachdem das Layouting getan wurde und alle Daten geladen sind.

Ansonsten sieht der Code schon nach "hauptsache es klappt" aus. Ein paar Swing-Tutorials wären ein guter nächster Schritt. 
[/EDIT]


----------



## blade_mz (30. Jan 2012)

Das wars!! DANKE!! Zwei Tage Arbeit wegen sowas 

Kannst du mir da ein paar Tutorials empfehlen? Ich hab schon jede Menge gegoogelt und auch einige gefunden, aber ich bin mittlerweile über den Status "Totaler Anfäger" hinweg (dafür gibt es viele Tutorials) aber noch lange nicht ein Profi (auch hierfür habe ich ab und zu etwas gefunden).

Was ich suche ist ein Tutorial, in dem erklärt wird wie man "anständig" programmiert. Und zwar nicht nur einen JFrame mit einem JLabel und einem JButton, bei dem sich die Farbe des Buttons ändert, wenn man drauf drückt... sondern schon etwas komplexer...


----------



## KrokoDiehl (30. Jan 2012)

Hier im Forum gibt es schon viel Wissen und Beispiele zu dem Thema, ansonsten kannst du dir mal die Tutorial-Sektion anschauen. Ich selbst mag auch die Oracle-Tutorials wo es welche zu Swing allgemein aber auch zu den einzelnen Swing-Komponenten gibt.


----------



## blade_mz (30. Jan 2012)

Dann werd ich mich da wohl mal durcharbeiten. Danke für die prompte Antwort!


----------

