Java Jtree et interfaces

**mikadev** · 25/12/2013, 23h18

Bonjour je cheche a afficher une vue de mon systéme de fichier dans un JTree,
j'ai trouvée ce code qui fonctionne : http://www.pushing-pixels.org/wp-con...etreepanel.txt

seulement je ne comprend pas du tout comment il fonctionne si quelqu’un peut m'aider ce serait vraiment cool merci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
import java.awt.BorderLayout;
import java.awt.Component;
import java.io.File;
import java.util.*;
 
import javax.swing.*;
import javax.swing.border.EmptyBorder;
import javax.swing.filechooser.FileSystemView;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.TreeNode;
 
/**
 * @author Kirill Grouchnikov
 */
public class FileTreePanel extends JPanel {
	/**
         * File system view.
         */
	protected static FileSystemView fsv = FileSystemView.getFileSystemView();
 
	/**
         * Renderer for the file tree.
         * 
         * @author Kirill Grouchnikov
         */
	private static class FileTreeCellRenderer extends DefaultTreeCellRenderer {
		/**
                 * Icon cache to speed the rendering.
                 */
		private Map<String, Icon> iconCache = new HashMap<String, Icon>();
 
		/**
                 * Root name cache to speed the rendering.
                 */
		private Map<File, String> rootNameCache = new HashMap<File, String>();
 
		/*
		 * (non-Javadoc)
		 * 
		 * @see javax.swing.tree.DefaultTreeCellRenderer#getTreeCellRendererComponent(javax.swing.JTree,
		 *      java.lang.Object, boolean, boolean, boolean, int, boolean)
		 */
		@Override
		public Component getTreeCellRendererComponent(JTree tree, Object value,
				boolean sel, boolean expanded, boolean leaf, int row,
				boolean hasFocus) {
			FileTreeNode ftn = (FileTreeNode) value;
			File file = ftn.file;
			String filename = "";
			if (file != null) {
				if (ftn.isFileSystemRoot) {
					// long start = System.currentTimeMillis();
					filename = this.rootNameCache.get(file);
					if (filename == null) {
						filename = fsv.getSystemDisplayName(file);
						this.rootNameCache.put(file, filename);
					}
					// long end = System.currentTimeMillis();
					// System.out.println(filename + ":" + (end - start));
				} else {
					filename = file.getName();
				}
			}
			JLabel result = (JLabel) super.getTreeCellRendererComponent(tree,
					filename, sel, expanded, leaf, row, hasFocus);
			if (file != null) {
				Icon icon = this.iconCache.get(filename);
				if (icon == null) {
					// System.out.println("Getting icon of " + filename);
					icon = fsv.getSystemIcon(file);
					this.iconCache.put(filename, icon);
				}
				result.setIcon(icon);
			}
			return result;
		}
	}
 
	/**
         * A node in the file tree.
         * 
         * @author Kirill Grouchnikov
         */
	private static class FileTreeNode implements TreeNode {
		/**
                 * Node file.
                 */
		private File file;
 
		/**
                 * Children of the node file.
                 */
		private File[] children;
 
		/**
                 * Parent node.
                 */
		private TreeNode parent;
 
		/**
                 * Indication whether this node corresponds to a file system root.
                 */
		private boolean isFileSystemRoot;
 
		/**
                 * Creates a new file tree node.
                 * 
                 * @param file
                 *            Node file
                 * @param isFileSystemRoot
                 *            Indicates whether the file is a file system root.
                 * @param parent
                 *            Parent node.
                 */
		public FileTreeNode(File file, boolean isFileSystemRoot, TreeNode parent) {
			this.file = file;
			this.isFileSystemRoot = isFileSystemRoot;
			this.parent = parent;
			this.children = this.file.listFiles();
			if (this.children == null)
				this.children = new File[0];
		}
 
		/**
                 * Creates a new file tree node.
                 * 
                 * @param children
                 *            Children files.
                 */
		public FileTreeNode(File[] children) {
			this.file = null;
			this.parent = null;
			this.children = children;
		}
 
		/*
		 * (non-Javadoc)
		 * 
		 * @see javax.swing.tree.TreeNode#children()
		 */
		public Enumeration<?> children() {
			final int elementCount = this.children.length;
			return new Enumeration<File>() {
				int count = 0;
 
				/*
				 * (non-Javadoc)
				 * 
				 * @see java.util.Enumeration#hasMoreElements()
				 */
				public boolean hasMoreElements() {
					return this.count < elementCount;
				}
 
				/*
				 * (non-Javadoc)
				 * 
				 * @see java.util.Enumeration#nextElement()
				 */
				public File nextElement() {
					if (this.count < elementCount) {
						return FileTreeNode.this.children[this.count++];
					}
					throw new NoSuchElementException("Vector Enumeration");
				}
			};
 
		}
 
		/*
		 * (non-Javadoc)
		 * 
		 * @see javax.swing.tree.TreeNode#getAllowsChildren()
		 */
		public boolean getAllowsChildren() {
			return true;
		}
 
		/*
		 * (non-Javadoc)
		 * 
		 * @see javax.swing.tree.TreeNode#getChildAt(int)
		 */
		public TreeNode getChildAt(int childIndex) {
			return new FileTreeNode(this.children[childIndex],
					this.parent == null, this);
		}
 
		/*
		 * (non-Javadoc)
		 * 
		 * @see javax.swing.tree.TreeNode#getChildCount()
		 */
		public int getChildCount() {
			return this.children.length;
		}
 
		/*
		 * (non-Javadoc)
		 * 
		 * @see javax.swing.tree.TreeNode#getIndex(javax.swing.tree.TreeNode)
		 */
		public int getIndex(TreeNode node) {
			FileTreeNode ftn = (FileTreeNode) node;
			for (int i = 0; i < this.children.length; i++) {
				if (ftn.file.equals(this.children[i]))
					return i;
			}
			return -1;
		}
 
		/*
		 * (non-Javadoc)
		 * 
		 * @see javax.swing.tree.TreeNode#getParent()
		 */
		public TreeNode getParent() {
			return this.parent;
		}
 
		/*
		 * (non-Javadoc)
		 * 
		 * @see javax.swing.tree.TreeNode#isLeaf()
		 */
		public boolean isLeaf() {
			return (this.getChildCount() == 0);
		}
	}
 
	/**
         * The file tree.
         */
	private JTree tree;
 
	/**
         * Creates the file tree panel.
         */
	public FileTreePanel() {
		this.setLayout(new BorderLayout());
 
		File[] roots = File.listRoots();
		FileTreeNode rootTreeNode = new FileTreeNode(roots);
		this.tree = new JTree(rootTreeNode);
		this.tree.setCellRenderer(new FileTreeCellRenderer());
		this.tree.setRootVisible(false);
		final JScrollPane jsp = new JScrollPane(this.tree);
		jsp.setBorder(new EmptyBorder(0, 0, 0, 0));
		this.add(jsp, BorderLayout.CENTER);
	}
 
	public static void main(String[] args) {
		SwingUtilities.invokeLater(new Runnable() {
			public void run() {
				JFrame frame = new JFrame("File tree");
				frame.setSize(500, 400);
				frame.setLocationRelativeTo(null);
				frame.add(new FileTreePanel());
				frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
				frame.setVisible(true);
			}
		});
	}
}

**joel.drigo** · 26/12/2013, 17h17

Salut,

Tu devrais dire plus précisément ce que tu ne comprends pas. Si tu ne comprends vraiment rien du tout, il te faut reprendre chaque classe de l'exemple, puis lire le code, et la doc de java ou des tutoriels !

Pour t'aiguiller dans ta démarche : analyse la partie création de l'arbre d'un coté et affichage de l'arbre d'un autre.

FileTreeNode est la classe qui représente chaque noeud de l'arbre de dossiers/fichiers : regardes ses constructeurs pour voir comment les fichiers ou sous-dossiers d'un dossier sont récupérés. Il s'agit d'une classe qui étend TreeNode, qui permet de définir des modèles d'arbres à afficher : n'importe quel tutoriel (comme celui là) t'en dira plus à ce sujet.
FileTreeCellRenderer est la classe qui définit comme afficher un FileTreeNode : la méthode getTreeCellRendererComponent est assez facile à lire, pour qui connait un peu les bases de java. La chose un peu particulière dans cette classe est le "cache" pour "accélerer" certains affichages, qui est constitués de 2 maps, que tu peux ignorer dans un premier temps.

**mikadev** · 26/12/2013, 21h01

Salut joel.drigo est merci pour ta réponse la chose que j'ai du mal a comprendre dans ce code lorsque tu regarde lors de l’instanciation de la classe interne FileTreeNode qui prend en paramètre seulement FileListRoots() (dans la méthode FileTreePanel()) le fait que toutes arborescence s'affiche lorsque qu'on clique sur les dossier de plus il y a 2 constructeur un seul est utiliser il ne fait que initialiser les attributs de cette classe ensuite j'ai l’impression que les autres méthodes ne font rien en clair c'est vraiment l'interface TreeNode qui me pose problème (j'ai rien trouvé de vraiment bien détaillé sur le web

)

**joel.drigo** · 26/12/2013, 22h46

En fait, le constructeur de FileTreeNode détermine les "fils" du File passé en argument (le premier constructeur en effet), et les stocke dans la variable children, un tableau de File. La méthode getChildCount() de l'interface TreeNode, implémentée dans FileTreeNode retourne directement la taille de ce tableau. Et la méthode TreeNode getChildAt(int childIndex) de TreeNode créée un FileTreeNode pour le fichier contenu dans children[childIndex], lorsque la méthode est appelée. Le JTree étant codé pour parcourir un arbre de TreeNode (le modèle d'un JTree), en utilisant ces 2 méthodes, récursivement, l'arbre est bien créé.

**mikadev** · 26/12/2013, 23h42

waw

merci je ne voudrais pas abuser mais je connais pas d'autre personne capable de m'explique du coup pourrait-tu m’éclairer sur 3 dernières choses la méthode énumération elle fait quoi précisément dans le 2em constructeur si l'enfant est null alors on crée un File[0] ça revient a faire quoi exactement et a quoi sert le boolean isFileSystemRoot dans cette même methode merci encore a toi

**joel.drigo** · 27/12/2013, 00h06

La méthode Enumeration<?> children() est une méthode de l'interface TreeNode, qui retourne une implémentation concrète de l'interface Enumeration, sous forme de classe anonyme (le new Enumeration< <File> {...}). L'interface Enumeration ressemble un peu à l'interface Iterator (c'est en fait une vieille interface datant du début de java, et il est conseillé maintenant d'implémenter Iterator plutôt que Enumeration, mais il reste des références à cette interface, comme pour TreeNode). Elle impose 2 méthodes :

boolean hasMoreElements(), qui retourne true, tant qu'il y a des éléments disponibles
E nextElement(), qui retourne le prochain élément disponible (ou soulève l'exception NoSuchElementException s'il n'y a plus d'éléments

Comme Iterator, il s'agit d'une classe qui permet de "parcourir" une fois une liste d'éléments (arrivé au bout, on doit recréer l'Enumeration pour refaire le parcourt). On appelle plusieurs fois la méthode nextElement(), tant que hasMoreElements() retourne true, pour parcourir les éléments.

Si tu regardes la documentation de TreeNode, on voit les différentes méthodes qu'on doit implémenter sur cette interface, et cette méthode children() en fait partie.

Pour ce qui est du new File[0] : on créé ainsi un tableau qui contient "0 File", soit un tableau vide, ce qui permet à toutes les méthodes manipulant le tableau children de fonctionner (sans soulever, par exemple, d'exception NullPointerException). On créé un tableau vide, puisqu'il n'y a aucun sous-dossier ou fichier dans le fichier passé en argument du constructeur, ce qui est cohérent. Le nombre de TreeNode fils est bien 0 (children.length)...

isFileSystemRoot est un boolean qui permet de distinguer un fichier, ou un dossier, classique, d'un élément racine, qui représente plutôt un "disque" (Disque dur, CD-ROM, Blu-RAY, Disque externe USB, etc...) : ce booléen permet de distinguer les 2 types, afin de les afficher différemment. Ce qu'on peut voir au début de la méthode getTreeCellRendererComponent du renderer de JTree :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public Component getTreeCellRendererComponent(JTree tree, Object value,
				boolean sel, boolean expanded, boolean leaf, int row,
				boolean hasFocus) {
			FileTreeNode ftn = (FileTreeNode) value;
			File file = ftn.file;
			String filename = "";
			if (file != null) {
				if (ftn.isFileSystemRoot) {
					// long start = System.currentTimeMillis();
					filename = this.rootNameCache.get(file);
					if (filename == null) {
						filename = fsv.getSystemDisplayName(file);
						this.rootNameCache.put(file, filename);
					}
					// long end = System.currentTimeMillis();
					// System.out.println(filename + ":" + (end - start));
				} else {
					filename = file.getName();
				}
			}

Java Jtree et interfaces

Java

Vue hybride

Discussions similaires

Partager

Partager