布尔属性如何与createBooleanBinding一起使用

Question

I have this code :

public class Test {
    public static void main(String [] args) {

        ObservableList<Integer> l = FXCollections.observableArrayList();
        l.add(1);
        l.add(2);
        l.add(3);
        BooleanProperty isPlayable = new SimpleBooleanProperty();
        isPlayable.bind(Bindings.createBooleanBinding(() -> 
        {
            System.out.println("List has changed");

            return l.contains(2);
        },l
        ));
l.remove(1);

I don't understand why would this code display "List has changed" only one time ? It should twice, one at the binding, and then in the remove because the list is observable. Why the list changement doesn't affect the boolean property ?

(I have a bigger problem in the long code but this situation illustrates my misunderstanding of the boolean property bindings)

Thank you !

Answer 1

From the documentation of ObservableValue (which both Binding and Property inherit from):

An implementation of ObservableValue may support lazy evaluation, which means that the value is not immediately recomputed after changes, but lazily the next time the value is requested. All bindings and properties in this library support lazy evaluation.

An ObservableValue generates two types of events: change events and invalidation events. A change event indicates that the value has changed. An invalidation event is generated if the current value is not valid anymore. This distinction becomes important if the ObservableValue supports lazy evaluation, because for a lazily evaluated value one does not know if an invalid value really has changed until it is recomputed. For this reason, generating change events requires eager evaluation while invalidation events can be generated for eager and lazy implementations.

Implementations of this class should strive to generate as few events as possible to avoid wasting too much time in event handlers. Implementations in this library mark themselves as invalid when the first invalidation event occurs. They do not generate anymore invalidation events until their value is recomputed and valid again.

Two types of listeners can be attached to an ObservableValue : InvalidationListener to listen to invalidation events and ChangeListener to listen to change events.

Important note: attaching a ChangeListener enforces eager computation even if the implementation of the ObservableValue supports lazy evaluation.

Note that both Property#bind and Bindings#createXXXBinding register an InvalidationListener on the dependency/dependencies, not a ChangeListener .

As you can see, bindings and properties in core JavaFX are lazy. You never query the value after you remove the element from the ObservableList so the value is never recomputed. Since the value is never recomputed, your Callable is not invoked for the second time.

I was actually surprised you saw "List has changed" even once. None of your code requests the value so I wouldn't have expected the value to be computed. However, looking at the implementation, it looks like the act of registering an InvalidationListener causes the ObservableValue to be validated (ie the value is queried)—and #bind adds an InvalidationListener . I'm not sure why the implementation does this, but it does.