FAQ JavaFXConsultez toutes les FAQ

final ObservableList<Person> people = FXCollections.observableArrayList();

final ObservableList<Person> people = FXCollections.observableArrayList(person1, person2, person3);

1
2
3
4
final Map<<PhoneNumber, Person> phoneBook = new HashMap<>(); 
// Remplissage de l'annuaire. 
[...] 
final ObservableMap<PhoneNumber, Person> phoneBookObservable = FXCollections.observableMap(phoneBook);

final ObservableList<Car> carList = FXCollections.observableList(new LinkedList());

final ObservableList<String> names = FXCollections.observableArrayList("André", "Élodie", "Jasmina", "Malik", "Valérie", "Yvana");

1
2
3
4
5
6
7
names.addListener(new ListChangeListener<String>() { 
  
    @Override 
    public void onChanged(ListChangeListener.Change<? extends String> change) { 
        // Traitement des changements ici. 
    }            
});

1
2
3
names.addListener((ListChangeListener.Change<? extends String> change) -> {            
    // Traitement des changements ici. 
});

1
2
3
while(change.next()) { 
   // Traiter chaque changement séparément ici. 
}

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
names.addListener((ListChangeListener.Change<? extends String> change) -> { 
    System.out.println("+Notification"); 
    while (change.next()) { 
        if (change.wasReplaced()) { 
            System.out.printf("++Remplacement %d %d", change.getFrom(), change.getTo()).println(); 
        } 
        if (change.wasPermutated()) { 
            System.out.printf("++Permutation %d %d", change.getFrom(), change.getTo()).println(); 
            for (int index = change.getFrom() ; index < change.getTo() ; index++) { 
                System.out.printf("%d -> %d", index, change.getPermutation(index)).println(); 
            } 
        } 
        if (change.wasUpdated()) { 
            System.out.printf("++Mise à jour %d %d", change.getFrom(), change.getTo()).println(); 
        } 
        if (change.wasAdded()) { 
            System.out.println("++Ajout"); 
            change.getAddedSubList().forEach(value -> System.out.printf("\"%s\" a été ajouté.", value).println()); 
        } 
        if (change.wasRemoved()) { 
            System.out.println("++Retrait"); 
            change.getRemoved().forEach(value -> System.out.printf("\"%s\" a été supprimé.", value).println()); 
        } 
    } 
    System.out.println(); 
});

names.addAll("Henri", "Oscar", "Manon");

1
2
3
4
5
+Notification 
++Ajout 
"Henri" a été ajouté. 
"Oscar" a été ajouté. 
"Manon" a été ajouté

names.removeAll("André", "Élodie");

1
2
3
4
+Notification 
++Retrait 
"André" a été supprimé. 
"Élodie" a été supprimé.

names.set(0, "Barbara");

1
2
3
4
5
6
+Notification 
++Remplacement 0 1 
++Ajout 
"Barbara" a été ajouté. 
++Retrait 
"Jasmina" a été supprimé.

FXCollections.sort(names);

1
2
3
4
5
6
7
8
9
+Notification 
++Permutation 0 7 
0 -> 0 
1 -> 2 
2 -> 5 
3 -> 6 
4 -> 1 
5 -> 4 
6 -> 3

1
2
final ObservableList<String> names = FXCollections.observableArrayList("Yvana", "Élodie", "André", "Jasmina", "Malik", "Valérie"); 
final SortedList<String> sortedNames = new SortedList(names);

1
2
3
4
5
6
7
sortedNames.setComparator(new Comparator<String>(){ 
  
    @Override 
    public int compare(String o1, String o2) { 
        return o1.compareTo(o2); 
    }             
});

sortedNames.setComparator(String::compareTo);

[André, Jasmina, Malik, Valérie, Yvana, Élodie]

1
2
final ObservableList<String> names = FXCollections.observableArrayList("Yvana", "Élodie", "André", "Jasmina", "Malik", "Valérie"); 
final FilteredList<String> filteredNames = new FilteredList(names);

1
2
3
4
5
6
7
filteredNames.setPredicate(new Predicate<String>() { 
  
    @Override 
    public boolean test(String value) { 
        return value.length() > 5; 
    } 
});

filteredNames.setPredicate(value -> value.length() > 5);

[Élodie, Jasmina, Valérie]

1
2
3
4
5
6
7
final Map<Integer, String> source = new HashMap(); 
source.put(0, "Anthony"); 
source.put(1, "Antoinette"); 
source.put(2, "Jérôme"); 
source.put(3, "Karine"); 
source.put(4, "Patrick"); 
final ObservableMap<Integer, String> users = FXCollections.observableMap(source);

1
2
3
4
5
6
7
users.addListener(new MapChangeListener<Integer, String>() { 
  
    @Override 
    public void onChanged(MapChangeListener.Change<? extends Integer, ? extends String> change) { 
        // Traitement des changements ici. 
    } 
});

1
2
3
users.addListener((MapChangeListener.Change<? extends Integer, ? extends String> change) -> { 
    // Traitement des changements ici. 
});

1
2
3
4
5
6
7
8
9
10
users.addListener((MapChangeListener.Change<? extends Integer, ? extends String> change) -> { 
    System.out.println("+Notification"); 
    if (change.wasAdded()) {      
        System.out.printf("\"%s\" a été ajouté.", change.getValueAdded()).println(); 
    } 
    if (change.wasRemoved()) {                 
        System.out.printf("\"%s\" a été supprimé.", change.getValueRemoved()).println(); 
    } 
    System.out.println(); 
});

1
2
users.put(5, "Renée"); 
users.put(6, "Hervé");

1
2
3
4
5
+Notification 
"Renée" a été ajouté. 
 
+Notification 
"Hervé" a été ajouté.

1
2
users.remove(0); 
users.remove(1);

1
2
3
4
5
+Notification 
"Anthony" a été supprimé. 
 
+Notification 
"Antoinette" a été supprimé.

users.put(3, "Annie");

1
2
3
+Notification 
"Annie" a été ajouté. 
"Karine" a été supprimé.