安装包 io.realm

RealmList<E> 类

  • 类型参数：
    E - 列表中的对象类。
    所有已实现的接口：
    io.realm.internal.Freezable<RealmCollection<E>>, io.realm.internal.ManageableObject, OrderedRealmCollection<E>, RealmCollection<E>, Iterable<E>, Collection<E>, List<E>
    public class RealmList<E>
extends AbstractList<E>
implements OrderedRealmCollection<E>
    RealmList 用于对RealmObject中的一对多关系进行建模。 RealmList 有两种模式：托管模式和非托管模式。 在托管模式下，所有对象都会保留在 Realm 中，在非托管模式下，它会像普通的 ArrayList 一样工作。

    只有 Realm 可以创建托管 RealmList。 每当更新底层 Realm 时，托管 RealmList 都会自动更新内容，并且只能使用RealmObject的 getter 进行访问。

    非托管 RealmList 可由用户创建，可包含托管和非托管 RealmObject。 这在处理 JSON 反序列化器（例如 GSON）或其他将值注入到类中的框架时非常有用。 可以使用Realm.copyToRealm(Iterable, ImportFlag...)方法将此列表中的非托管元素添加到 Realm 中。

    RealmList包含的元素数量可以多于Integer.MAX_VALUE 。 在这种情况下，您只能访问其中的前Integer.MAX_VALUE元素。

    • 字段详细信息

      • baseRealm

        public final io.realm.BaseRealm baseRealm
        此列表所在的BaseRealm实例。

        警告：此字段仅供内部使用，不应使用。

    • 构造函数详细信息

      • RealmList

        public RealmList()
        在非托管模式下创建 RealmList，其中的元素不受 Realm 控制。 这实际上使 RealmList 函数成为ArrayList ，并且无法查询此状态下的对象。

        使用Realm.copyToRealm(Iterable, ImportFlag...)在 Realm 中正确保留其元素。

      • RealmList

        公共 RealmList​（ E ...对象）
        在非托管模式下创建一个具有初始元素列表的 RealmList。 非托管模式下的 RealmList 充当ArrayList ，无法查询此状态下的对象。

        使用Realm.copyToRealm(Iterable, ImportFlag...)正确保留 Realm 中的所有非托管元素。

        参数：
        objects - 列表中的初始对象。

    • 方法详细信息

      • isValid

        public boolean isValid()
        检查collection是否仍可有效使用，即Realm实例尚未关闭。对于非托管collection，它将始终返回true 。
        指定者：
        isValid 在接口中 io.realm.internal.ManageableObject
        指定者：
        isValid 在接口中 RealmCollection<E>
        返回：
        true 如果仍可使用，则为非托管collection，否则为false 。

      • 冻结

        public RealmList<E> freeze()
        指定者：
        freeze 在接口中 io.realm.internal.Freezable<E>

      • IsFrozen

        public boolean isFrozen()
        指定者：
        isFrozen 在接口中 io.realm.internal.ManageableObject

      • isManaged

        public boolean isManaged()
        检查collection是否由 Realm 托管。一个托管的collection只是底层 Realm 文件中数据的包装器。在 Looper 线程上，托管 collection 将实时更新，因此它始终点向最新数据。托管collection具有线程限制，因此除了创建它们的线程之外，无法从其他线程访问托管collection。

        如果此方法返回false ，则该集合为非托管集合。 非托管集合只是普通的 Java 集合，因此不会实时更新。

        指定者：
        isManaged 在接口中 io.realm.internal.ManageableObject
        指定者：
        isManaged 在接口中 RealmCollection<E>
        返回：
        true 如果这是托管RealmCollection ，否则为false 。

      • move

        public void move​(int oldPos,
                 int newPos)
        将对象从一个位置移动到另一个位置，同时保持列表大小固定。 RealmObject 将进行移动，因此不会引入null值。
        参数：
        oldPos — 要移动的 RealmObject 的索引。
        newPos - 目标位置。 如果 newPos < oldPos，则该位置的对象将向右移动。 如果 oldPos < newPos,indexes > oldPos 将向左移动一次。
        抛出异常：
        IllegalStateException - 如果 Realm 实例已关闭或父对象已删除。
        IndexOutOfBoundsException - 如果任何位置超出 [0, size()]。

      • 删除

        公共E删除​（int位置）
        从此列表中删除指定位置的对象。
        指定者：
        remove 在接口中 List<E>
        覆盖：
        remove 课堂上 AbstractList<E>
        参数：
        location - 要删除的对象的索引。
        返回：
        删除的对象。
        抛出异常：
        IllegalStateException - 如果 Realm 实例已关闭或父对象已删除。
        IndexOutOfBoundsException - 如果location < 0 || location >= size() 。

      • 删除

        公共布尔删除​（ @Nullable Object对象）
        如果此Collection包含指定对象，则从中删除一个实例。 此实现会遍历此Collection并测试迭代器返回的每个元素e ，确定e是否等于给定对象。 如果为object != null ，则使用object.equals(e)执行此测试，否则使用object == null执行。 如果找到等于给定对象的元素，则对迭代器调用remove方法并返回true ，否则返回false 。 如果迭代器不支持删除元素，则会引发UnsupportedOperationException 。
        指定者：
        remove 在接口中 Collection<E>
        指定者：
        remove 在接口中 List<E>
        覆盖：
        remove 课堂上 AbstractCollection<E>
        参数：
        object - 要删除的对象。
        返回：
        true 如果此Collection已修改，则否则为false 。
        抛出异常：
        ClassCastException - 如果传递的对象类型不正确。
        NullPointerException - 如果object为null 。

      • 删除全部

        public boolean removeAll​(Collection<?> collection)
        删除指定Collection中每个对象在此Collection中出现的所有情况。 在此方法返回后，在此Collection中找不到所传递的Collection中的任何元素。

        此实现遍历Collection并测试迭代器返回的每个元素e ，看看它是否包含在指定的Collection中。 如果此测试是肯定的，则在迭代器上调用 remove方法。

        指定者：
        removeAll 在接口中 Collection<E>
        指定者：
        removeAll 在接口中 List<E>
        覆盖：
        removeAll 课堂上 AbstractCollection<E>
        参数：
        collection - 要删除的collection的对象。
        返回：
        true 如果此Collection已修改，则否则为false 。
        抛出异常：
        ClassCastException - 如果collection的一个或多个元素的类型不正确。
        NullPointerException - 如果collection为null 。

      • deleteFirstFromRealm

        public boolean deleteFirstFromRealm()
        从 Realm 中删除第一个对象。 这也会将其从该collection中删除。
        指定者：
        deleteFirstFromRealm 在接口中 OrderedRealmCollection<E>
        返回：
        true 如果删除了对象，则为false 。

      • deleteLastFromRealm

        public boolean deleteLastFromRealm()
        从 Realm 中删除最后一个对象。 这也会将其从该collection中删除。
        指定者：
        deleteLastFromRealm 在接口中 OrderedRealmCollection<E>
        返回：
        true 如果删除了对象，则为false 。

      • 获取

        @Nullable public E get​(int 位置)
        返回此列表中指定位置的元素。
        指定者：
        get 在接口中 List<E>
        指定者：
        get 课堂上 AbstractList<E>
        参数：
        location - 要返回的元素的索引。
        返回：
        指定索引处的元素。
        抛出异常：
        IllegalStateException - 如果 Realm 实例已关闭或父对象已删除。
        IndexOutOfBoundsException - 如果location < 0 || location >= size() 。

      • first

        @Nullable public E first​( @Nullable E defaultValue)
        获取集合中的第一个对象。 如果collection为空，将使用提供的默认。
        指定者：
        first 在接口中 OrderedRealmCollection<E>
        返回：
        第一个对象或提供的默认值。

      • last

        @Nullable public E last​( @Nullable E defaultValue)
        从collection中获取最后一个对象。如果collection为空，将使用提供的默认。
        指定者：
        last 在接口中 OrderedRealmCollection<E>
        返回：
        最后一个对象或提供的默认值。

      • sort

        public RealmResults<E> sort​(String fieldName)
        根据提供的字段以升序对collection进行排序。
        指定者：
        sort 在接口中 OrderedRealmCollection<E>
        参数：
        fieldName - 作为排序依据的字段名称。 仅支持 boolean、short、int、long、float、double、Date 和 String 类型的字段。
        返回：
        将创建并返回一个新的已排序RealmResults 。 原始collection保持不变。

      • sort

        public RealmResults<E> sort​(String fieldName,
                            Sort sortOrder)
        根据提供的字段和排序顺序对collection进行排序。
        指定者：
        sort 在接口中 OrderedRealmCollection<E>
        参数：
        fieldName - 作为排序依据的字段名称。 仅支持 boolean、short、int、long、float、double、Date 和 String 类型的字段。
        sortOrder - 排序依据的方向。
        返回：
        将创建并返回一个新的已排序RealmResults 。 原始collection保持不变。

      • sort

        public RealmResults<E> sort​(String fieldName1,
                            Sort sortOrder1,
                            String fieldName2,
                            Sort sortOrder2)
        根据提供的字段和排序顺序对collection进行排序。
        指定者：
        sort 在接口中 OrderedRealmCollection<E>
        参数：
        fieldName1 - 第一个字段名称。 仅支持 boolean、short、int、long、float、double、Date 和 String 类型的字段。
        sortOrder1 — 第一个字段的排序顺序。
        fieldName2 — 第二个字段名称。 仅支持 boolean、short、int、long、float、double、Date 和 String 类型的字段。
        sortOrder2 — 第二个字段的排序顺序。
        返回：
        将创建并返回一个新的已排序RealmResults 。 原始collection保持不变。

      • sort

        public RealmResults<E> sort​(String[] fieldNames,
                            Sort[] sortOrders)
        根据提供的字段和排序顺序对collection进行排序。
        指定者：
        sort 在接口中 OrderedRealmCollection<E>
        参数：
        fieldNames - 作为排序依据的字段名称数组。 仅支持 boolean、short、int、long、float、double、Date 和 String 类型的字段。
        sortOrders - 排序依据的方向。
        返回：
        将创建并返回一个新的已排序RealmResults 。 原始collection保持不变。

      • deleteFromRealm

        public void deleteFromRealm​(int location)
        从 Realm 中删除给定索引处的对象。 这也会将其从collection中删除。
        指定者：
        deleteFromRealm 在接口中 OrderedRealmCollection<E>
        参数：
        location - 标识要删除的对象的数组索引。

      • min

        @Nullable public Number min​( String fieldName)
        查找字段的最小值。
        指定者：
        min 在接口中 RealmCollection<E>
        参数：
        fieldName - 查找最小值的字段。 仅支持数字字段。
        返回：
        如果对象不存在，或者给定字段的值为null ，则返回null 。否则返回最小值。 确定最小值时，具有null值的对象将被忽略。

      • Max

        @Nullable public Number max​( String fieldName)
        查找字段的最大值。
        指定者：
        max 在接口中 RealmCollection<E>
        参数：
        fieldName - 要查找最大值的字段。 仅支持数字字段。
        返回：
        如果对象不存在，或者给定字段的值为null ，则返回null 。否则返回最大值。 确定最大值时，具有null值的对象将被忽略。

      • 总和

        公共数字总和（字符串字段名称）
        计算给定字段的总和。
        指定者：
        sum 在接口中 RealmCollection<E>
        参数：
        fieldName - 要求和的字段。 仅支持数字字段。
        返回：
        总和。 如果对象不存在，或者给定字段的值为null ，则返回0 。计算总和时，具有null值的对象将被忽略。

      • 平均值

        公共双重平均值（ String fieldName）
        返回给定字段的平均值。
        指定者：
        average 在接口中 RealmCollection<E>
        参数：
        fieldName - 计算平均值的字段。 仅支持数字字段。
        返回：
        查询结果中对象之间给定字段的平均值。对于所有类型的数字字段，该值的类型都是 double。如果对象不存在，或者给定字段的值为null ，则返回0 。计算平均值时，具有null值的对象将被忽略。

      • maxDate

        @Nullable public Date maxDate​( String fieldName)
        查找最大日期。
        指定者：
        maxDate 在接口中 RealmCollection<E>
        参数：
        fieldName - 查找最大日期的字段。 如果 fieldName 不是 Date 类型，则会抛出异常。
        返回：
        如果对象不存在，或者给定日期字段的值为null ，则返回null 。否则，返回最大日期。 确定最大日期时，具有null值的对象将被忽略。

      • minDate

        @Nullable public Date minDate​( String fieldName)
        查找最小日期。
        指定者：
        minDate 在接口中 RealmCollection<E>
        参数：
        fieldName - 查找最小日期的字段。如果 fieldName 不是 Date 类型，则会抛出异常。
        返回：
        如果对象不存在，或者给定日期字段的值为null ，则返回null 。 否则，返回最小日期。 确定最小日期时，具有null值的对象将被忽略。

      • deleteAllFromRealm

        public boolean deleteAllFromRealm()
        这将从底层 Realm 以及集合中删除集合中的所有对象。
        指定者：
        deleteAllFromRealm 在接口中 RealmCollection<E>
        返回：
        true 如果删除了对象，则返回false 。

      • isLoaded

        public boolean isLoaded()
        检查collection是否已完成数据加载。
        指定者：
        isLoaded 在接口中 RealmCollection<E>
        返回：
        true 如果数据已加载且可用，则如果仍在加载数据，则为false 。

      • 负载

        公共 boolean load()
        阻止collection，直到所有数据都可用。
        指定者：
        load 在接口中 RealmCollection<E>
        返回：
        true 如果可以成功加载数据，则为false 。

      • contains

        公共布尔包含​（ @Nullable Object对象）
        如果列表在附加到 Realm 时包含指定元素，则返回true 。 该方法将查询原生 Realm 底层storage engine，以快速找到指定的元素。

        如果列表未附加到 Realm，则将执行默认的List.contains(Object)实现。

        指定者：
        contains 在接口中 Collection<E>
        指定者：
        contains 在接口中 List<E>
        指定者：
        contains 在接口中 RealmCollection<E>
        覆盖：
        contains 课堂上 AbstractCollection<E>
        参数：
        object - 要测试其在此列表中是否存在的元素。
        返回：
        true 如果此列表包含指定元素，否则为false 。

      • getRealm

        公共Realm getRealm()
        返回此collection所属的Realm实例。

        不鼓励在返回的实例上调用Closeable.close() ，因为它与在原始 Realm 实例上调用它相同，这可能会导致 Realm 完全关闭，从而使列表失效。

        返回：
        Realm collection所属的实例，如果该collection为非托管，则为null 。
        抛出异常：
        IllegalStateException - 如果 Realm 是DynamicRealm的实例或者Realm已关闭。

      • asFlowable

        public Flowable<RealmList<E>> asFlowable()
        返回一个监控此 RealmList 更改的 Rx Flowable。 订阅时，它将发出当前的 RealmList。 RealmList 将在 RealmList 更新时不断发出 - onComplete将永远不会被调用。

        从 Realm Flowable 发出的项被冻结（请参阅freeze() 。 这意味着它们是不可变的，可以在任何线程上读取。

        Realm Flowables 始终从持有活动 RealmList 的线程中发出项目。 这意味着，如果需要进行进一步处理，建议观察计算调度器上的值：

        list.asFlowable() .observeOn(Schedulers.computation()) .map(rxResults -> doExpensiveWork(rxResults)) .observeOn(AndroidSchedulers.mainThread()) .subscribe( ... );

        如果希望asFlowable()停止发出项目，可以使用first()操作符指示 RxJava 仅发出第一项： 

         
 list.asFlowable()
      .first()
      .subscribe( ... ) // You only get the results once

        返回：
        仅调用onNext的 RxJava Observable。 它永远不会调用onComplete或OnError 。
        抛出异常：
        UnsupportedOperationException - 如果所需的 RxJava 框架不在类路径上，或者相应的 Realm 实例不支持 RxJava。
        另请参阅：
        RxJava 和 Realm

      • asChangesetObservable

        public Observable<CollectionChange<RealmList<E>>> asChangesetObservable()
        返回一个 Rx Observable，用于监控对此 RealmList 的更改。 订阅时，它将发出当前的 RealmList。 对于 RealmList 的每次更新，都将发送由 RealmList 和OrderedCollectionChangeSet组成的对。 首次发出 RealmList 时，变更集将为null 。

        RealmList 将在 RealmList 更新时不断发出 - onComplete将永远不会被调用。

        从 Realm Observables 发出的项被冻结（请参阅freeze() 。 这意味着它们是不可变的，可以在任何线程上读取。

        Realm Observables 始终从持有活动 Realm 的线程中发出项目。 这意味着，如果需要进行进一步处理，建议观察计算调度器上的值：

        list.asChangesetObservable() .observeOn(Schedulers.computation()) .map((rxList, changes) -> doExpensiveWork(rxList, changes)) .observeOn(AndroidSchedulers.mainThread()) .subscribe( ... );

        返回：
        仅调用onNext的 RxJava Observable。 它永远不会调用onComplete或OnError 。
        抛出异常：
        UnsupportedOperationException - 如果所需的 RxJava 框架不在类路径上，或者相应的 Realm 实例不支持 RxJava。
        IllegalStateException - 如果 Realm 不是在 事件循环 线程上打开的。
        另请参阅：
        RxJava 和 Realm

      • addChangeListener

        public void addChangeListener​(OrderedRealmCollectionChangeListener<RealmList<E>> listener)
        向此RealmList添加变更侦听器。

        注册变更侦听器不会阻止底层 RealmList 被垃圾收集。 如果对 RealmList 进行垃圾回收，则将停止触发变更侦听器。 为避免这种情况，请尽可能长时间地保留强引用，例如在类变量中。 

         
 public class MyActivity extends Activity {

     private RealmList<Dog> dogs; // Strong reference to keep listeners alive

     \@Override
     protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       dogs = realm.where(Person.class).findFirst().getDogs();
       dogs.addChangeListener(new OrderedRealmCollectionChangeListener<RealmList<Dog>>() {
           \@Override
           public void onChange(RealmList<Dog> dogs, OrderedCollectionChangeSet changeSet) {
               // React to change
           }
       });
     }
 }
        参数：
        listener - 要通知的变更侦听器。
        抛出异常：
        IllegalArgumentException - 如果变更侦听器为null 。
        IllegalStateException - 如果您尝试从非 事件循环 或IntentService线程添加侦听器。

      • addChangeListener

        public void addChangeListener​(RealmChangeListener<RealmList<E>> listener)
        向此RealmList添加变更侦听器。

        注册变更侦听器不会阻止底层 RealmList 被垃圾收集。 如果对 RealmList 进行垃圾回收，则将停止触发变更侦听器。 为避免这种情况，请尽可能长时间地保留强引用，例如在类变量中。 

         
 public class MyActivity extends Activity {

     private RealmList<Dog> dogs; // Strong reference to keep listeners alive

     \@Override
     protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       dogs = realm.where(Person.class).findFirst().getDogs();
       dogs.addChangeListener(new RealmChangeListener<RealmList<Dog>>() {
           \@Override
           public void onChange(RealmList<Dog> dogs) {
               // React to change
           }
       });
     }
 }
        参数：
        listener - 要通知的变更侦听器。
        抛出异常：
        IllegalArgumentException - 如果变更侦听器为null 。
        IllegalStateException - 如果您尝试从非 事件循环 或IntentService线程添加侦听器。

      • 删除所有变更监听器

        public void removeAllChangeListeners()
        删除所有用户定义的变更侦听器。
        抛出异常：
        IllegalStateException - 如果您尝试从非事件循环线程中删除侦听器。
        另请参阅：
        RealmChangeListener