JavaFX - Trier ou Filtrer

Bonjour à tous!!!!
Je suis un débutant en JavaFX.
Alors je souhaiterais savoir comment faire des tries ou filtrages des données d'une table.
Pour être explicite, l'idée est que je crée une table(nom, prenom, diplome, etat civil), ensuite des menu buton
- diplome: qui contient par exemple BAC-BTS-Ingenieur
- Etat civil : qui contient par exemple Marié(e) - Divorcé(e) - veuf(ve)

Donc lorsque l'utilisateur choisit un diplome, alors on doit voir afficher dans la table les personnes qui ont ce diplome. Et de même pour l'etat civil et tout en ayant la possibilité de faire les 2 à la fois.

voila mon souci et je compte sur votre aide
Merci d'avance.....

Bon alors, Jonathan Giles avait en 2011 fait une démo de deux classes : SortedList et FilteredList qui étaient toutes deux des dérivées d'ObservableList. Ici en démo dans une ListView mais c'est totalement applicable à une TableView.

http://www.jonathangiles.net/javafx/...sortAndFilter/

L'ennui c'est qu'à ma connaissance, il n'a jamais publié le code source et je ne sais pas si c'est inclus dans DataFX ou dans JavaFX 8, en tout cas ce n'est pas dispo dans JavaFX 2.2. J'ai été amené à faire une implémentation de FilteredList hier mais c'est un peu "basique", pas très optimisé (genre quand on change les filtres-prédicats, on retire tous les éléments de la liste filtrée avant d'en remettre de nouveaux et j'ai codé une gestion des permutation dont je ne sais pas si elle est correcte) et surtout pas testé à fond.

Je posterai le code une fois arrivé au boulot.

EDIT - un autre exemple : JavaFX TableView Filter

bon alors, sans garantie aucune que ce n'est pas truffe de bugs et que les performances ne sont pas exécrables lorsqu'on manipule des grandes listes.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

/**  * A predicate used to filter an observable collection.  * @author Fabrice Bouyé (fabriceb@spc.int)  */ public interface Predicate<T> {   /**      * The test in this predicate.      * @param value The value to be tested.      * @return A {@code True} if the test succeeds, {@code false} otherwise.      */ public boolean delegate(final T value); }

---

Code:

---

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 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537

import java.util.Collection; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.ListIterator; import javafx.beans.InvalidationListener; import javafx.beans.Observable; import javafx.beans.property.ListProperty; import javafx.beans.property.SimpleListProperty; import javafx.collections.FXCollections; import javafx.collections.ListChangeListener; import javafx.collections.ObservableList;   /**  * Offers a simple implementation for filtered list.  * <br/>Filtered lists are non-modifiable.  * @todo See if this is needed again when switching to JDK8.  * @author Fabrice Bouyé (fabriceb@spc.int)  */ public final class FilteredObservableList<T> implements ObservableList<T> {   /**      * Inner delegated list.      */ private ObservableList<T> delegated;   /**      * Creates a new empty instance.      */ public FilteredObservableList() { this(null); }   /**      * Creates a new instance from a regular list.      * <br/>Direct changes in the underlying list will not be reported to this list.      * @param source The source list.      * @param predicates The predicates used to filter this list.      */ public FilteredObservableList(final List<T> source, final Predicate<T>... predicates) { this(FXCollections.observableList(source), predicates); }   /**      * Creates a new instance from an observable list.      * @param source The source list.      * @param predicates The predicates used to filter this list.      */ public FilteredObservableList(final ObservableList<T> source, final Predicate<T>... predicates) { setSource(source); getPredicates().addAll(predicates); // sourceProperty().addListener(sourceListChangeListener); predicatesProperty().addListener(predicatesListChangeListener); // populateDelegatedList(); } /**      * Listen for changes in the source list.      */ private ListChangeListener<T> sourceListChangeListener = new ListChangeListener<T>() { @Override public void onChanged(ListChangeListener.Change<? extends T> change) { populateDelegatedList(); } }; /**      * Listen for changes in the predicate list.      */ private ListChangeListener<Predicate<T>> predicatesListChangeListener = new ListChangeListener<Predicate<T>>() { @Override public void onChanged(ListChangeListener.Change<? extends Predicate<T>> change) { populateDelegatedList(); } };   /**      * Test the predicate on a value.s      * @param value The value to be test.      * @return The result of the test.      */ private boolean testPredicates(T value) { boolean result = false; for (Predicate<T> predicate : predicates) { result = predicate.delegate(value); if (!result) { break; } } return result; }   /**      * Populate filtered list.      */ private void populateDelegatedList() { final List<T> toBeAdded = new LinkedList<>(); for (T value : source) { if (testPredicates(value)) { toBeAdded.add(value); } } if (delegated == null) { delegated = FXCollections.observableList(new LinkedList<T>()); delegated.addListener(delegatedInvalidationListener); delegated.addListener(delegatedChangeListener); } delegated.setAll(toBeAdded); toBeAdded.clear(); } /**      * Listen for invalidation in the delegated list.      */ private InvalidationListener delegatedInvalidationListener = new InvalidationListener() { @Override public void invalidated(Observable o) { initListenerList(); for (Object object : listenerList) { if (object instanceof InvalidationListener) { InvalidationListener invalidationListener = (InvalidationListener) object; invalidationListener.invalidated(o); } } } }; /**      * Listen for changes in the delegated list.      */ private ListChangeListener<T> delegatedChangeListener = new ListChangeListener<T>() { @Override public void onChanged(final ListChangeListener.Change<? extends T> change) { if (listenerList != null) { ListChangeListener.Change<? extends T> newChange = new ListChangeListener.Change(FilteredObservableList.this) { @Override public boolean next() { return change.next(); }   @Override public void reset() { change.reset(); }   @Override public int getFrom() { return change.getFrom(); }   @Override public int getTo() { return change.getTo(); }   @Override public List getRemoved() { return change.getRemoved(); }   @Override protected int[] getPermutation() { // Not sure about this. if (!change.wasPermutated()) { return new int[0]; } else { int[] permutations = new int[delegated.size()]; for (int index = 0; index < permutations.length; index++) { permutations[index] = change.getPermutation(index); } return permutations; } } }; initListenerList(); for (Object object : listenerList) { if (object instanceof ListChangeListener) { ListChangeListener listChangeListener = (ListChangeListener) object; newChange.reset(); listChangeListener.onChanged(newChange); } } } } };   //////////////////////////////////////////////////////////////////////////// // Size support. /**      * {@inheritDoc}      */ @Override public int size() { return delegated.size(); }   /**      * {@inheritDoc}      */ @Override public boolean isEmpty() { return delegated.isEmpty(); }   //////////////////////////////////////////////////////////////////////////// // Modifiable methods, all disabled. /**      * {@inheritDoc}      * @throws UnsupportedOperationException Always.      */ @Override public boolean setAll(T... es) { throw new UnsupportedOperationException("Not supported."); }   /**      * {@inheritDoc}      * @throws UnsupportedOperationException Always.      */ @Override public boolean setAll(Collection<? extends T> clctn) { throw new UnsupportedOperationException("Not supported."); }   /**      * {@inheritDoc}      * @throws UnsupportedOperationException Always.      */ @Override public T set(int index, T element) { throw new UnsupportedOperationException("Not supported."); }   /**      * {@inheritDoc}      * @throws UnsupportedOperationException Always.      */ @Override public boolean addAll(T... es) { throw new UnsupportedOperationException("Not supported."); }   /**      * {@inheritDoc}      * @throws UnsupportedOperationException Always.      */ @Override public boolean addAll(Collection<? extends T> c) { throw new UnsupportedOperationException("Not supported."); }   /**      * {@inheritDoc}      * @throws UnsupportedOperationException Always.      */ @Override public boolean addAll(int index, Collection<? extends T> c) { throw new UnsupportedOperationException("Not supported."); }   /**      * {@inheritDoc}      * @throws UnsupportedOperationException Always.      */ @Override public boolean add(T e) { throw new UnsupportedOperationException("Not supported."); }   /**      * {@inheritDoc}      * @throws UnsupportedOperationException Always.      */ @Override public void add(int index, T element) { throw new UnsupportedOperationException("Not supported."); }   /**      * {@inheritDoc}      * @throws UnsupportedOperationException Always.      */ @Override public void clear() { throw new UnsupportedOperationException("Not supported."); }   /**      * {@inheritDoc}      * @throws UnsupportedOperationException Always.      */ @Override public boolean removeAll(T... es) { throw new UnsupportedOperationException("Not supported."); }   /**      * {@inheritDoc}      * @throws UnsupportedOperationException Always.      */ @Override public boolean removeAll(Collection<?> c) { throw new UnsupportedOperationException("Not supported."); }   /**      * {@inheritDoc}      * @throws UnsupportedOperationException Always.      */ @Override public boolean remove(Object o) { throw new UnsupportedOperationException("Not supported."); }   /**      * {@inheritDoc}      * @throws UnsupportedOperationException Always.      */ @Override public void remove(int i, int i1) { throw new UnsupportedOperationException("Not supported."); }   /**      * {@inheritDoc}      * @throws UnsupportedOperationException Always.      */ @Override public boolean retainAll(T... es) { throw new UnsupportedOperationException("Not supported."); }   /**      * {@inheritDoc}      * @throws UnsupportedOperationException Always.      */ @Override public boolean retainAll(Collection<?> c) { throw new UnsupportedOperationException("Not supported."); }   /**      * {@inheritDoc}      * @throws UnsupportedOperationException Always.      */ @Override public T remove(int index) { throw new UnsupportedOperationException("Not supported."); }   //////////////////////////////////////////////////////////////////////////// // Get support. /**      * {@inheritDoc}      * @throws UnsupportedOperationException Always.      */ @Override public T get(int index) { return delegated.get(index); }   //////////////////////////////////////////////////////////////////////////// // Contains support. /**      * {@inheritDoc}      */ @Override public boolean contains(Object o) { return delegated.contains(o); }   /**      * {@inheritDoc}      */ @Override public boolean containsAll(Collection<?> c) { return delegated.containsAll(c); }   /**      * {@inheritDoc}      */ @Override public int indexOf(Object o) { return delegated.indexOf(o); }   /**      * {@inheritDoc}      */ @Override public int lastIndexOf(Object o) { return delegated.lastIndexOf(o); }   //////////////////////////////////////////////////////////////////////////// // Misc. /**      * {@inheritDoc}      */ @Override public Object[] toArray() { return delegated.toArray(); }   /**      * {@inheritDoc}      */ @Override public <T> T[] toArray(T[] a) { return delegated.toArray(a); }   @Override public String toString() { return delegated.toString(); }   //////////////////////////////////////////////////////////////////////////// // Iterator support. /**      * {@inheritDoc}      */ @Override public ListIterator<T> listIterator() { return delegated.listIterator(); }   /**      * {@inheritDoc}      */ @Override public ListIterator<T> listIterator(int index) { return delegated.listIterator(index); }   /**      * {@inheritDoc}      */ @Override public Iterator<T> iterator() { return delegated.iterator(); }   //////////////////////////////////////////////////////////////////////////// // Sub-list support. /**      * {@inheritDoc}      */ @Override public List<T> subList(int fromIndex, int toIndex) { return delegated.subList(fromIndex, toIndex); } //////////////////////////////////////////////////////////////////////////// // Listener support. private List<Object> listenerList = null;   private synchronized void initListenerList() { if (listenerList == null) { listenerList = new LinkedList<>(); } }   /**      * {@inheritDoc}      */ @Override public void addListener(ListChangeListener ll) { if (ll != null) { initListenerList(); listenerList.add(ll); } }   /**      * {@inheritDoc}      */ @Override public void removeListener(ListChangeListener ll) { if (listenerList != null && ll != null) { listenerList.remove(ll); } }   /**      * {@inheritDoc}      */ @Override public void addListener(InvalidationListener il) { if (il != null) { initListenerList(); listenerList.add(il); } }   /**      * {@inheritDoc}      */ @Override public void removeListener(InvalidationListener il) { if (listenerList != null && il != null) { listenerList.remove(il); } } //////////////////////////////////////////////////////////////////////////// /**      * Source list of this filtered list.      */ private final ListProperty<T> source = new SimpleListProperty<>(this, "source", FXCollections.observableList(new LinkedList<T>())); // NOI18N.   public final ObservableList<T> getSource() { return source.get(); }   public final void setSource(final ObservableList<T> value) { source.set(value); }   public final ListProperty<T> sourceProperty() { return source; } /**      * List of predicates in this filtered list.      */ private final ListProperty<Predicate<T>> predicates = new SimpleListProperty<>(this, "predicates", FXCollections.observableList(new LinkedList<Predicate<T>>())); // NOI18N.   public final ObservableList<Predicate<T>> getPredicates() { return predicates.get(); }   public final void setPredicates(final ObservableList<Predicate<T>> value) { predicates.set(value); }   public final ListProperty<Predicate<T>> predicatesProperty() { return predicates; } }

---

Et a l'utilisation :

Code:

---

1 2 3 4 5 6 7 8 9 10

ObservableList<String> source = FXCollections.observableArrayList("Adrien", "Bruno", "David", "Dorian", "Fabrice", "Patrice", "Vivien"); Predicate<String> predicate = new Predicate<String>() { @Override public boolean delegate(String value) { return value.matches(".+rice"); } }; // La liste filtree ne contient plus que "Fabrice" et "Patrice". FilteredObservableList<String> filteredList= createFilter(source, predicate);

---

Pour une liste triée, c'est pareil sauf qu'on prend un Comparator<T> au lieu d'une liste de Predicate<T> et que dans populateDelegatedList(), on fera un truc du genre :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

/**      * Populate filtered list.      */ private void populateDelegatedList() { final List<T> toBeAdded = new LinkedList<>(); toBeAdded.addAll(source); final Comparator<T> comparator = getComparator(); if (comparator != null) { Collections.sort(toBeAdded, comparator); } if (delegated == null) { delegated = FXCollections.observableList(new LinkedList<T>()); delegated.addListener(delegatedInvalidationListener); delegated.addListener(delegatedChangeListener); } delegated.setAll(toBeAdded); toBeAdded.clear(); }

---

Et donc on pourrait faire :

Code:

---

1 2 3

Comparator<String> comparator = ... SortedObservableList<String> sortedList = new SortedList<>(filteredList, comparator);

---

Apres ces classes sont valides pour Java 7. Dans Java 8, il faudra les etendre pour surcharger tout un tas de nouvelles methodes, entre autres celles qui retournent des Stream (qui ne sont pas des flux I/O per se, mais des entites permettant de faire des taches en parallèle sur les collections).

A noter qu'en Java 8, tu n'as pas besoin d'écrire l'interface Predicate : elle existe déja.

L'ennui avec la classe Predicate de Java8 c'est qu'elle ne s'applique principalement qu'aux Stream et ensuite les méthodes dispos dans Collections ne servent qu'à modifier la collection. Donc le fonctionnement n'est pas trop le même que celui présenté ici : à savoir une vue d'une liste parente qui reste synchronisée avec le contenu de la liste parent.

Évidement, il faudra voir si JavaFX 8 a plus ou moins un support des Stream, ou si les collections observable ou la classe FXCollections ont des support des Predicate tout en gardant la fonctionnalité en question.

En fait je voulais dire que tu pouvais utiliser l'interface Predicate de Java 8 a la place de la tienne. Et je me suis rendu compte que je me trompais après avoir regardé le code de l'interface en question... et je suis tombé sur des déclarations de methode avec du code dedans... dans une interface ? Oo Dafuk ? Quelqu'un pour m'expliquer ?

P.S. : désolé pour le changement de sujet.

Alors... pour faire court, Java 8 introduit un nouveau concept : celui des default method dans les interfaces. C'est a dire des interfaces avec des methodes contenant du code :aie:.

Plus d'explications JDK 8 1/3 - Interface default method implementations ou encore Java 8 explained: Default Methods

On pourrait penser que grosso-modo on va revenir a faire une sorte d’héritage multiple comme jadis :aie:. Mais en fait, il est impossible d’hériter de deux interfaces qui définissent une default method avec la même signature : ça plante a la compilation.

Code:

---

java: class Clazz inherits unrelated defaults for foo() from types A and B

---

Une des raisons de l'ajout de cette approche a ete de permettre de modifier les interfaces des collections (ajout de l'API Stream ou encore methode forEach() dans les Iterable) sans pour autant que tous les gens de part la planète qui aient implémenté leur propre collection soient soudainement obligés de devoir retoucher leur code pour ajouter ce support. Il faut cependant s'attendre a ce que les vieux codes puissent poser problème si une classe dispose d'un arbre d’héritage complique avec beaucoup d'interfaces.

Un petit test avec le JDK 8 montre qu'on pourra bientot faire ca :

Code:

---

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

import java.util.Comparator; import java.util.function.Predicate; import javafx.collections.FXCollections; import javafx.collections.ObservableList; import javafx.collections.transformation.FilteredList; import javafx.collections.transformation.SortedList;   [...]   ObservableList<String> nameList = FXCollections.observableArrayList("Adrien", "Bruno", "David", "Dorian", "Patrice", "Fabrice", "Vivien"); // Filter result. Predicate<String> predicate = new Predicate<String>() { @Override public boolean test(String value) { return value.matches(".+rice"); } }; FilteredList<String> filteredList = nameList.filtered(predicate); // Sort result. Comparator<String> comparator = new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.compareTo(o2); } }; SortedList<String> sortedList = filteredList.sorted(comparator); System.out.println(sortedList);

---

Avec pour résultat :

Code:

---

[Fabrice, Patrice]

---

Merci des infos. C'est assez violent, dans l'esprit, comme changement, même si ça se comprend.
Accessoirement, je suis déçu : la javadoc 8 ne donne aucune information sur la classe FilteredList.

La javadoc de JavaFX 8 n'est pas encore incluse dans la javadoc du JDK 8 :aie:. Soit il faut la télécharger séparément (si un tel dl existe sur la page du JDK 8), soit il faut la générer (en espérant que les binaires du runtime contiennent encore les commentaires de doc), soit il faut aller fureter du coté des sources sur l'OpenJFX et lire la doc directement dans le code.

bah perso, j'ai trouvé ça : http://download.java.net/jdk8/jfxdocs/

Par contre, ça ne contient pas de doc sur le package java.collections.transformations, et donc rien sur la FilteredList (même si la methode filter est bien decrite dans la doc de ObservableList :aie:)