安装包 io.realm

RealmQuery<E> 类

  • 类型参数：
    E - 要查询的对象的类。
    public class RealmQuery<E>
extends Object
    RealmQuery 使用构建器模式封装对Realm或RealmResults的查询。 使用findAll()或findFirst()执行查询。

    许多查询函数的输入将字段名称视为字符串。请注意，这不是类型安全的。 如果对 RealmObject 类进行重构，则必须注意不要破坏任何查询。

    Realm是无序的，这意味着不能保证查询 Realm 会按对象插入的顺序返回对象。 如果需要特定顺序，请使用sort(String) （字符串）} 和类似方法。

    RealmQuery 不能在不同线程之间传递。

    大多数时候都能很快得到结果。 但是，从用户界面线程启动大量查询可能会导致丢帧甚至 ANR。 如果要防止这些行为，可以使用将 显式设置为 的 来实例化 Realm。RealmConfigurationRealmConfiguration.Builder.allowQueriesOnUiThread(boolean)false这样，查询将被迫从非用户界面线程启动。 或者，也可以使用findAllAsync()或findFirstAsync() 。

    另请参阅：
    构建者模式、 Realm.where(Class) 、 RealmResults.where()

    • 方法详细信息

      • isValid

        public boolean isValid()
        检查RealmQuery是否仍然有效，即Realm实例尚未关闭以及任何父RealmResults仍然有效。
        返回：
        true 如果仍然有效，则返回false 。

      • IsNull

        public RealmQuery<E> isNull​(String fieldName)
        测试字段是否为null 。 仅适用于可为 null 的字段。

        对于链接查询，如果链接路径的任何部分是null ，则整个路径被视为null ，例如，如果linkField或linkField.stringField为null ，则isNull("linkField.stringField")将被视为null 。

        参数：
        fieldName - 字段名称。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段不可为空。
        另请参阅：
        for further infomation.

      • EqualTo

        public RealmQuery<E> equalTo​(String fieldName,
                             @Nullable
                             String value)
        等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • EqualTo

        public RealmQuery<E> equalTo​(String fieldName,
                             @Nullable
                             String value,
                             Case casing)
        等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        casing - 如何处理大小写。 将其设置为Case.INSENSITIVE仅适用于 Latin-1 字符。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • EqualTo

        public RealmQuery<E> equalTo​(String fieldName,
                             RealmAny value,
                             Case casing)
        等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        casing - 如何处理大小写。 将其设置为Case.INSENSITIVE仅适用于 Latin-1 字符。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • EqualTo

        public RealmQuery<E> equalTo​(String fieldName,
                             @Nullable
                             Decimal128 value)
        等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • EqualTo

        public RealmQuery<E> equalTo​(String fieldName,
                             @Nullable
                             ObjectId value)
        等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • EqualTo

        public RealmQuery<E> equalTo​(String fieldName,
                             @Nullable
                             UUID value)
        等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • EqualTo

        public RealmQuery<E> equalTo​(String fieldName,
                             @Nullable
                             Byte value)
        等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • EqualTo

        public RealmQuery<E> equalTo​(String fieldName,
                             @Nullable
                             byte[] value)
        等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • EqualTo

        public RealmQuery<E> equalTo​(String fieldName,
                             @Nullable
                             Short value)
        等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • EqualTo

        public RealmQuery<E> equalTo​(String fieldName,
                             @Nullable
                             Integer value)
        等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • EqualTo

        public RealmQuery<E> equalTo​(String fieldName,
                             @Nullable
                             Long value)
        等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • EqualTo

        public RealmQuery<E> equalTo​(String fieldName,
                             @Nullable
                             Double value)
        等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • EqualTo

        public RealmQuery<E> equalTo​(String fieldName,
                             @Nullable
                             Float value)
        等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • EqualTo

        public RealmQuery<E> equalTo​(String fieldName,
                             @Nullable
                             Boolean value)
        等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • EqualTo

        public RealmQuery<E> equalTo​(String fieldName,
                             @Nullable
                             Date value)
        等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • EqualTo

        public RealmQuery<E> equalTo​(String fieldName,
                             RealmAny value)
        等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • in

        public RealmQuery<E> in​(String fieldName,
                        @Nullable
                        String[] values)
        相比之下。 这允许您测试对象是否与值数组中的任何值匹配。
        参数：
        fieldName - 要比较的字段。
        values - 要比较的值的数组。 如果提供了null或空数组，则查询永远不会匹配任何结果。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段不是字符串字段。

      • in

        public RealmQuery<E> in​(String fieldName,
                        @Nullable
                        String[] values,
                        Case casing)
        相比之下。 这允许您测试对象是否与值数组中的任何值匹配。
        参数：
        fieldName - 要比较的字段。
        values - 要比较的值的数组。 如果提供了null或空数组，则查询永远不会匹配任何结果。
        casing - 如何处理大小写。 Case.INSENSITIVE仅适用于 Latin-1 字符。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段不是字符串字段。

      • in

        public RealmQuery<E> in​(String fieldName,
                        @Nullable
                        Byte[] values)
        相比之下。 这允许您测试对象是否与值数组中的任何值匹配。
        参数：
        fieldName - 要比较的字段。
        values - 要比较的值的数组。 如果提供了null或空数组，则查询永远不会匹配任何结果。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段不是字节字段。

      • in

        public RealmQuery<E> in​(String fieldName,
                        @Nullable
                        Short[] values)
        相比之下。 这允许您测试对象是否与值数组中的任何值匹配。
        参数：
        fieldName - 要比较的字段。
        values - 要比较的值的数组。 如果提供了null或空数组，则查询永远不会匹配任何结果。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段不是短字段。

      • in

        public RealmQuery<E> in​(String fieldName,
                        @Nullable
                        Integer[] values)
        相比之下。 这允许您测试对象是否与值数组中的任何值匹配。
        参数：
        fieldName - 要比较的字段。
        values - 要比较的值的数组。 如果提供了null或空数组，则查询永远不会匹配任何结果。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段不是整型字段。

      • in

        public RealmQuery<E> in​(String fieldName,
                        @Nullable
                        Long[] values)
        相比之下。 这允许您测试对象是否与值数组中的任何值匹配。
        参数：
        fieldName - 要比较的字段。
        values - 要比较的值的数组。 如果提供了null或空数组，则查询永远不会匹配任何结果。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段不是长整型字段。 空。

      • in

        public RealmQuery<E> in​(String fieldName,
                        @Nullable
                        Double[] values)
        相比之下。 这允许您测试对象是否与值数组中的任何值匹配。
        参数：
        fieldName - 要比较的字段。
        values - 要比较的值的数组。 如果提供了null或空数组，则查询永远不会匹配任何结果。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段不是双精度字段。 空。

      • in

        public RealmQuery<E> in​(String fieldName,
                        @Nullable
                        Float[] values)
        相比之下。 这允许您测试对象是否与值数组中的任何值匹配。
        参数：
        fieldName - 要比较的字段。
        values - 要比较的值的数组。 如果提供了null或空数组，则查询永远不会匹配任何结果。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段不是浮点字段。

      • in

        public RealmQuery<E> in​(String fieldName,
                        @Nullable
                        Boolean[] values)
        相比之下。 这允许您测试对象是否与值数组中的任何值匹配。
        参数：
        fieldName - 要比较的字段。
        values - 要比较的值的数组。 如果提供了null或空数组，则查询永远不会匹配任何结果。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果该字段不是布尔值。 或为空。

      • in

        public RealmQuery<E> in​(String fieldName,
                        @Nullable
                        Date[] values)
        相比之下。 这允许您测试对象是否与值数组中的任何值匹配。
        参数：
        fieldName - 要比较的字段。
        values - 要比较的值的数组。 如果提供了null或空数组，则查询永远不会匹配任何结果。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段不是日期字段。

      • in

        public RealmQuery<E> in​(String fieldName,
                        RealmAny[] values)
        相比之下。 这允许您测试对象是否与值数组中的任何值匹配。
        参数：
        fieldName - 要比较的字段。
        values - 要比较的值的数组。 如果提供了null或空数组，则查询永远不会匹配任何结果。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段不是日期字段。

      • 不等于

        public RealmQuery<E> notEqualTo​(String fieldName,
                                @Nullable
                                String value)
        不等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 不等于

        public RealmQuery<E> notEqualTo​(String fieldName,
                                @Nullable
                                String value,
                                Case casing)
        不等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        casing - 如何处理大小写。 Case.INSENSITIVE仅适用于 Latin-1 字符。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 不等于

        public RealmQuery<E> notEqualTo​(String fieldName,
                                RealmAny value,
                                Case casing)
        不等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        casing - 如何处理大小写。 Case.INSENSITIVE仅适用于 Latin-1 字符。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 不等于

        public RealmQuery<E> notEqualTo​(String fieldName,
                                Decimal128 value)
        不等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 不等于

        public RealmQuery<E> notEqualTo​(String fieldName,
                                ObjectId value)
        不等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 不等于

        public RealmQuery<E> notEqualTo​(String fieldName,
                                UUID value)
        不等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 不等于

        public RealmQuery<E> notEqualTo​(String fieldName,
                                RealmAny value)
        不等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 不等于

        public RealmQuery<E> notEqualTo​(String fieldName,
                                @Nullable
                                Byte value)
        不等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 不等于

        public RealmQuery<E> notEqualTo​(String fieldName,
                                @Nullable
                                byte[] value)
        不等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 不等于

        public RealmQuery<E> notEqualTo​(String fieldName,
                                @Nullable
                                Short value)
        不等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 不等于

        public RealmQuery<E> notEqualTo​(String fieldName,
                                @Nullable
                                Integer value)
        不等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 不等于

        public RealmQuery<E> notEqualTo​(String fieldName,
                                @Nullable
                                Long value)
        不等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 不等于

        public RealmQuery<E> notEqualTo​(String fieldName,
                                @Nullable
                                Double value)
        不等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 不等于

        public RealmQuery<E> notEqualTo​(String fieldName,
                                @Nullable
                                Float value)
        不等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 不等于

        public RealmQuery<E> notEqualTo​(String fieldName,
                                @Nullable
                                Boolean value)
        不等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 不等于

        public RealmQuery<E> notEqualTo​(String fieldName,
                                @Nullable
                                Date value)
        不等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 大于

        public RealmQuery<E> greaterThan​(String fieldName,
                                 int value)
        大于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 大于

        public RealmQuery<E> greaterThan​(String fieldName,
                                 long value)
        大于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 大于

        public RealmQuery<E> greaterThan​(String fieldName,
                                 double value)
        大于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 大于

        public RealmQuery<E> greaterThan​(String fieldName,
                                 float value)
        大于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 大于

        public RealmQuery<E> greaterThan​(String fieldName,
                                 Date value)
        大于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 大于

        public RealmQuery<E> greaterThan​(String fieldName,
                                 RealmAny value)
        大于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 大于

        public RealmQuery<E> greaterThan​(String fieldName,
                                 Decimal128 value)
        大于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 大于

        public RealmQuery<E> greaterThan​(String fieldName,
                                 ObjectId value)
        大于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 大于

        public RealmQuery<E> greaterThan​(String fieldName,
                                 UUID value)
        大于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • moreThanOrEqualTo

        public RealmQuery<E> greaterThanOrEqualTo​(String fieldName,
                                          int value)
        大于或等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • moreThanOrEqualTo

        public RealmQuery<E> greaterThanOrEqualTo​(String fieldName,
                                          long value)
        大于或等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • moreThanOrEqualTo

        public RealmQuery<E> greaterThanOrEqualTo​(String fieldName,
                                          double value)
        大于或等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • moreThanOrEqualTo

        public RealmQuery<E> greaterThanOrEqualTo​(String fieldName,
                                          float value)
        大于或等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配

      • moreThanOrEqualTo

        public RealmQuery<E> greaterThanOrEqualTo​(String fieldName,
                                          Date value)
        大于或等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • moreThanOrEqualTo

        public RealmQuery<E> greaterThanOrEqualTo​(String fieldName,
                                          Decimal128 value)
        大于或等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • moreThanOrEqualTo

        public RealmQuery<E> greaterThanOrEqualTo​(String fieldName,
                                          ObjectId value)
        大于或等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • moreThanOrEqualTo

        public RealmQuery<E> greaterThanOrEqualTo​(String fieldName,
                                          UUID value)
        大于或等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • moreThanOrEqualTo

        public RealmQuery<E> greaterThanOrEqualTo​(String fieldName,
                                          RealmAny value)
        大于或等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 小于

        public RealmQuery<E> lessThan​(String fieldName,
                              int value)
        小于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 小于

        public RealmQuery<E> lessThan​(String fieldName,
                              long value)
        小于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 小于

        public RealmQuery<E> lessThan​(String fieldName,
                              Decimal128 value)
        小于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 小于

        public RealmQuery<E> lessThan​(String fieldName,
                              ObjectId value)
        小于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 小于

        public RealmQuery<E> lessThan​(String fieldName,
                              UUID value)
        小于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 小于

        public RealmQuery<E> lessThan​(String fieldName,
                              double value)
        小于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 小于

        public RealmQuery<E> lessThan​(String fieldName,
                              float value)
        小于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 小于

        public RealmQuery<E> lessThan​(String fieldName,
                              Date value)
        小于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 小于

        public RealmQuery<E> lessThan​(String fieldName,
                              RealmAny value)
        小于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 小于或等于

        public RealmQuery<E> lessThanOrEqualTo​(String fieldName,
                                       int value)
        小于或等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 小于或等于

        public RealmQuery<E> lessThanOrEqualTo​(String fieldName,
                                       long value)
        小于或等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 小于或等于

        public RealmQuery<E> lessThanOrEqualTo​(String fieldName,
                                       Decimal128 value)
        小于或等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 小于或等于

        public RealmQuery<E> lessThanOrEqualTo​(String fieldName,
                                       ObjectId value)
        小于或等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 小于或等于

        public RealmQuery<E> lessThanOrEqualTo​(String fieldName,
                                       UUID value)
        小于或等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 小于或等于

        public RealmQuery<E> lessThanOrEqualTo​(String fieldName,
                                       double value)
        小于或等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 小于或等于

        public RealmQuery<E> lessThanOrEqualTo​(String fieldName,
                                       float value)
        小于或等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 小于或等于

        public RealmQuery<E> lessThanOrEqualTo​(String fieldName,
                                       Date value)
        小于或等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 小于或等于

        public RealmQuery<E> lessThanOrEqualTo​(String fieldName,
                                       RealmAny value)
        小于或等于比较。
        参数：
        fieldName - 要比较的字段。
        value - 要比较的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • between

        public RealmQuery<E> between​(String fieldName,
                             int from,
                             int to)
        介于条件之间。
        参数：
        fieldName - 要比较的字段。
        from - 最低值（含）。
        to - 最高值（含）。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • between

        public RealmQuery<E> between​(String fieldName,
                             long from,
                             long to)
        介于条件之间。
        参数：
        fieldName - 要比较的字段。
        from - 最低值（含）。
        to - 最高值（含）。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • between

        public RealmQuery<E> between​(String fieldName,
                             double from,
                             double to)
        介于条件之间。
        参数：
        fieldName - 要比较的字段。
        from - 最低值（含）。
        to - 最高值（含）。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • between

        public RealmQuery<E> between​(String fieldName,
                             float from,
                             float to)
        介于条件之间。
        参数：
        fieldName - 要比较的字段。
        from - 最低值（含）。
        to - 最高值（含）。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • between

        public RealmQuery<E> between​(String fieldName,
                             Date from,
                             Date to)
        介于条件之间。
        参数：
        fieldName - 要比较的字段。
        from - 最低值（含）。
        to - 最高值（含）。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • between

        public RealmQuery<E> between​(String fieldName,
                             RealmAny from,
                             RealmAny to)
        介于条件之间。
        参数：
        fieldName - 要比较的字段。
        from - 最低值（含）。
        to - 最高值（含）。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • between

        public RealmQuery<E> between​(String fieldName,
                             Decimal128 from,
                             Decimal128 to)
        介于条件之间。
        参数：
        fieldName - 要比较的字段。
        from - 最低值（含）。
        to - 最高值（含）。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • contains

        public RealmQuery<E> contains​(String fieldName,
                              String value)
        条件是字段值包含指定的子字符串。
        参数：
        fieldName - 要比较的字段。
        value - 子字符串。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • contains

        public RealmQuery<E> contains​(String fieldName,
                              RealmAny value)
        条件是字段值包含指定的子字符串。
        参数：
        fieldName - 要比较的字段。
        value - 子字符串。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • contains

        public RealmQuery<E> contains​(String fieldName,
                              String value,
                              Case casing)
        条件是字段值包含指定的子字符串。
        参数：
        fieldName - 要比较的字段。
        value - 子字符串。
        casing - 如何处理大小写。 将其设置为Case.INSENSITIVE仅适用于 Latin-1 字符。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • contains

        public RealmQuery<E> contains​(String fieldName,
                              RealmAny value,
                              Case casing)
        条件是字段值包含指定的子字符串。
        参数：
        fieldName - 要比较的字段。
        value - 子字符串。
        casing - 如何处理大小写。 将其设置为Case.INSENSITIVE仅适用于 Latin-1 字符。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • beginswith

        public RealmQuery<E> beginsWith​(String fieldName,
                                String value)
        条件是字段的值以指定字符串开头。
        参数：
        fieldName - 要比较的字段。
        value - 字符串。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • beginswith

        public RealmQuery<E> beginsWith​(String fieldName,
                                RealmAny value)
        条件是字段的值以指定字符串开头。
        参数：
        fieldName - 要比较的字段。
        value - 字符串。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • beginswith

        public RealmQuery<E> beginsWith​(String fieldName,
                                String value,
                                Case casing)
        条件是字段的值以指定子字符串开头。
        参数：
        fieldName - 要比较的字段。
        value - 子字符串。
        casing - 如何处理大小写。 将其设置为Case.INSENSITIVE仅适用于 Latin-1 字符。
        返回：
        查询对象
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • beginswith

        public RealmQuery<E> beginsWith​(String fieldName,
                                RealmAny value,
                                Case casing)
        条件是字段的值以指定子字符串开头。
        参数：
        fieldName - 要比较的字段。
        value - 子字符串。
        casing - 如何处理大小写。 将其设置为Case.INSENSITIVE仅适用于 Latin-1 字符。
        返回：
        查询对象
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • endswith

        public RealmQuery<E> endsWith​(String fieldName,
                              String value)
        条件是字段的值以指定字符串结尾。
        参数：
        fieldName - 要比较的字段。
        value - 字符串。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • endswith

        public RealmQuery<E> endsWith​(String fieldName,
                              RealmAny value)
        条件是字段的值以指定字符串结尾。
        参数：
        fieldName - 要比较的字段。
        value - 字符串。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • endswith

        public RealmQuery<E> endsWith​(String fieldName,
                              String value,
                              Case casing)
        条件是字段的值以指定子字符串结尾。
        参数：
        fieldName - 要比较的字段。
        value - 子字符串。
        casing - 如何处理大小写。 将其设置为Case.INSENSITIVE仅适用于 Latin-1 字符。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • endswith

        public RealmQuery<E> endsWith​(String fieldName,
                              RealmAny value,
                              Case casing)
        条件是字段的值以指定子字符串结尾。
        参数：
        fieldName - 要比较的字段。
        value - 子字符串。
        casing - 如何处理大小写。 将其设置为Case.INSENSITIVE仅适用于 Latin-1 字符。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 就像

        public RealmQuery<E> like​(String fieldName,
                          String value)
        条件字段的值与指定子字符串匹配，并带有通配符：
        • '*' 匹配 [0, n] unicode 字符
        • '?'匹配单个 unicode 字符。
        参数：
        fieldName - 要比较的字段。
        value — 通配符字符串。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 就像

        public RealmQuery<E> like​(String fieldName,
                          RealmAny value)
        条件字段的值与指定子字符串匹配，并带有通配符：
        • '*' 匹配 [0, n] unicode 字符
        • '?'匹配单个 unicode 字符。
        参数：
        fieldName - 要比较的字段。
        value — 通配符字符串。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 就像

        public RealmQuery<E> like​(String fieldName,
                          String value,
                          Case casing)
        条件字段的值与指定子字符串匹配，并带有通配符：
        • '*' 匹配 [0, n] unicode 字符
        • '?'匹配单个 unicode 字符。
        参数：
        fieldName - 要比较的字段。
        value — 通配符字符串。
        casing - 如何处理大小写。 将其设置为Case.INSENSITIVE仅适用于 Latin-1 字符。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • 就像

        public RealmQuery<E> like​(String fieldName,
                          RealmAny value,
                          Case casing)
        条件字段的值与指定子字符串匹配，并带有通配符：
        • '*' 匹配 [0, n] unicode 字符
        • '?'匹配单个 unicode 字符。
        参数：
        fieldName - 要比较的字段。
        value — 通配符字符串。
        casing - 如何处理大小写。 将其设置为Case.INSENSITIVE仅适用于 Latin-1 字符。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果一个或多个参数与类或字段类型不匹配。

      • beginGroup

        public RealmQuery<E> beginGroup()
        开始对条件进行分组（“左括号”）。 必须通过调用endGroup()来关闭群组。
        返回：
        查询对象。
        另请参阅：
        endGroup()

      • endGroup

        public RealmQuery<E> endGroup()
        结束通过调用beginGroup()打开的条件分组（“右括号”）。
        返回：
        查询对象。
        另请参阅：
        beginGroup()

      • or

        public RealmQuery<E> or()
        逻辑或两个条件。
        返回：
        查询对象。

      • 和

        public RealmQuery<E> and()
        逻辑与两个条件 Realm 会自动在所有声明之间应用逻辑与，因此这只是为了提高可读性的平均值。
        返回：
        查询对象

      • not

        public RealmQuery<E> not()
        否定条件。
        返回：
        查询对象。

      • isEmpty

        public RealmQuery<E> isEmpty​(String fieldName)
        查找被视为“空”的值的条件，即空列表、长度为 0 的字符串或字节数组。
        参数：
        fieldName - 要比较的字段。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效或其类型不是 RealmList、字符串或字节数组。

      • isNotEmpty

        public RealmQuery<E> isNotEmpty​(String fieldName)
        查找被视为“非空”值的条件，即具有非空值的列表、字符串或字节数组。
        参数：
        fieldName - 要比较的字段。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效或其类型不是 RealmList、字符串或字节数组。

      • containsKey

        public RealmQuery<E> containsKey​(String fieldName,
                                 @Nullable
                                 String key)
        条件是该值（如果是字典字段）包含指定的键。
        参数：
        fieldName - 要比较的字段。
        key - 要搜索的键。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效。

      • containsValue

        public RealmQuery<E> containsValue​(String fieldName,
                                   @Nullable
                                   Boolean value)
        如果该值是字段，则条件包含指定值。
        参数：
        fieldName - 要比较的字段。
        value - 要搜索的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效。

      • containsValue

        public RealmQuery<E> containsValue​(String fieldName,
                                   @Nullable
                                   Byte value)
        如果该值是字段，则条件包含指定值。
        参数：
        fieldName - 要比较的字段。
        value - 要搜索的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效。

      • containsValue

        public RealmQuery<E> containsValue​(String fieldName,
                                   @Nullable
                                   Short value)
        如果该值是字段，则条件包含指定值。
        参数：
        fieldName - 要比较的字段。
        value - 要搜索的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效。

      • containsValue

        public RealmQuery<E> containsValue​(String fieldName,
                                   @Nullable
                                   Integer value)
        如果该值是字段，则条件包含指定值。
        参数：
        fieldName - 要比较的字段。
        value - 要搜索的值
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效。

      • containsValue

        public RealmQuery<E> containsValue​(String fieldName,
                                   @Nullable
                                   Long value)
        如果该值是字段，则条件包含指定值。
        参数：
        fieldName - 要比较的字段。
        value - 要搜索的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效。

      • containsValue

        public RealmQuery<E> containsValue​(String fieldName,
                                   @Nullable
                                   Double value)
        如果该值是字段，则条件包含指定值。
        参数：
        fieldName - 要比较的字段。
        value - 要搜索的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效。

      • containsValue

        public RealmQuery<E> containsValue​(String fieldName,
                                   @Nullable
                                   Float value)
        如果该值是字段，则条件包含指定值。
        参数：
        fieldName - 要比较的字段。
        value - 要搜索的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效。

      • containsValue

        public RealmQuery<E> containsValue​(String fieldName,
                                   @Nullable
                                   String value)
        如果该值是字段，则条件包含指定值。
        参数：
        fieldName - 要比较的字段。
        value - 要搜索的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效。

      • containsValue

        public RealmQuery<E> containsValue​(String fieldName,
                                   @Nullable
                                   byte[] value)
        如果该值是字段，则条件包含指定值。
        参数：
        fieldName - 要比较的字段。
        value - 要搜索的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效。

      • containsValue

        public RealmQuery<E> containsValue​(String fieldName,
                                   @Nullable
                                   Date value)
        如果该值是字段，则条件包含指定值。
        参数：
        fieldName - 要比较的字段。
        value - 要搜索的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效。

      • containsValue

        public RealmQuery<E> containsValue​(String fieldName,
                                   @Nullable
                                   Decimal128 value)
        如果该值是字段，则条件包含指定值。
        参数：
        fieldName - 要比较的字段。
        value - 要搜索的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效。

      • containsValue

        public RealmQuery<E> containsValue​(String fieldName,
                                   @Nullable
                                   ObjectId value)
        如果该值是字段，则条件包含指定值。
        参数：
        fieldName - 要比较的字段。
        value - 要搜索的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效。

      • containsValue

        public RealmQuery<E> containsValue​(String fieldName,
                                   @Nullable
                                   UUID value)
        如果该值是字段，则条件包含指定值。
        参数：
        fieldName - 要比较的字段。
        value - 要搜索的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效。

      • containsValue

        public RealmQuery<E> containsValue​(String fieldName,
                                   RealmAny value)
        如果该值是字段，则条件包含指定值。
        参数：
        fieldName - 要比较的字段。
        value - 要搜索的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效。

      • containsValue

        public RealmQuery<E> containsValue​(String fieldName,
                                   RealmModel value)
        如果该值是字段，则条件包含指定值。
        参数：
        fieldName - 要比较的字段。
        value - 要搜索的值。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效。

      • containsEntry

        public RealmQuery<E> containsEntry​(String fieldName,
                                   Map.Entry<String,​?> entry)
        条件是该值（如果是字典字段）包含指定的条目。
        参数：
        fieldName - 要比较的字段。
        entry - 要搜索的条目。
        返回：
        查询对象。
        抛出异常：
        IllegalArgumentException - 如果字段名称无效。

      • 总和

        公共数字总和（字符串字段名称）
        计算给定字段的总和。
        参数：
        fieldName - 要求和的字段。 仅支持数字和 RealmAny 字段。
        返回：
        匹配对象的字段总和。 如果对象不存在，或者给定字段的值为null ，则返回0 。计算总和时，具有null值的对象将被忽略。 应用于 RealmAny 字段时，仅对数值 (Byte/Integer/Integer/Long/Float/Double/Decimal128) 求和，返回类型为Decimal128 。
        抛出异常：
        IllegalArgumentException - 如果字段不是数字类型。
        RealmException - 如果通过RealmConfiguration.Builder.allowQueriesOnUiThread(boolean)选择退出后从用户界面线程调用。

      • 平均值

        公共双重平均值（ String fieldName）
        返回给定字段的平均值。不支持点字段表示法。
        参数：
        fieldName - 计算平均值的字段。 仅支持数字字段。
        返回：
        查询结果中对象之间给定字段的平均值。对于所有类型的数字字段，该值的类型都是 double。如果对象不存在，或者给定字段的值为null ，则返回0 。计算平均值时，具有null值的对象将被忽略。
        抛出异常：
        IllegalArgumentException - 如果字段不是数字类型。
        RealmException - 如果通过RealmConfiguration.Builder.allowQueriesOnUiThread(boolean)选择退出后从用户界面线程调用。

      • averageDecimal128

        @Nullable public Decimal128 averageDecimal128​( String fieldName)
        返回给定字段的平均值。不支持点字段表示法。
        参数：
        fieldName - 计算平均值的字段。 仅支持 Decimal128 字段。对于其他数字类型，请考虑使用average(String) 。
        返回：
        查询结果中对象之间给定字段的平均值。其类型为 Decimal128。 如果对象不存在或都具有null作为给定字段的值，则将返回0 。计算平均值时，具有null值的对象将被忽略。
        抛出异常：
        IllegalArgumentException - 如果字段不是 Decimal128 类型。
        RealmException - 如果通过RealmConfiguration.Builder.allowQueriesOnUiThread(boolean)选择退出后从用户界面线程调用。

      • averageRealmAny

        @Nullable public Decimal128 averageRealmAny​( String fieldName)
        返回给定字段的平均值。不支持点字段表示法。
        参数：
        fieldName - 计算平均值的字段。 仅支持 RealmAny 字段。对于其他类型，请考虑使用average(String) 。
        返回：
        查询结果中对象之间给定字段的平均值。其类型为 Decimal128。 如果对象不存在或都具有null作为给定字段的值，则将返回0 。计算平均值时，具有null值的对象将被忽略。
        抛出异常：
        IllegalArgumentException - 如果字段不是 RealmAny 类型。
        RealmException - 如果通过RealmConfiguration.Builder.allowQueriesOnUiThread(boolean)选择退出后从用户界面线程调用。

      • maximumDate

        @Nullable public Date maximumDate​( String fieldName)
        查找字段的最大值。
        参数：
        fieldName - 字段名称。
        返回：
        如果对象不存在，或者给定日期字段的值为null ，则返回null 。否则，返回最大日期。 确定最大日期时，具有null值的对象将被忽略。
        抛出异常：
        UnsupportedOperationException - 如果查询无效（“语法错误”）。

      • maxRealmAny

        public RealmAny maxRealmAny​( String fieldName)
        查找RealmAny字段的最大值。
        参数：
        fieldName — 包含 RealmAny 值的字段。
        返回：
        如果对象不存在，或者给定 RealmAny 字段的值为null ，则返回RealmAny.Type.NULL 。 否则，将返回 RealmAny 的最大值。 确定 RealmAny 的最大值时，具有null值的对象将被忽略。 有关如何比较 RealmAny 值的更多详细信息，请参阅RealmAny文档。
        抛出异常：
        UnsupportedOperationException - 如果查询无效（“语法错误”）。

      • sort

        public RealmQuery<E> sort​(String fieldName)
        按特定字段名称升序对查询结果进行排序。

        排序目前仅限于“基本拉丁语”、“拉丁语补充”、“拉丁扩展 A”、“拉丁扩展 B”（UTF-8 范围 0-591）中的字符集。 对于其他字符集，排序不起作用。

        参数：
        fieldName - 作为排序依据的字段名称。
        抛出异常：
        IllegalArgumentException - 如果字段名称不存在。
        IllegalStateException - 如果已定义排序顺序。

      • sort

        public RealmQuery<E> sort​(String fieldName,
                          Sort sortOrder)
        按指定字段名称和顺序对查询结果进行排序。

        排序目前仅限于“基本拉丁语”、“拉丁语补充”、“拉丁扩展 A”、“拉丁扩展 B”（UTF-8 范围 0-591）中的字符集。 对于其他字符集，排序不起作用。

        参数：
        fieldName - 作为排序依据的字段名称。
        sortOrder — 如何对结果进行排序。
        抛出异常：
        IllegalArgumentException - 如果字段名称不存在。
        IllegalStateException - 如果已定义排序顺序。

      • sort

        public RealmQuery<E> sort​(String fieldName1,
                          Sort sortOrder1,
                          String fieldName2,
                          Sort sortOrder2)
        按所提供顺序中的特定字段名称对查询结果进行排序。fieldName2仅在fieldName1中的值相等的情况下使用。

        排序目前仅限于“基本拉丁语”、“拉丁语补充”、“拉丁扩展 A”、“拉丁扩展 B”（UTF-8 范围 0-591）中的字符集。 对于其他字符集，排序不起作用。

        参数：
        fieldName1 - 第一个字段名称
        sortOrder1 - 第一个字段的排序顺序
        fieldName2 - 第二个字段名称
        sortOrder2 - 第二个字段的排序顺序
        抛出异常：
        IllegalArgumentException - 如果字段名称不存在。
        IllegalStateException - 如果已定义排序顺序。

      • sort

        public RealmQuery<E> sort​(String[] fieldNames,
                          Sort[] sortOrders)
        按所提供顺序中的特定字段名称对查询结果进行排序。仅当前面的字段值相等时才会使用后面的字段。

        排序目前仅限于“基本拉丁语”、“拉丁语补充”、“拉丁扩展 A”、“拉丁扩展 B”（UTF-8 范围 0-591）中的字符集。 对于其他字符集，排序不起作用。

        参数：
        fieldNames - 作为排序依据的字段名称数组。
        sortOrders - 如何对字段名称进行排序。
        抛出异常：
        IllegalArgumentException - 如果字段名称不存在。
        IllegalStateException - 如果已定义排序顺序。

      • distinct

        public RealmQuery<E> distinct​(String firstFieldName,
                              String... remainingFieldNames)
        选择特定类的一组不同对象。 当给定多个不同字段时，将返回字段中值的所有唯一组合。 如果有多个匹配项，则未定义返回哪个对象。 除非结果已排序，否则将返回第一个对象。
        参数：
        firstFieldName - 查找不同对象时使用的第一个字段名。
        remainingFieldNames - 确定字段值的所有唯一组合时剩余的字段名称。
        抛出异常：
        IllegalArgumentException - 如果字段名称为空或null 、不存在、是不支持的类型或指向链接字段。
        IllegalStateException - 如果已定义不同的字段名称。

      • limit

        public RealmQuery<E> limit​(long limit)
        限制返回的对象数量，以防查询匹配到更多对象。

        请注意，当将此方法与sort(String)和distinct(String, String...)结合使用时，它们将按添加顺序执行，这可能会影响最终结果。

        参数：
        limit - 为&ge; 1的限制。
        抛出异常：
        IllegalArgumentException - 如果提供的limit小于 1。

      • alwaysTrue

        public RealmQuery<E> alwaysTrue()
        该谓词将始终匹配。

      • alwaysFalse

        public RealmQuery<E> alwaysFalse()
        此谓词永远不会匹配，导致查询始终返回 0 个结果。

      • rawPredicate

        public RealmQuery<E> rawPredicate​(String predicate,
                                  Object... arguments)
        使用 Realm Query Language 创建基于文本的谓词。 该谓词可以与其他原始谓词或类型安全谓词结合使用，它接受 Realm 值作为参数。

        原始谓词中使用的类和属性名称可以是 Realm 模型类中定义的名称，也可以是使用RealmClass或RealmField注解定义的内部名称。 如果类名或属性名包含空格，则必须对这些空格进行转义。

        参数在字符串谓词中定义为 $argument_index，其中 $argument_index 是一个十进制整数，用于指定参数在参数列表中的位置。 第一个参数由 $0 引用，第二个参数由 $1 引用，依此类推。

        有关 Realm Query Language 的更详细说明，请参阅这些文档。 

         例子：
 
 RealmQuery<Person> query = realm.where(Person.class);

 // Simple query
 query.rawPredicate("name = 'Jane'");

 // Spaces in property name
 query.rawPredicate("my\ property = 'Jane'");

 // Multiple predicates
 query.rawPredicate("name = 'Jane' OR name = 'John'")

 // Collection queries
 query.rawPredicate("children.@count > 3")
 query.rawPredicate("ALL children.age > 18")

 // Sub queries
 query.rawPredicate("SUBQUERY(children, $child, $child.age > 21 AND $child.gender = 'male').@count > 0");

 // Sort, Distinct, Limit
 query.rawPredicate("name = 'Jane' SORT(lastName ASC) DISTINCT(city) LIMIT(5)");

 // Arguments
 query.rawPredicate("name = $0 AND age > $1", "Jane", 18);
        参数：
        predicate — Realm Query Language 谓词。
        arguments — 谓词的 Realm 值。
        抛出异常：
        IllegalArgumentException - 如果存在语法错误。

      • getRealm

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

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

        返回：
        Realm 此查询所属的实例。
        抛出异常：
        IllegalStateException - 如果 Realm 是DynamicRealm的实例或者Realm已关闭。

      • getDescription

        public String getDescription()
        返回此查询的文本描述。
        返回：
        查询的文本描述。

      • getTypeQueried

        public String getTypeQueried()
        返回正在查询的类型的内部 Realm 名称。
        返回：
        正在查询的 Realm 模型类的内部名称。

      • getQueryPointer

        public long getQueryPointer()
        返回指向底层 C++ 查询的指针。 此方法仅是公开的，因为架构设计选择很难变通，应将其视为内部方法，并且可以在没有警告的情况下进行更改。
        返回：
        指向底层 C++ 查询的指针。

      • findFirstAsync

        public E findFirstAsync()
        与findFirst()类似，但在工作线程上异步运行。 应向返回的RealmObject注册侦听器，以便在查询完成时获取通知。 如果查询的RealmObject发生更改，也会触发已注册的侦听器。 如果RealmObject被删除，则监听器将被调用最后一次，然后停止。 不会重新运行查询。
        返回：
        立即获得一个带有isLoaded() == false的空RealmObject }。 在加载返回对象之前尝试访问该对象上的任何字段都会抛出IllegalStateException 。
        抛出异常：
        IllegalStateException - 如果在非事件循环线程上调用此方法。