qq_594336505

Android DataBing详解

转载于http://blog.csdn.net/qdjdeveloper/article/details/62236309

前几天小试牛刀写了一篇 Android DataBinding 初探，只是简单的介绍了一下 DataBinding 的几个小问题，并没有特别详细的去介绍 DataBinding 的更多方法，这几天看了一下 DataBinding 的官网的相关内容，觉得有必要把官网的用法记录一下，用来参考及以后使用时的参考，以前大家很多人都使用过注解框架，包括 Jake Wharton 大神的 ButterKnife，但 DataBinding 出来后，相信会对此类的框架形成碾压，毕竟是 Google 的官方出品，接下来我们切入正题了，开始详细的去介绍这个 Android DataBinding Library，先上一张概况图：

一、构建环境(Build Environment)

要使用 DataBinding 数据库，先从 Android SDK Manager 的支持库里下载该库
配置你的应用程序使用数据绑定，在应用程序模块，你的 build.gradle 文件添加数据绑定元素
另外，需要注意你使用的 Android Studio 的兼容版本，需要 1.3 及以上的版本

使用下面代码段来配置数据绑定：

[java] view plain copy

android {
….
dataBinding {
enabled = true
}
}

android {
    ....
    dataBinding {
        enabled = true
    }
}

二、数据绑定布局文件(Data Binding Layout Files)

1) DataBinding 表达式

数据绑定的布局文件和我们以前经常写的布局文件稍有不同，并从布局的根标记开始，后面依次是数据元素和视图根元素，即根布局是 layout，接下来是 data 节点，variable 节点，示例如下：

[html] view plain copy

xml version=“1.0” encoding=“utf-8”?>
<layout xmlns:android=“http://schemas.android.com/apk/res/android”>
<data>
<variable name=“user” type=“com.example.User”/>
data>
<LinearLayout
android:orientation=“vertical”
android:layout_width=“match_parent”
android:layout_height=“match_parent”>
<TextView android:layout_width=“wrap_content”
android:layout_height=“wrap_content”
android:text=“@{user.firstName}”/>
<TextView android:layout_width=“wrap_content”
android:layout_height=“wrap_content”
android:text=“@{user.lastName}”/>
LinearLayout>
layout>

数据中的用户变量描述此布局中可能使用的属性：

[html] view plain copy

<variable name=“user” type=“com.example.User”/>

布局中的表达式使用 “@{}” 语法在属性中写入，在这里，TextView 的文本设置为用户 FirstName 属性：

[html] view plain copy

<span style=“color:#666666;”><TextView android:layout_width=“wrap_content”
android:layout_height=“wrap_content”
android:text=“@{user.firstName}”/>span>

2)数据对象(Data Object)

假设你现在有一个普通的 Java 对象(User):

[java] view plain copy

public class User {
public final String firstName;
public final String lastName;
public User(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
}

public class User {
   public final String firstName;
   public final String lastName;
   public User(String firstName, String lastName) {
       this.firstName = firstName;
       this.lastName = lastName;
   }
}

这种类型的对象具有从不改变的数据，应用程序中国通常有一次读取数据，此后不会更改，也可以使用 JavaBeans 对象：

[java] view plain copy

public class User {
private final String firstName;
private final String lastName;
public User(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public String getFirstName() {
return this.firstName;
}
public String getLastName() {
return this.lastName;
}
}

public class User {
   private final String firstName;
   private final String lastName;
   public User(String firstName, String lastName) {
       this.firstName = firstName;
       this.lastName = lastName;
   }
   public String getFirstName() {
       return this.firstName;
   }
   public String getLastName() {
       return this.lastName;
   }
}

从数据绑定的角度来看，这两个类是等价的，用于 TextView 中的 android:text 属性的表达式 @{user.firstName} 将访问前者 User 对象中的 firstName 和后者 JavaBeans 对象中的 getFirstName 方法

3）数据绑定(Binding Data)

默认情况下，绑定类将根据 layout 文件的名称生成，首字母大写的命名规范，并添加 “Binding” 后缀，上述的布局文件是main_activity.xml，所以生成类是 MainActivityBinding, 该类将布局属性(例如 User 变量)的所有绑定保存到布局视图中，并知道如何为绑定表达式赋值，创建最简单的方法是在 inflating 时绑定，如下:

[java] view plain copy

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
MainActivityBinding binding = DataBindingUtil.setContentView(this, R.layout.main_activity);
User user = new User(“Test”, “User”);
binding.setUser(user);
}

@Override
protected void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   MainActivityBinding binding = DataBindingUtil.setContentView(this, R.layout.main_activity);
   User user = new User("Test", "User");
   binding.setUser(user);
}

就这样，运行应用程序，你将会在 UI 中看到 Test User，或者你可以通过如下获取 View:

[java] view plain copy

MainActivityBinding binding = MainActivityBinding.inflate(getLayoutInflater());

MainActivityBinding binding = MainActivityBinding.inflate(getLayoutInflater());

如果你是在 ListView 或者 RecyclerView adapter 中使用 Data Binding 时，你可能使用：

[java] view plain copy

ListItemBinding binding = ListItemBinding.inflate(layoutInflater, viewGroup, false);
//or
ListItemBinding binding = DataBindingUtil.inflate(layoutInflater, R.layout.list_item, viewGroup, false);

ListItemBinding binding = ListItemBinding.inflate(layoutInflater, viewGroup, false);
//or
ListItemBinding binding = DataBindingUtil.inflate(layoutInflater, R.layout.list_item, viewGroup, false);

4）事件处理(Event Handing)

数据绑定允许你编写表达式处理，如 onClick 事件，有少数例外事件属性的名称受监听方法名称的约束，例如View.OnLongClickListener 有一个 onLongClick 方法，所以此事件的属性是：Android:onLongClick，它有两种处理事件的方法：

方法引用：在表达式中，可以引用符合监听方法签名的方法，当表达式计算为方法引用时，数据绑定将监听器中的方法引用和所有者对象封装在一起，并在目标视图上设置监听器，如果表达式计算为 null，则数据绑定不会创建监听器，而是设置空监听器
监听器绑定：这些是在事件发生时计算 Lambda 表达式，数据绑定总是创建一个监听器，它设置在视图上，当事件被发送时，监听器计算 Lambda 表达式

方法引用：事件可以直接绑定到处理程序的方法，类似于 Android:onClick，相比来看 View#onClick 属性更重要的优势是，表达式在编译的时候处理的，所以如果方法不存在或签名是不正确的，你将会在编译时出错，方法引用和监听器绑定之间的主要区别是，当数据绑定时，实际的监听器实现将创建，而不是在触发时，如果你希望事件发生时对表达式进行审核，则应该使用监听器绑定，若将事件分配给其处理程序，请使用常规绑定表达式，该值是要调用的方法名，例如，如果你的数据对象有两种方法：

[java] view plain copy

public class MyHandlers {
public void onClickFriend(View view) { … }
}

public class MyHandlers {
    public void onClickFriend(View view) { ... }
}

绑定表达式可以为视图分配单击监听器：

注意表达式中的方法的签名必须与监听对象中的方法的签名完全匹配

[html] view plain copy

xml version=“1.0” encoding=“utf-8”?>
<layout xmlns:android=“http://schemas.android.com/apk/res/android”>
<data>
<variable name=“handlers” type=“com.example.Handlers”/>
<variable name=“user” type=“com.example.User”/>
data>
<LinearLayout
android:orientation=“vertical”
android:layout_width=“match_parent”
android:layout_height=“match_parent”>
<TextView android:layout_width=“wrap_content”
android:layout_height=“wrap_content”
android:text=“@{user.firstName}”
android:onClick=“@{handlers::onClickFriend}”/>
LinearLayout>
layout>

监听器绑定：监听器绑定是在事件发生运行时的绑定表达式，它类似于方法引用，但它容许你运行任意的数据绑定表达式，需要注意的是此功能在 Android Gradle2.0 及以上版本可用，在方法引用中，该方法的参数必须与事件监听器的参数相匹配，在监听器绑定中，只有返回值必须与监听器的期望返回值相匹配，示例如下：

[java] view plain copy

public class Presenter {
public void onSaveClick(Task task){}
}

public class Presenter {
    public void onSaveClick(Task task){}
}

然后你可以在你的 xml 文件中将点击事件绑定如下：

[html] view plain copy

xml version=“1.0” encoding=“utf-8”?>
<layout xmlns:android=“http://schemas.android.com/apk/res/android”>
<data>
<variable name=“task” type=“com.android.example.Task” />
<variable name=“presenter” type=“com.android.example.Presenter” />
data>
<LinearLayout android:layout_width=“match_parent” android:layout_height=“match_parent”>
<Button android:layout_width=“wrap_content” android:layout_height=“wrap_content”
android:onClick=“@{() -> presenter.onSaveClick(task)}” />
LinearLayout>
layout>

监听器由 Lambda 表达式表示，这些表达式只允许作为表达式的根元素，当表达中使用回调时，数据绑定会自动创建时间的必要监听器和寄存器，当视图触发事件时，数据绑定将审核给定的表达式，与常规绑定方式一样，在审核这些监听器表达式时，任然可以得到数据绑定的 null 和线程安全性

请注意，在上面的例子中，我们还没有定义 View 的参数，通过 onClick(Android.view.View)Listener 绑定为监听器参数提供两种选择：你可以忽略所有方法参数或命名所有参数，如果你更喜欢命名参数，则也可以在表达式中使用它们，例如，上面的表达式可以写成：

[html] view plain copy

android:onClick=“@{(view) -> presenter.onSaveClick(task)}”

android:onClick="@{(view) -> presenter.onSaveClick(task)}"

或者如果你想使用表达式中的参数，它可以写成如下：

[java] view plain copy

public class Presenter {
public void onSaveClick(View view, Task task){}
}

public class Presenter {
    public void onSaveClick(View view, Task task){}
}

[html] view plain copy

android:onClick=“@{(theView) -> presenter.onSaveClick(theView, task)}”

android:onClick="@{(theView) -> presenter.onSaveClick(theView, task)}"

可以使用多个参数的 Lambda 表达式：

[java] view plain copy

public class Presenter {
public void onCompletedChanged(Task task, boolean completed){}
}

public class Presenter {
    public void onCompletedChanged(Task task, boolean completed){}
}

[html] view plain copy

<CheckBox android:layout_width=“wrap_content” android:layout_height=“wrap_content”
android:onCheckedChanged=“@{(cb, isChecked) -> presenter.completeChanged(task, isChecked)}” />

如果监听的事件返回类型无效的值，则表达式必须返回相同类型的值。例如，如果要监听长点击事件，则表达式应返回布尔值：

[java] view plain copy

public class Presenter {
public boolean onLongClick(View view, Task task){}
}

public class Presenter {
    public boolean onLongClick(View view, Task task){}
}

[html] view plain copy

android:onLongClick=“@{(theView) -> presenter.onLongClick(theView, task)}”

android:onLongClick="@{(theView) -> presenter.onLongClick(theView, task)}"

你还可以使用三元表达式：

[html] view plain copy

android:onClick=“@{(v) -> v.isVisible() ? doSomething() : void}”

android:onClick="@{(v) -> v.isVisible() ? doSomething() : void}"

避免复杂的监听：
监听器表达式是非常强大的，可以使你的代码很容易阅读。另一方面，含有复杂的表达式的监听让你的布局难以阅读和维护。这些表达式应该是简单的，从用户界面传递可用数据到回调方法。您可以在从监听器表达式调用的回调方法中实现任何业务逻辑

三、布局细节(Layout Details)

1)imports

可以在数据元素内使用零个或多个导入元素。这些可以参考在你的布局文件的类，就像在 java:

[html] view plain copy

<data>
<import type=“android.view.View”/>
data>

现在，视图可以在绑定表达式中使用：

[html] view plain copy

<TextView
android:text=“@{user.lastName}”
android:layout_width=“wrap_content”
android:layout_height=“wrap_content”
android:visibility=“@{user.isAdult ? View.VISIBLE : View.GONE}”/>

当有类名冲突时，其中一个类可以重命名为“alias:”,如下：

[html] view plain copy

<import type=“android.view.View”/>
<import type=“com.example.real.estate.View”
alias=“Vista”/>

现在，Vista 可以用来参考的 com.example.real.estate.view 和视图可以用来参考 android.view.view 在布局文件中，导入类型可以用作变量和表达式中的类型引用：

[html] view plain copy

<data>
<import type=“com.example.User”/>
<import type=“java.util.List”/>
<variable name=“user” type=“User”/>
<variable name=“userList” type=“List”/>
data>

注意：Android Studio 还不能很好的兼容支持，变量可能不能在 IDE 中完成自动提示功能。但是你的应用程序将仍然可以编译，你可以通过使用完全限定名称来定义变量解决 IDE 的问题：

[html] view plain copy

<TextView
android:text=“@{((User)(user.connection)).lastName}”
android:layout_width=“wrap_content”
android:layout_height=“wrap_content”/>

在表达式中引用静态字段和方法时也可以使用导入类型：

[html] view plain copy

<data>
<import type=“com.example.MyStringUtils”/>
<variable name=“user” type=“com.example.User”/>
data>
…
<TextView
android:text=“@{MyStringUtils.capitalize(user.lastName)}”
android:layout_width=“wrap_content”
android:layout_height=“wrap_content”/>

…

就像在 java 语言，java * 自动导入

2）Variables

可以在数据元素内使用任意数量的变量元素。每个变量元素描述可以在布局文件中用于绑定表达式中的布局的属性:

[html] view plain copy

<data>
<import type=“android.graphics.drawable.Drawable”/>
<variable name=“user” type=“com.example.User”/>
<variable name=“image” type=“Drawable”/>
<variable name=“note” type=“String”/>
data>

在编译时检查变量类型，因此，如果变量实现 Observable 或 Observable 的集合，则该类型应反映在类型中。如果变量是不执行 Observable* 接口的基类或接口，则不会观察变量,当有不同的布局文件的各种配置（如头像），变量将被合并。这些布局文件之间不能有冲突的变量定义生成一个名为上下文的特殊变量，用于在需要时绑定表达式。上下文的值是根目录的 getcontext()，上下文变量将被一个显式变量声明所覆盖

3）自定义绑定类名(Custom Binding Class Names)

默认情况下，绑定类是基于布局的文件名生成，开始用大写，去掉下划线 “_”，然后加后缀 “Binding”，这个类将会被放置在一个绑定包的模块包下，例如，布局文件是 contant_item.xml 将生成 ContactItemBinding，如果模块封装为 com.example.my.app，那么它将被放置在 com.example.my.app.databinding

通过调整数据元素的类属性可以将绑定类重命名或放置在不同的包中。例如:

[html] view plain copy

<data class=“ContactItem”>
…
data>

...

这个生成绑定类中的模块封装在数据绑定包 ContactItem，如果类产生在不同的包中的模块封装内，它可能会加 “.”，如下：

[html] view plain copy

<data class=“.ContactItem”>
…
data>

...

在这种情况下，ContactItem 直接在模块封装生成，如果提供完整的包，任何包可以使用：

[html] view plain copy

<data class=“com.example.ContactItem”>
…
data>

...

4）Includes

通过使用应用程序命名空间和属性中的变量名，可以将变量从包含布局中传递到包含布局中：

[html] view plain copy

xml version=“1.0” encoding=“utf-8”?>
<layout xmlns:android=“http://schemas.android.com/apk/res/android”
xmlns:bind=“http://schemas.android.com/apk/res-auto”>
<data>
<variable name=“user” type=“com.example.User”/>
data>
<LinearLayout
android:orientation=“vertical”
android:layout_width=“match_parent”
android:layout_height=“match_parent”>
<include layout=“@layout/name”
bind:user=“@{user}”/>
<include layout=“@layout/contact”
bind:user=“@{user}”/>
LinearLayout>
layout>

在这里，必须有两 name.xml 和 contact.xml 布局文件的用户变量

数据绑定不支持包括合并元素的直接子项。例如，不支持下列布局：

[html] view plain copy

xml version=“1.0” encoding=“utf-8”?>
<layout xmlns:android=“http://schemas.android.com/apk/res/android”
xmlns:bind=“http://schemas.android.com/apk/res-auto”>
<data>
<variable name=“user” type=“com.example.User”/>
data>
<merge>
<include layout=“@layout/name”
bind:user=“@{user}”/>
<include layout=“@layout/contact”
bind:user=“@{user}”/>
merge>
layout>

5）表达式(Expression Language)

常用表达式给 Java 表达式很像，如下：

Mathematical(数学)” + - / * %"
String concatenation(字符串连接) “+“
Logical(逻辑) “&& ||“
Binary(二进制) “& | ^“
Unary(一元运算) “+ - ! ~“
Shift(移位) “>> >>> <<“
Comparison(比较)”== > < >= <=“
instanceof
Grouping(分组) “()“
Literals - character, String, numeric, null
Cast
Method calls(方法调用)
Field access
Array access(数据访问) “[]“
Ternary operator(三元运算) “?:“

示例如下：

[html] view plain copy

android:text=“@{String.valueOf(index + 1)}”
android:visibility=“@{age < 13 ? View.GONE : View.VISIBLE}”
android:transitionName=‘@{“image_” + id}’

android:text="@{String.valueOf(index + 1)}"
android:visibility="@{age < 13 ? View.GONE : View.VISIBLE}"
android:transitionName='@{"image_" + id}'

缺少的操作：

this
super
new
Explicit generic invocation

null 合并运算符：

null 合并运算符(??)左边不为 null 或正确，则返回左边，否则返回右边，如下：

[html] view plain copy

android:text=“@{user.displayName ?? user.lastName}”

android:text="@{user.displayName ?? user.lastName}"

在功能上和如下相同：

[html] view plain copy

android:text=“@{user.displayName != null ? user.displayName : user.lastName}”

android:text="@{user.displayName != null ? user.displayName : user.lastName}"

属性引用：

第一个前边已经提到了，DataBinding 表达式：JavaBean 引用的简短格式

当一个表达式引用一个类的属性，它仍使用同样的格式对于字段、getters 以及 ObservableFields

[html] view plain copy

android:text=“@{user.lastName}”

android:text="@{user.lastName}"

避免空指针(Avoiding NullPointerException)

Data Binding 代码生成时会自动检查是否为 null，来避免出现 null pointer exception 错误，例如在表达式 @{user.name} 中，如果 user 是 null，user.name 会赋予它的默认值 null，如果你引用 @{user.age}，age 是 int 类型，那么它的默认值是 0

集合：

常见的集合：数组，列表，稀疏列表和 maps，可以访问使用 [ ] 运算符

[html] view plain copy

<data>
<import type=“android.util.SparseArray”/>
<import type=“java.util.Map”/>
<import type=“java.util.List”/>
<variable name=“list” type=“List”/>
<variable name=“sparse” type=“SparseArray”/>
<variable name=“map” type=“Map”/>
<variable name=“index” type=“int”/>
<variable name=“key” type=“String”/>
data>
…
android:text=“@{list[index]}”
…
android:text=“@{sparse[index]}”
…
android:text=“@{map[key]}”


    
    
    
    
    
    
    
    

…
android:text="@{list[index]}"
…
android:text="@{sparse[index]}"
…
android:text="@{map[key]}"

字符串常量(String Literals)：

当在属性值周围使用单引号时，表达式中使用双引号：

[html] view plain copy

android:text=‘@{map[“firstName”]}’

android:text='@{map["firstName"]}'

使用双引号来包含属性值也可以，字符串前需要使用”`”:

[html] view plain copy

android:text=“@{map[`firstName`}”
android:text=“@{map[‘firstName’]}”

android:text="@{map[`firstName`}"
android:text="@{map['firstName']}"

资源(Resources):

可以使用正常语法的表达式访问资源：

[html] view plain copy

android:padding=“@{large? @dimen/largePadding : @dimen/smallPadding}”

android:padding="@{large? @dimen/largePadding : @dimen/smallPadding}"

格式字符串和复数可通过提供参数判断：

[html] view plain copy

android:text=“@{@string/nameFormat(firstName, lastName)}”
android:text=“@{@plurals/banana(bananaCount)}”

android:text="@{@string/nameFormat(firstName, lastName)}"
android:text="@{@plurals/banana(bananaCount)}"

当复数需要多个参数时，所有参数都应通过：

[html] view plain copy

Have an orange
Have %d oranges
android:text=“@{@plurals/orange(orangeCount, orangeCount)}”

  Have an orange
  Have %d oranges

android:text="@{@plurals/orange(orangeCount, orangeCount)}"

一些资源需要显示类型判断：

四、数据对象(Data Objects)

任何普通的 java 对象（POJO）可用于数据绑定，但修改一个 POJO 不会造成UI更新。数据绑定的真正能力可以通过给数据对象在数据变化时通知来使用,有三种不同的数据更改通知机制，Observable 对象，ObservableFilelds 字段和 Observable Cllections 集合,当这些可观察数据对象绑定到 UI 和数据对象的属性更改时，用户界面将自动更新

Observable 对象(Observable Objects)

实现 Observable 接口类允许单个监听器连接到绑定对象以监听该对象所有属性的改变

Observable 接口有一个机制来添加和删除监听器，但通知是由开发人员管理,为使开发更容易，一个 BaseObservable 基类是为了实现监听器注册机制而创建。Data 类实现者仍然是负责通知时的性能变化。这是通过分配一个 Bindable 注释 getter 和 setter 进行通知来完成

[java] view plain copy

private static class User extends BaseObservable {
private String firstName;
private String lastName;
@Bindable
public String getFirstName() {
return this.firstName;
}
@Bindable
public String getLastName() {
return this.lastName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
notifyPropertyChanged(BR.firstName);
}
public void setLastName(String lastName) {
this.lastName = lastName;
notifyPropertyChanged(BR.lastName);
}
}

private static class User extends BaseObservable {
   private String firstName;
   private String lastName;
   @Bindable
   public String getFirstName() {
       return this.firstName;
   }
   @Bindable
   public String getLastName() {
       return this.lastName;
   }
   public void setFirstName(String firstName) {
       this.firstName = firstName;
       notifyPropertyChanged(BR.firstName);
   }
   public void setLastName(String lastName) {
       this.lastName = lastName;
       notifyPropertyChanged(BR.lastName);
   }
}

Bindable 在编译过程中生成绑定在 BR 类的文件条目，BR 类文件会在模块包内生成，如果 Data 类的基类不能改变，Observable 接口通过 PropertyChangeRegistry 可以方便的来实现用于存储和有效的通知监听器

Observable 字段（ObservableFields）

一个小工作会涉及到创建 Observable 类，所以开发者们想节省时间或仅有几个特性可以用 observablefield 和它的同类observableboolean，observablebyte，observablechar，observableshort，observableint，observablelong，observablefloat，observabledouble，和observableparcelable。observablefields 完备可观察对象有一个单一的领域。原始版本避免装箱和拆箱过程中访问操作。若要使用，请在数据类中创建 public final 字段：

[java] view plain copy

private static class User {
public final ObservableField firstName =
new ObservableField<>();
public final ObservableField lastName =
new ObservableField<>();
public final ObservableInt age = new ObservableInt();
}

private static class User {
   public final ObservableField firstName =
       new ObservableField<>();
   public final ObservableField lastName =
       new ObservableField<>();
   public final ObservableInt age = new ObservableInt();
}

是这么回事！访问值，使用设置和获取方法：

[java] view plain copy

user.firstName.set(“Google”);
int age = user.age.get();

user.firstName.set("Google");
int age = user.age.get();

Observable 集合(Observable Clollections)

一些应用程序使用更多的动态结构来保存数据。Observable 集合允许对这些数据对象进行键控访问。ObservableArrayMap 用于键是引用类型，关键是引用类型，比如 String:

[java] view plain copy

ObservableArrayMap user = new ObservableArrayMap<>();
user.put(”firstName”, “Google”);
user.put(”lastName”, “Inc.”);
user.put(”age”, 17);

ObservableArrayMap user = new ObservableArrayMap<>();
user.put("firstName", "Google");
user.put("lastName", "Inc.");
user.put("age", 17);

在布局中，map 可以通过字符串键访问：

[html] view plain copy

<data>
<import type=“android.databinding.ObservableMap”/>
<variable name=“user” type=“ObservableMap”/>
data>
…
<TextView
android:text=‘@{user[“lastName”]}’
android:layout_width=“wrap_content”
android:layout_height=“wrap_content”/>
<TextView
android:text=‘@{String.valueOf(1 + (Integer)user[“age”])}’
android:layout_width=“wrap_content”
android:layout_height=“wrap_content”/>

…

ObservableArrayList 用于键是整数：

[java] view plain copy

ObservableArrayList

Android DataBing详解

你可能感兴趣的:(Android高级开发)