java – ListChangeListener wasPermutated块

ListChangeListener的 JavaDoc提供了一个用于处理更改的模板.但是,我不知道如何处理排列.对于每个索引,我都可以找到项目的新索引所在的位置,但我不知道如何处理它.这是一个独立于编程语言的难题. ObservableList只能添加(),remove(),set(),还有一个迭代器.

如果我有一个原始列表[1,2,3],并将list []绑定到它,则绑定列表[1,3]需要匹配它.
如果原始列表的比较器被交换,原始列表现在读取[3,1],我如何使绑定列表跟随？

/**
 * Binds a source list's elements to a destination list. Any changes made in
 * the source list will reflect in the destination list.
 *
 * @param <SRC> The source list's object type.
 * @param <DEST> The destination list's object type.
 * @param dest The destination list that will be bound to the src list.
 * @param src The source list to watch for changes,and propagate up to the
 * destination list.
 * @param transformer A function that will transform a source list data
 * type,A,into a destination list data type,B.
 */
public static <SRC,DEST> void bindLists(
        ObservableList<DEST> dest,ObservableList<SRC> src,Function<? super SRC,? extends DEST> transformer) {
    /*Add the initial data into the destination list.*/
    for (SRC a : src) {
        dest.add(transformer.apply(a));
    }
    /*Watch for future data to add to the destination list. Also watch for removal
     of data form the source list to remove its respective item in the destination
     list.*/
    src.addListener((ListChangeListener.Change<? extends SRC> c) -> {
        while (c.next()) {
            if (c.wasPermutated()) {
                /*How do you handle permutations? Do you remove and then add,or add and then remove,or use set,or use a copy arraylist 
                 and set the right indices? Removing/adding causes concurrent modifications.*/
                for (int oldIndex = c.getFrom(); oldIndex < c.getTo(); oldIndex++) {
                    int newIndex = c.getPermutation(oldIndex);
                    dest.remove(oldIndex);
                    dest.add(newIndex,dest.get(oldIndex));
                }
            } else if (c.wasUpdated()) {

            } else {
                /*Respond to removed data.*/
                for (SRC item : c.getRemoved()) {
                    int from = c.getFrom();
                    dest.remove(from);
                }
                /*Respond to added data.*/
                for (SRC item : c.getAddedSubList()) {
                    int indexAdded = src.indexOf(item);
                    dest.add(indexAdded,transformer.apply(item));
                }
            }
        }
    });
}

newIndex = getPermutation(oldIndex);

int from = c.getFrom();
    int to = c.getTo();
    List<DEST> copy = new ArrayList<>(dest.subList(from,to));
    for (int oldIndex = from; oldIndex < to; oldIndex++) {
        int newIndex = c.getPermutation(oldIndex);
        dest.set(newIndex,copy.get(oldIndex - from));
    }