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�.