JavaFX：从DoubleProperty的ObserviceSet中获取一个运行的值总数_Java_Javafx

JavaFX：从DoubleProperty的ObserviceSet中获取一个运行的值总数

java javafx

JavaFX：从DoubleProperty的ObserviceSet中获取一个运行的值总数,java,javafx,Java,Javafx,我有一个observeSetitemSet，它为Item的任何数量的实例保存DoublePropertyprop1 我想创建另一个DoubleProperty总计，它将反映itemSet中所有DoubleProperty的最新总计集合中每个DoubleProperty的双精度值可以独立更改。总价值需要反映这些变化这是项类： class Item { DoubleProperty prop1; DoubleProperty prop2; public Item() {

我有一个

observeSet

itemSet，它为

Item

的任何数量的实例保存

DoubleProperty

prop1

我想创建另一个

DoubleProperty

总计，它将反映itemSet中所有

DoubleProperty

的最新总计

集合中每个

DoubleProperty

的双精度值可以独立更改。总价值需要反映这些变化

这是

项

类：

class Item {
    DoubleProperty prop1;
    DoubleProperty prop2;

    public Item() {
        this.prop1 = new SimpleDoubleProperty(1.0);
        this.prop2 = new SimpleDoubleProperty(2.0);

        itemSet.add(this.prop1);
    }
}

这是一种全局变量类

class ItemValue {
    private ItemValue itemValue = null;

    ObservableSet<DoubleProperty> itemSet = FXCollections.observableSet();
    DoubleProperty total;

    private ItemValue() {
        this.total = new SimpleDoubleProperty(0.0);

        // create several Item's here...

        itemSet.addListener((InvalidationListener) observable -> {
        /*
        Something which binds the total
        I figure it will need to go here so that if new items get added the total will reflect that?
        */
        });
    }

    public ItemValue get() {
        if (itemValue == null) itemValue = new ItemValue();
        return itemValue;
}

类ItemValue{
私有ItemValue ItemValue=null；
ObservableSet itemSet=FXCollections.ObservableSet（）；
双重财产总额；
私有项值（）{
this.total=新的SimpleDoubleProperty（0.0）；
//在此处创建多个项目。。。
itemSet.addListener（（InvalizationListener）可观察->{
/*
束缚整体的东西
我想它需要放在这里，这样如果添加了新项目，总数就会反映出这一点？
*/
});
}
public ItemValue get（）{
如果（itemValue==null）itemValue=new itemValue（）；
返回项目值；
}

我会给itemSet一个变更监听器，每次调用它时都用一些方法重新计算总数

请参阅。

我会给项目集一个更改侦听器，并在每次调用时使用某种方法重新计算总数

请参阅。

据我所知，没有简单的内置方法。但是，有两种方法可以做到这一点。大多数（？）高效但更复杂的方法是监听

observateset

的添加/删除，观察任何当前

DoubleProperty

元素，并自己修改

total

属性

import javafx.beans.property.DoubleProperty;
import javafx.beans.property.ReadOnlyDoubleProperty;
import javafx.beans.property.ReadOnlyDoubleWrapper;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.beans.value.WeakChangeListener;
import javafx.collections.FXCollections;
import javafx.collections.ObservableSet;
import javafx.collections.SetChangeListener;

public class SomeClass {

  private final ReadOnlyDoubleWrapper total = new ReadOnlyDoubleWrapper(this, "total");
  private void setTotal(double total) { this.total.set(total); }
  public final double getTotal() { return total.get(); }
  public final ReadOnlyDoubleProperty totalProperty() { return total.getReadOnlyProperty(); }

  private final ObservableSet<DoubleProperty> propertySet = FXCollections.observableSet();
  private final ChangeListener<Number> elementListener = this::elementValueChanged;
  private final WeakChangeListener<Number> weakElementListener =
      new WeakChangeListener<>(elementListener);

  public SomeClass() {
    propertySet.addListener(this::propertySetChanged);
  }

  private void propertySetChanged(SetChangeListener.Change<? extends DoubleProperty> change) {
    if (change.wasRemoved()) {
      change.getElementRemoved().removeListener(weakElementListener);
      setTotal(getTotal() - change.getElementRemoved().get());
    }
    if (change.wasAdded()) {
      change.getElementAdded().addListener(weakElementListener);
      setTotal(getTotal() + change.getElementAdded().get());
    }
  }

  private void elementValueChanged(ObservableValue<? extends Number> observable,
                                   Number oldValue, Number newValue) {
    setTotal(getTotal() - oldValue.doubleValue() + newValue.doubleValue());
  }

}

在这种情况下，我们将一个

invalizationListener

添加到

observateSet

中。每当在

observateSet

中添加或删除元素时，都会调用此侦听器。发生这种情况时，会发生以下三种情况之一：

如果

observeSet

现在为空，则解除绑定

total

属性并将其设置为零。

这是处理无元素的特殊情况

如果

observeSet

现在只包含单个元素，只需将

total

属性绑定到所述元素即可。

另一个处理单个元素的特殊情况是，它阻止我们创建不必要的对象和执行不必要的计算，如果我们跳过第三个分支，就会发生这种情况

否则，创建一个计算总和的大绑定，然后将

total

绑定到该绑定。

此分支使用
```
DoubleExpression.add（ObservableEnumberValue）
```
。该方法调用产生的
```
DoubleBinding
```
将在两个可观察对象中的一个发生更改时更新。这将简化为单个
```
DoubleExpression
```
，然后将
```
total
```
属性绑定到该属性

第二个选项效率较低，因为它每次都需要迭代整个

可观察集。它还可能导致创建大量双重绑定对象。但是，您可能会发现它更易于编码/理解，并且性能影响对您的应用程序来说可能不够显著。
据我所知，没有简单的内置方法可以做到这一点。然而，有几种方法可以做到这一点。大多数（？）高效但更复杂的方法是监听observateset
的添加/删除，观察任何当前DoubleProperty
元素，并自己修改total
属性
import javafx.beans.property.DoubleProperty;
import javafx.beans.property.ReadOnlyDoubleProperty;
import javafx.beans.property.ReadOnlyDoubleWrapper;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.beans.value.WeakChangeListener;
import javafx.collections.FXCollections;
import javafx.collections.ObservableSet;
import javafx.collections.SetChangeListener;

public class SomeClass {

  private final ReadOnlyDoubleWrapper total = new ReadOnlyDoubleWrapper(this, "total");
  private void setTotal(double total) { this.total.set(total); }
  public final double getTotal() { return total.get(); }
  public final ReadOnlyDoubleProperty totalProperty() { return total.getReadOnlyProperty(); }

  private final ObservableSet<DoubleProperty> propertySet = FXCollections.observableSet();
  private final ChangeListener<Number> elementListener = this::elementValueChanged;
  private final WeakChangeListener<Number> weakElementListener =
      new WeakChangeListener<>(elementListener);

  public SomeClass() {
    propertySet.addListener(this::propertySetChanged);
  }

  private void propertySetChanged(SetChangeListener.Change<? extends DoubleProperty> change) {
    if (change.wasRemoved()) {
      change.getElementRemoved().removeListener(weakElementListener);
      setTotal(getTotal() - change.getElementRemoved().get());
    }
    if (change.wasAdded()) {
      change.getElementAdded().addListener(weakElementListener);
      setTotal(getTotal() + change.getElementAdded().get());
    }
  }

  private void elementValueChanged(ObservableValue<? extends Number> observable,
                                   Number oldValue, Number newValue) {
    setTotal(getTotal() - oldValue.doubleValue() + newValue.doubleValue());
  }

}

在这种情况下，我们将一个invalizationListener
添加到observateSet
中。每当在observateSet
中添加或删除元素时，都会调用此侦听器。发生这种情况时，会发生以下三种情况之一：
如果observeSet
现在为空，则解除绑定total属性并将其设置为零。

这是处理无元素的特殊情况

如果observeSet
现在只包含单个元素，只需将total属性绑定到所述元素即可。

另一个处理单个元素的特殊情况是，它阻止我们创建不必要的对象和执行不必要的计算，如果我们跳过第三个分支，就会发生这种情况

否则，创建一个计算总和的大绑定，然后将total绑定到该绑定。

此分支使用DoubleExpression.add（ObservableEnumberValue）
。该方法调用产生的DoubleBinding
将在两个可观察对象中的一个发生更改时更新。这将简化为单个DoubleExpression
，然后将total
属性绑定到该属性

第二个选项效率较低，因为它每次都需要迭代整个observateSet
。它还可能导致创建大量DoubleBinding
对象。但是，您可能会发现它更易于编码/理解，并且性能影响可能对您的应用程序来说不够大。
Hmmm。…不确定这是否有效。如果我理解正确，集合上的ChangeListener
只会识别集合中的DoubleProperty
是否被添加/删除/替换，而不会识别该DoubleProperty
的值是否被更改。因此，我的问题是：我特别需要合计这些DoubleProperty
'sHmmm…不确定这是否有效。如果我理解正确，则集合上的ChangeListener
仅在集合中的DoubleProperty
被添加/删除/替换时才会识别，但如果的值