Когда мы получим несколько изменений в ListChangeListener.Change <E>?

Question

С JavaFX API ListChangeListener.Change

public abstract boolean next ()

Переход к следующему изменению.Экземпляр Change в своем начальном состоянии недопустим и требует вызова next () перед вызовом других методов.Первый вызов next () заставит этот объект представлять первое изменение.

Итак, если у нас есть первое изменение, мы можем иметь второе и т. Д. Теперь рассмотрим следующий код:

public class NewMain {

    public static void main(String[] args) throws InterruptedException {
        ObservableList<String> list = FXCollections.observableArrayList("Z", "Y", "X");
        list.addListener((ListChangeListener)(event) -> {
            while(event.next()) {
                System.out.println("Added:" +  event.wasAdded());
                System.out.println("Permutated:" +  event.wasPermutated());
                System.out.println("Removed:" +  event.wasRemoved());
                System.out.println("Replaced:" +  event.wasReplaced());
                System.out.println("Updated:" +  event.wasUpdated());
            }
        });
        System.out.println("REPLACING");
        list.set(0, "W");
        System.out.println("\nCLEARING");
        list.clear();
    }
}

Это вывод:

REPLACING
Added:true
Permutated:false
Removed:true
Replaced:true
Updated:false

CLEARING
Added:false
Permutated:false
Removed:true
Replaced:false
Updated:false

Если одно изменение для замены ясно - replaced + removed + added, то как объяснить, что когда мы действительно очищаем, мы в любом случае получаем одно изменение.Объясните, пожалуйста, когда мы получим несколько изменений в ListChangeListener.Change?

Answer 1

За изменение диапазона значений может отвечать одно изменение (которое можно определить, проверив свойства from и to Change).Обычно ObservableList s пытаются инициировать наименьшее количество возможных частичных изменений, и для ясности это изменение удаления с одной частью со значением from, равным 0, и значением to, равным размеру списка, перед вызовом.clear().

Точные инициированные изменения соответствуют реализации ObservableList, но реализация, доступная через ObservableListBase, хорошо справляется с группировкой изменений.Этот класс является суперклассом многих используемых реализаций ObservableList.

Мало что вызывает многокомпонентные изменения в одном событии в стандартных реализациях ObservableList, но retainAll может это сделать ( спасибо @kleopatra за упоминание этого):

ObservableList<Integer> ol = FXCollections.observableArrayList();
for (int i = 0; i < 10; i++) {
    ol.add(i);
}

ol.addListener((ListChangeListener.Change<? extends Integer> event) -> {
    System.out.println("new change----------------------------------------------");
    while(event.next()) {
        System.out.println("Added:" +  event.wasAdded());
        System.out.println("Permutated:" +  event.wasPermutated());
        System.out.println("Removed:" +  event.wasRemoved());
        System.out.println("Replaced:" +  event.wasReplaced());
        System.out.println("Updated:" +  event.wasUpdated());
    }
});
ol.retainAll(1, 3, 5, 7, 9);

вывод:

new change----------------------------------------------
Added:false
Permutated:false
Removed:true
Replaced:false
Updated:false
Added:false
Permutated:false
Removed:true
Replaced:false
Updated:false
Added:false
Permutated:false
Removed:true
Replaced:false
Updated:false
Added:false
Permutated:false
Removed:true
Replaced:false
Updated:false
Added:false
Permutated:false
Removed:true
Replaced:false
Updated:false

Любая реализация ObservableList может определять новые операции, которые сгруппированысделать несколько изменений, которые приводят к одному уведомлению слушателей, хотя.Самым простым способом реализации этого является использование ObservableListBase beginChange и endChange методов:

class Ol extends ModifiableObservableListBase<Integer> {

    private final List<Integer> list = new ArrayList<>(Arrays.asList(2, 4, 6, 8));

    @Override
    public Integer get(int index) {
        return list.get(index);
    }

    @Override
    public int size() {
        return list.size();
    }

    @Override
    protected void doAdd(int index, Integer element) {
        list.add(index, element);
    }

    @Override
    protected Integer doSet(int index, Integer element) {
        return list.set(index, element);
    }

    @Override
    protected Integer doRemove(int index) {
        return list.remove(index);
    }

    public void modify() {
        if (size() < 4) {
            throw new IllegalStateException();
        }
        beginChange();
        set(0, 3);
        set(3, 7);
        endChange();
    }

}

modify() запускает 2 замены замены, если они успешны.