子列表到主列表的Java绑定

有什么方法可以将几个子列表绑定到一个主列表中吗

我扩展了

TreeItem

如下：

import java.util.List;
import javafx.scene.control.TreeItem;
import javafx.collections.ObservableList;
// Further imports

public class MyTreeItem extends TreeItem<MyItem>  {
// ...

    public ObservableList<MyHistoryItem>  getOwnHistory() {
          // some code generating data
        }



    public ObservableList<MyHistoryItem>  getCombinedHistory(){
        ObservableList<MLDFXHistoryItem> fxCombHistory = FXCollections.observableArrayList();

        fxCombHistory.addAll(this.getOwnHistory());

        for (TreeItem<MyItem> child: this.getChildren())
        {
            fxCombHistory.addAll(((MyItem) child).getCombinedHistory());
        }

        return fxCombHistory;
    }
 }

import java.util.List；
导入javafx.scene.control.TreeItem；
导入javafx.collections.ObservableList；
//进一步进口
公共类MyTreeItem扩展了TreeItem{
// ...
公共观察列表getOwnHistory（）{
//一些代码生成数据
}
公共可观察列表getCombinedHistory（）{
ObservableList fxCombHistory=FXCollections.observableArrayList（）；
fxCombHistory.addAll（this.getOwnHistory（））；
for（TreeItem-child:this.getChildren（））
{
fxCombHistory.addAll（（（MyItem）child.getCombinedHistory（））；
}
回归历史；
}
}

函数

getCombinedHistory（）

应将根项中的数据与其所有子项组合起来。基本上它是有效的。无论如何，子列表中的更改不会自动转发

---

我必须自己编写适当的侦听器来更新

fxCombHistory

，还是更简单的方法来绑定此列表？

由于我找不到板上方法来完成此操作，我已经编写了我想要共享的onw类。主要接口是

removeSublist（inti）

和

addSublist（observelist list）

。不允许对数据进行直接

add（）

或

remove（）

，这会导致数据不一致

欢迎反馈实施情况。（可以增强对错误输入的处理。）

import java.util.ArrayList；
导入java.util.List；
导入javafx.collections.ModifiableObservableListBase；
导入javafx.collections.ObservableList；
导入javafx.collections.ListChangeListener；
公共类ObservableCompondedList扩展了ModifiableObservableListBase{
private List mainList=new ArrayList（）；
私有列表子列表=新的ArrayList（）；
私有列表侦听器=新的ArrayList（）；
私有类SubListListener实现ListChangeListener{
公共子ListListener（）{
}
@凌驾
public void onChanged（ListChangeListener.Change由于我找不到一种板上方法来实现这一点，我已经编写了我想要共享的onw类。主要接口是
removeSublist（int I）
和
addSublist（observeList）
。Direct
add（）
或
remove（）
不允许对数据进行修改，这将导致数据不一致

欢迎向实施部门反馈。（可以加强对错误输入的处理。）

import java.util.ArrayList；
导入java.util.List；
导入javafx.collections.ModifiableObservableListBase；
导入javafx.collections.ObservableList；
导入javafx.collections.ListChangeListener；
公共类ObservableCompondedList扩展了ModifiableObservableListBase{
private List mainList=new ArrayList（）；
私有列表子列表=新的ArrayList（）；
私有列表侦听器=新的ArrayList（）；
私有类SubListListener实现ListChangeListener{
公共子ListListener（）{
}
@凌驾
public void onchange（ListChangeListener.change）您是否尝试过绑定.Bindings.bindContentBioderial（ObservableList list1，ObservableList list2）
？您是否尝试过绑定.Bindings.bindContentBioderial（ObservableList list1，ObservableList list2）

？

import java.util.ArrayList;
import java.util.List;
import javafx.collections.ModifiableObservableListBase;
import javafx.collections.ObservableList;
import javafx.collections.ListChangeListener;


public class ObservableCombindedList<E>  extends ModifiableObservableListBase<E> {
    private List<E> mainList = new ArrayList<E>();
    private List<ObservableList<E>> subLists = new ArrayList<>();
    private List<SubListListener> listeners = new ArrayList<>();


    private class SubListListener implements ListChangeListener<E>{

        public SubListListener (){
        }

        @Override
        public  void onChanged(ListChangeListener.Change<? extends E> c) {

            ObservableList<E> subList = (ObservableList<E>) c.getList();

            int subListPos = ObservableCombindedList.this.subLists.indexOf(subList);
            int idxstart = getStartIndex(subListPos);


            while (c.next()) {
                 if (c.wasPermutated() || c.wasUpdated()) {
                     for (int i = c.getFrom(); i < c.getTo(); ++i) {
                             ObservableCombindedList.this.set(i+idxstart,(E) subList.get(i));
                         }
                     }
                 if (c.wasRemoved()) {
                     ObservableCombindedList.this.remove(c.getFrom(),c.getTo());
                  }

                 if (c.wasAdded()){
                         for (int i = c.getFrom(); i < c.getTo(); ++i) {
                             ObservableCombindedList.this.add(i+idxstart,(E) subList.get(i));
                         }
                     }

                 };
        } //  void onChanged

    }  // private class SubListListener implements ListChangeListener<E>

    public  int getStartIndex(int listNr)
    {
        int index = 0;
        for (int i_list  = 0; i_list < listNr ; ++i_list)
        {
            index += this.subLists.get(i_list).size();
        }
        return index;
    }

    public void addSublist(ObservableList<E> list){
        SubListListener listener = new SubListListener();
        this.subLists.add(list);
        list.addListener(listener);

        this.listeners.add(listener);


        for (E el : list)
        {
            this.add(el);
        }
    } // public void addSublist

    public void removeSublist(int i){

        int i_start = getStartIndex(i);

        this.remove(i_start, i_start + this.subLists.get(i).size());

        ObservableList<E> sublist = this.subLists.remove(i);
        ObservableCombindedList<E>.SubListListener listener = this.listeners.remove(i);
        sublist.removeListener(listener);

    }

    @Override
       public E get(int index) {
           return this.mainList.get(index);
       }

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

    @Override
    protected void doAdd(int index, E element) {
        this.mainList.add(index, element);
       }

    @Override
    protected E doSet(int index, E element) {

       return this.mainList.set(index, element);
       }

    @Override
    protected E doRemove(int index) {
          return this.mainList.remove(index);
    }

}