ComputedValue

org.eclipse.core.databinding.observable.value.ComputedValue<T>类实现IObservableValue接口，提供对象T的延迟计算特性，它提供了一个抽象方法calculate,实现这个方法就可以实现根据多个可监控对象(IObservableValue)计算更新当前对象的需求。

尼玛，好抽象，我自己都不知道在说什么,还是举个例子吧。

比如我们有一张表List<Integer>,这张表中的元素会被修改(添加，删除，更新)。

另外一个值sum,sum是上面这张表所有元素的和。所以如果要获取sum的值，就要对List进行求和。

下面这段代码通过实现ComputedValue<Integer>的抽象方法calculate来完成sum的自动求和功能，println方法调用sum的getValue时会自动计算List中的所有元素的总和。

TestComputeValue.java

package testwb;import java.util.ArrayList;import java.util.Iterator;import java.util.List;import org.eclipse.core.databinding.observable.Realm;import org.eclipse.core.databinding.observable.list.IObservableList;import org.eclipse.core.databinding.observable.list.WritableList;import org.eclipse.core.databinding.observable.value.ComputedValue;import org.eclipse.jface.databinding.swt.DisplayRealm;import org.eclipse.swt.widgets.Display;public class TestComputeValue {
       public static void main(String[] args) {        Display display = Display.getDefault();        Realm realm = DisplayRealm.getRealm(display);        // 创建一张空表        final IObservableList
   
     addends = new WritableList
    
     (realm);        // 向表中添加元素        addends.add(Integer.valueOf(0));        addends.add(Integer.valueOf(1));        addends.add(Integer.valueOf(2));        // 定义sum,实现calculate方法完成自动求和计算        ComputedValue
     
       sum = new ComputedValue
      
       () {            protected Integer calculate() {                int sum = 0;                                                for (Iterator
       
         it = addends.iterator(); it.hasNext();) {                    Integer addend = (Integer) it.next();                    sum += addend.intValue();                }                // 返回求和结果                return sum;            }        };        // 输出sum,通过getValue获取sum时，已经自动调用calculate方法计算了List总和        System.out.println(sum.getValue()); // => 3        // 向表中动态增加一个元素，则再次输出sum的值时，已经更新        addends.add(Integer.valueOf(10));        System.out.println(sum.getValue()); // => 13    }}

WritableList

这里要说明一下上面例子中的另一个主角WritableList，WritableList其实就是一个List,并且它实现了IObservableList接口(监控表中所有元素接口)，所以可以对List中的所有元素进行监控。

我们可以将任何一个普通的java.util.List封装成WritableList以实现对表中所有元素的监控，所以上面的示例代码也可以写成这样：

TestComputeValue2.java

package testwb;import java.util.ArrayList;import java.util.Iterator;import java.util.List;import org.eclipse.core.databinding.observable.Realm;import org.eclipse.core.databinding.observable.list.IObservableList;import org.eclipse.core.databinding.observable.list.WritableList;import org.eclipse.core.databinding.observable.value.ComputedValue;import org.eclipse.jface.databinding.swt.DisplayRealm;import org.eclipse.swt.widgets.Display;public class TestComputeValue2 {
       public static void main(String[] args) {        Display display = Display.getDefault();        Realm realm = DisplayRealm.getRealm(display);        //构造一个List,并添加元素。        List
   
     list = new ArrayList
    
     ();        list.add(0);        list.add(1);        list.add(2);        // 构造WritableList对象将list封装成IObservableList        final IObservableList
     
       addends = new WritableList
      
       (realm,list,null);        ComputedValue
       
         sum = new ComputedValue
        
         (realm) { protected Integer calculate() { int sum = 0; for (Iterator
         
           it = addends.iterator(); it.hasNext();) { Integer addend = (Integer) it.next(); sum += addend.intValue(); } return sum; } }; System.out.println(sum.getValue()); // => 3 addends.add(Integer.valueOf(10)); System.out.println(sum.getValue()); // => 13 System.out.println(list.size());// list中元素数目更新了，变为4， }}

runWithDefault

其实这个例子是我从ComputedValue源代码注释中抄来的(参见)，只是注释中的example代码并不完整，而且还写错了(WritableList.withElementType写成了WritableValue.withValueType)。在修改这段代码的时候，总算算搞清楚了ComputedValue的玩儿法。

看到这时你也许会问，既然ComputedValue源码中的例子错将WritableList.withElementType写成了WritableValue.withValueType，你上面的代码中为什么没有用WritableList.withElementType方法来构造WritableList对象呢？

用withElementType静态方法来构造WritableList的确很方便，但它是有环境使用要求的。请看它的代码：

public static 
   
     WritableList
    
      withElementType(Object elementType) {        return new WritableList
     
      (Realm.getDefault(), new ArrayList
      
       (), elementType);    }

在调用构造函数WritableList(Realm realm, List<E> toWrap, Object elementType)时对于第一个realm参数是用Realm.getDefault()静态方法获取的。而默认情况下Realm.getDefault()返回是null(why?参见Realm代码)，所以使用withElementType静态方法肯定就抛出异常了。

那么什么情况下Realm.getDefault()返回不为null呢?

看下面Realm中的runWithDefault静态方法的代码就明白了：

public static void runWithDefault(Realm realm, Runnable runnable) {        Realm oldRealm = Realm.getDefault();        try {            //设置defaultRealm,只有这时defaultRealm的值才不为null            defaultRealm.set(realm);            // 执行Runnable对象            runnable.run();        } finally {            // 执行完后恢复defaultRealm            defaultRealm.set(oldRealm);        }    }

所以如果要像ComputedValue源码中的例子那样使用withElementType静态方法来构造WritableList，代码应该这样写：

TestComputeValue3.java

package testwb;import java.util.ArrayList;import java.util.Iterator;import java.util.List;import org.eclipse.core.databinding.observable.Realm;import org.eclipse.core.databinding.observable.list.IObservableList;import org.eclipse.core.databinding.observable.list.WritableList;import org.eclipse.core.databinding.observable.value.ComputedValue;import org.eclipse.jface.databinding.swt.DisplayRealm;import org.eclipse.swt.widgets.Display;public class TestComputeValue3 {
       public static void main(String[] args) {        Display display = Display.getDefault();        Realm.runWithDefault(DisplayRealm.getRealm(display), new Runnable() {            public void run() {                try {                    // 调用withElementType静态方法创建WritableList对象                    final IObservableList
   
     addends = WritableList.withElementType(null);                    addends.add(Integer.valueOf(0));                    addends.add(Integer.valueOf(1));                    addends.add(Integer.valueOf(2));                    ComputedValue
    
      sum = new ComputedValue
     
      () {                        protected Integer calculate() {                            int sum = 0;                            for (Iterator
      
        it = addends.iterator(); it.hasNext();) {                                Integer addend = (Integer) it.next();                                sum += addend.intValue();                            }                            return sum;                        }                    };                    System.out.println(sum.getValue()); // => 3                    addends.add(Integer.valueOf(10));                    System.out.println(sum.getValue()); // => 13                } catch (Exception e) {                    e.printStackTrace();                }            }        });    }}

lambda支持

Eclipse Neon版本中ComputedValue类增加了一个新的create静态方法，来创建ComputedValue对象，create方法允许更方便的使用lamda表达来实现calculate方法。

例如下面的代码：

IObservableValue
   
     lastName = // ...IObservableValue
    
      firstName = // ...// 调用create方法通过lambda表达式作为calculate方法的实现IObservableValue
     
       formattedName = ComputedValue.create(() -> {        String lastNameValue = lastName.getValue();        String firstNameValue = firstName.getValue();        return lastNameValue + "," + firstNameValue;});

参考：

你可能感兴趣的文章

cs230 深度学习 Lecture 2 编程作业： Logistic Regression with a Neural Network mindset