安装包 io.realm

类 Realm

  • 所有已实现的接口：
    Closeable, AutoCloseable
    public class Realm
extends Object
    Realm 类是对象持久存储的存储和事务管理器。 它负责创建 RealmObject 的实例。 Realm 中的对象可以随时查询和读取。 创建、修改和删除对象必须在事务内部完成。 请参阅 executeTransaction(Transaction)

    事务确保多个实例（在多个线程上）可以访问处于一致状态的相同对象，并具有完整的 ACID 保证。

    请务必记住在使用 Realm 实例完成后调用Closeable.close()方法。 否则，可能会导致OutOfMemoryError ，因为无法释放原生资源。

    Realm 实例不能跨不同线程使用。 这意味着您必须在要使用 Realm 的每个线程上打开一个实例。 Realm 实例使用引用计数按线程自动缓存，因此只要引用计数未达到零，调用getInstance(RealmConfiguration)将仅返回缓存的 Realm，并且应被视为轻量级操作。

    对于用户界面线程，这意味着打开和关闭Realms应发生在onCreate/onDestroy或onStart/onStop中。

    Realm 实例使用Handler机制跨线程协调其状态。 这也意味着没有Looper的线程上的 Realm 实例无法接收更新，除非手动调用refresh() 。

    在 Android 活动中使用 Realm 的标准模式如下所示： 

     public class RealmApplication extends Application {

     \@Override
     public void onCreate() {
         super.onCreate();

         // The Realm file will be located in package's "files" directory.
         RealmConfiguration realmConfig = new RealmConfiguration.Builder(this).build();
         Realm.setDefaultConfiguration(realmConfig);
     }
 }

 public class RealmActivity extends Activity {

   private Realm realm;

   \@Override
   protected void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.layout_main);
     realm = Realm.getDefaultInstance();
   }

   \@Override
   protected void onDestroy() {
     super.onDestroy();
     realm.close();
   }
 }

    Realm 支持最大包含 16 MB 的字符串和字节字段。

    另请参阅：
    ACID ，使用 Realm 的示例

    • 字段详细信息

      • ENCRYPTION_KEY_LENGTH

        public static final int ENCRYPTION_KEY_LENGTH
        用于加密 Realm 数据的加密密钥所需的长度。
        另请参阅：
        常量字段值

      • WRITE_EXECUTOR

        public static final io.realm.internal.async.RealmThreadPoolExecutor WRITE_EXECUTOR
        用于写入操作的线程池执行程序 — 由于写入无法并行化，因此仅需要一个线程。

      • SharedRealm

        public io.realm.internal.OsSharedRealm sharedRealm

      • objectContext

        public static final io.realm.BaseRealm.ThreadLocalRealmObjectContext objectContext

    • 方法详细信息

      • asFlowable

        public Flowable<Realm> asFlowable()
        返回一个监控此 Realm 变更的 RxJava Flowable。 订阅时，它将发出当前状态。 随着 Realm 更新，项目将不断发出 - onComplete将永远不会被调用。

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

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

        realm.asFlowable() .observeOn(Schedulers.computation()) .map(rxRealm -> doExpensiveWork(rxRealm)) .observeOn(AndroidSchedulers.mainThread()) .subscribe( ... );

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

         
 realm.asFlowable().first().subscribe( ... ); // You only get the results once
        返回：
        仅调用onNext的 RxJava Observable。 它永远不会调用onComplete或OnError 。
        另请参阅：
        RxJava 和 Realm

      • isEmpty

        public boolean isEmpty()
        检查此Realm是否包含任何对象。
        返回：
        true 如果为空，则为 @{code false} 否则。

      • init

        public static void init​(Context context)
        初始化 Realm 库并创建可供使用的默认配置。 在与任何其他 Realm API 交互之前，必须先调用此方法。

        一个好地方是在Application子类中： 

         
 public class MyApplication extends Application {
   \@Override
   public void onCreate() {
     super.onCreate();
     Realm.init(this);
   }
 }

        请记住将其注册到AndroidManifest.xml文件中： 

         
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="io.realm.example">
 <application android:name=".MyApplication">
   // ...
 </application>
 </manifest>
        参数：
        context — 应用程序上下文。
        抛出异常：
        IllegalArgumentException - 如果提供了null上下文。
        IllegalStateException - 如果无法找到Context.getFilesDir() 。
        另请参阅：
        getDefaultInstance()

      • init

        public static void init​(Context context,
                        String userAgent)
        初始化 Realm 库并创建可供使用的默认配置。 在与任何其他 Realm API 交互之前，必须先调用此方法。

        一个好地方是在Application子类中： 

         
 public class MyApplication extends Application {
   \@Override
   public void onCreate() {
     super.onCreate();
     Realm.init(this, "MyApp/" + BuildConfig.VERSION_NAME);
   }
 }

        请记住将其注册到AndroidManifest.xml文件中： 

         
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="io.realm.example">
 <application android:name=".MyApplication">
   // ...
 </application>
 </manifest>
        参数：
        context — 应用程序上下文。
        userAgent — 可选的用户定义字符串，在建立会话时将作为User-Agent标头的一部分发送到 Realm 对象服务器。 非同步 Realm 不会使用此设置。
        抛出异常：
        IllegalArgumentException - 如果提供了null上下文或用户代理。
        IllegalStateException - 如果无法找到Context.getFilesDir() 。
        另请参阅：
        getDefaultInstance()

      • createObject

        public <E extends RealmModel> E createObject​(Class<E> clazz,
                                             @Nullable
                                             Object primaryKeyValue)
        实例化一个新对象并将其添加到已设置主键值的 Realm 中。

        如果该值违反了主键约束，则不会添加任何对象，并会抛出RealmException 。 模型类提供的主键默认值将被忽略。

        参数：
        clazz — 要创建的对象的类。
        primaryKeyValue - 主键字段的值。
        返回：
        新对象。
        抛出异常：
        RealmException - 如果由于主键无效而无法创建对象。
        IllegalStateException - 如果模型类没有定义主键。
        IllegalArgumentException - 如果primaryKeyValue没有可以转换为预期值的值。

      • createEmbeddedObject

        public <E extends RealmModel> E createEmbeddedObject​(Class<E> clazz,
                                                     RealmModel parentObject,
                                                     String parentProperty)
        实例化一个新的嵌入式对象并将其添加到 Realm 中。

        此方法只应用于创建标记为嵌入式的类型的对象。

        参数：
        clazz — 要创建的对象的类。 它必须标有\@RealmClass(embedded = true) 。
        parentObject - 应包含对嵌入式对象的引用的父对象。
        parentProperty - 父类中保存引用的属性。 如果父属性是列表，则嵌入式对象将被添加到该列表的末尾。
        返回：
        新创建的嵌入式对象。
        抛出异常：
        IllegalArgumentException - 如果clazz不是嵌入式类，或者父类中的属性无法保存适当类型的对象。
        另请参阅：
        RealmClass.embedded()

      • copyToRealm

        public <E extends RealmModel> E copyToRealm​(E object,
                                            ImportFlag... flags)
        将 RealmObject 复制到 Realm 实例并返回副本。 对原始 RealmObject 的任何进一步更改都不会反映在 Realm 副本中。 这是一个深复制，因此所有引用的对象都将被复制。 已在此 Realm 中的对象将被忽略。

        请注意，复制对象将复制所有字段值。 如果未提供，则此对象和子对象中任何未设置的字段都将设置为其默认值。

        参数：
        object - 要复制到 Realm 的RealmObject 。
        flags - 修改将数据插入到 Realm 的行为的任何标志。
        返回：
        一个托管 RealmObject，其属性由 Realm 支持。
        抛出异常：
        IllegalArgumentException - 如果对象为null或属于不同线程中的 Realm 实例。

      • copyToRealmOrUpdate

        public <E extends RealmModel> E copyToRealmOrUpdate​(E object,
                                                    ImportFlag... flags)
        更新由同一PrimaryKey标识的现有 RealmObject；如果找不到现有对象，则创建新副本。 这是深度复制或更新，即所有引用的对象都将被复制或更新。

        请注意，复制对象将复制所有字段值。 如果未提供，则对象和子对象中任何未设置的字段都将设置为其默认值。

        参数：
        object - RealmObject进行复制或更新。
        flags - 修改将数据插入到 Realm 的行为的任何标志。
        返回：
        新的或更新的 RealmObject 及其由 Realm 支持的所有属性。
        抛出异常：
        IllegalArgumentException - 如果对象为null或未定义主键，或者属于不同线程中的 Realm 实例。
        另请参阅：
        copyToRealm(RealmModel, ImportFlag...)

      • copyToRealm

        public <E extends RealmModel> List<E> copyToRealm​(Iterable<E> objects,
                                                  ImportFlag... flags)
        将 RealmObject 集合复制到 Realm 实例并返回其副本。 对原始 RealmObject 的任何进一步更改都不会反映在 Realm 副本中。 这是深度复制，即所有引用的对象都将被复制。 已在此 Realm 中的对象将被忽略。

        请注意，复制对象将复制所有字段值。 如果未提供，则对象和子对象中任何未设置的字段都将设置为其默认值。

        参数：
        objects - 要复制到 Realm 的 RealmObject。
        flags - 修改将数据插入到 Realm 的行为的任何标志。
        返回：
        转换后的 RealmObject 列表，所有这些对象的属性均由 Realm 托管。
        抛出异常：
        RealmException - 如果已将任何对象添加到 Realm。
        IllegalArgumentException - 如果输入collection中的任何元素为null 。

      • insert

        public void insert​(Collection<? extends RealmModel> objects)
        插入非托管 RealmObject 的列表。 这通常比copyToRealm(Iterable, ImportFlag...)更快，因为它不返回插入的元素，而是执行最少的分配和检查。 插入后，对原始对象的任何更改都不会保留。

        请注意：

        • 我们不会检查提供的对象是否已经托管，因此插入托管对象可能会重复该对象。 仅当对象没有主键时才会发生复制。 具有主键的对象永远不会重复。
        • 我们不会为每个元素创建（也不会返回）托管的RealmObject
        • 复制对象将复制所有字段值。 如果未提供，则对象和子对象中任何未设置的字段都将设置为其默认值

        如果您希望返回托管RealmObject ，请使用copyToRealm(Iterable, ImportFlag...) ，否则，如果您有大量对象，此方法通常速度更快。

        参数：
        objects — 要插入的 RealmObject。
        抛出异常：
        IllegalStateException - 如果相应的 Realm 已关闭、从不正确的线程调用或不在事务中调用。

      • insert

        public void insert​(RealmModel object)
        插入非托管 RealmObject。 这通常比copyToRealm(RealmModel, ImportFlag...)更快，因为它不返回插入的元素，而是执行最少的分配和检查。 插入后，对原始对象的任何更改都不会保留。

        请注意：

        • 我们不会检查提供的对象是否已经托管，因此插入托管对象可能会重复该对象。 仅当对象没有主键时才会发生复制。 具有主键的对象永远不会重复。
        • 我们不会为每个元素创建（也不会返回）托管的RealmObject
        • 复制对象将复制所有字段值。 如果未提供，则对象和子对象中任何未设置的字段都将设置为其默认值

        如果您希望返回托管RealmObject ，请使用copyToRealm(RealmModel, ImportFlag...) ，否则，如果您有大量对象，此方法通常速度更快。

        参数：
        object — 要插入的 RealmObject。
        抛出异常：
        IllegalStateException - 如果相应的 Realm 已关闭、从不正确的线程调用或不在事务中调用。
        RealmPrimaryKeyConstraintException - 如果插入了两个具有相同主键的对象，或者主键值已存在于 Realm 中。

      • insertOrUpdate

        public void insertOrUpdate​(Collection<? extends RealmModel> objects)
        插入或更新非托管 RealmObject 列表。 这通常比copyToRealmOrUpdate(Iterable, ImportFlag...)更快，因为它不返回插入的元素，而是执行最少的分配和检查。 插入后，对原始对象的任何更改都不会保留。

        请注意：

        • 我们不会检查提供的对象是否已经托管，因此插入托管对象可能会重复该对象。 仅当对象没有主键时才会发生复制。 具有主键的对象永远不会重复。
        • 我们不会为每个元素创建（也不会返回）托管的RealmObject
        • 复制对象将复制所有字段值。 如果未提供，则对象和子对象中任何未设置的字段都将设置为其默认值

        如果您希望返回托管RealmObject ，请使用copyToRealm(Iterable, ImportFlag...) ，否则，如果您有大量对象，此方法通常速度更快。

        参数：
        objects — 要插入的 RealmObject。
        抛出异常：
        IllegalStateException - 如果相应的 Realm 已关闭、从不正确的线程调用或不在事务中调用。
        RealmPrimaryKeyConstraintException - 如果插入了两个具有相同主键的对象，或者主键值已存在于 Realm 中。

      • insertOrUpdate

        public void insertOrUpdate​(RealmModel object)
        插入或更新非托管 RealmObject。 这通常比copyToRealmOrUpdate(RealmModel, ImportFlag...)更快，因为它不返回插入的元素，而是执行最少的分配和检查。 插入后，对原始对象的任何更改都不会保留。

        请注意：

        • 我们不会检查提供的对象是否已经托管，因此插入托管对象可能会重复该对象。 仅当对象没有主键时才会发生复制。 具有主键的对象永远不会重复。
        • 我们不会为每个元素创建（也不会返回）托管的RealmObject
        • 复制对象将复制所有字段值。 如果未提供，则对象和子对象中任何未设置的字段都将设置为其默认值

        如果您希望返回托管RealmObject ，请使用copyToRealm(RealmModel, ImportFlag...) ，否则，如果您有大量对象，此方法通常速度更快。

        参数：
        object — 要插入的 RealmObject。
        抛出异常：
        IllegalStateException - 如果相应的 Realm 已关闭、从不正确的线程调用或不在事务中调用。

      • copyToRealmOrUpdate

        public <E extends RealmModel> List<E> copyToRealmOrUpdate​(Iterable<E> objects,
                                                          ImportFlag... flags)
        更新由PrimaryKey标识的现有 RealmObject 列表，如果找不到现有对象，则创建新副本。 这是深度复制或更新，即所有引用的对象都将被复制或更新。

        请注意，复制对象将复制所有字段值。 如果未提供，则对象和子对象中任何未设置的字段都将设置为其默认值。

        参数：
        objects - 要更新或复制到 Realm 中的对象列表。
        flags - 修改将数据插入到 Realm 的行为的任何标志。
        返回：
        所有新的或更新的 RealmObject 的列表。
        抛出异常：
        IllegalArgumentException - 如果 RealmObject 为null或未定义主键。
        另请参阅：
        copyToRealm(Iterable, ImportFlag...)

      • copyFromRealm

        public <E extends RealmModel> List<E> copyFromRealm​(Iterable<E> realmObjects)
        为已持久化的 RealmObject 创建非托管内存中副本。 这是一个深度复制，将复制所有引用的对象。

        复制的对象均会与 Realm 分离，并且将不再自动更新。 这意味着复制的对象可能包含不再与其他托管 Realm 对象一致的数据。

        *警告*：对复制对象的任何更改都可以使用copyToRealmOrUpdate(RealmModel, ImportFlag...)合并回 Realm 中，但所有字段都将被覆盖，而不仅仅是已更改的字段。 这包括对其他对象的引用，并且可能会覆盖其他线程所做的更改。 可以使用ImportFlag修改此行为。

        类型参数：
        E - 对象类型。
        参数：
        realmObjects — 要复制的 RealmObject。
        返回：
        托管 RealmObjects 的内存中分离副本。
        抛出异常：
        IllegalArgumentException - 如果 RealmObject 无法再访问或其为DynamicRealmObject 。
        另请参阅：
        copyToRealmOrUpdate(Iterable, ImportFlag...)

      • copyFromRealm

        public <E extends RealmModel> List<E> copyFromRealm​(Iterable<E> realmObjects,
                                                    int maxDepth)
        为已持久化的 RealmObject 创建非托管内存中副本。 这是深度复制，可将所有引用的对象复制到定义的深度。

        复制的对象均会与 Realm 分离，并且将不再自动更新。 这意味着复制的对象可能包含不再与其他托管 Realm 对象一致的数据。

        *警告*：对复制对象的任何更改都可以使用copyToRealmOrUpdate(Iterable, ImportFlag...)合并回 Realm 中，但所有字段都将被覆盖，而不仅仅是已更改的字段。 这包括对其他对象的引用，即使它们可能由于到达null 而处于maxDepth 状态。这也可能会覆盖其他线程所做的更改。 可以使用ImportFlag修改此行为。

        类型参数：
        E - 对象类型。
        参数：
        realmObjects — 要复制的 RealmObject。
        maxDepth - 深层复制的限制。 此深度之后的所有引用都将为null 。 起始深度为0 。
        返回：
        RealmObjects 的内存中分离副本。
        抛出异常：
        IllegalArgumentException — 如果为maxDepth < 0 ，则 RealmObject 不可再访问或是一个DynamicRealmObject 。
        另请参阅：
        copyToRealmOrUpdate(Iterable, ImportFlag...)

      • copyFromRealm

        public <E extends RealmModel> E copyFromRealm​(E realmObject)
        制作已持久化RealmObject的非托管内存中副本。 这是一个深度复制，将复制所有引用的对象。

        复制的对象均已与 Realm 分离，并且将不再自动更新。 这意味着复制的对象可能包含不再与其他托管 Realm 对象一致的数据。

        *警告*：对复制对象的任何更改都可以使用copyToRealmOrUpdate(RealmModel, ImportFlag...)合并回 Realm 中，但所有字段都将被覆盖，而不仅仅是已更改的字段。 这包括对其他对象的引用，并且可能会覆盖其他线程所做的更改。 可以使用ImportFlag修改此行为。

        类型参数：
        E - 对象类型。
        参数：
        realmObject - 要复制的RealmObject 。
        返回：
        托管RealmObject的内存中分离副本。
        抛出异常：
        IllegalArgumentException - 如果 RealmObject 无法再访问或其为DynamicRealmObject 。
        另请参阅：
        copyToRealmOrUpdate(RealmModel, ImportFlag...)

      • copyFromRealm

        public <E extends RealmModel> E copyFromRealm​(E realmObject,
                                              int maxDepth)
        制作已持久化RealmObject的非托管内存中副本。 这是深度复制，可将所有引用的对象复制到定义的深度。

        复制的对象均已与 Realm 分离，并且将不再自动更新。 这意味着复制的对象可能包含不再与其他托管 Realm 对象一致的数据。

        *警告*：对复制对象的任何更改都可以使用copyToRealmOrUpdate(RealmModel, ImportFlag...)合并回 Realm 中，但所有字段都将被覆盖，而不仅仅是已更改的字段。 这包括对其他对象的引用，即使它们可能由于到达null 而处于maxDepth 状态。这也可能会覆盖其他线程所做的更改。 可以使用ImportFlag修改此行为。

        类型参数：
        E - 对象类型。
        参数：
        realmObject - 要复制的RealmObject 。
        maxDepth - 深层复制的限制。 此深度之后的所有引用都将为null 。 起始深度为0 。
        返回：
        托管RealmObject的内存中分离副本。
        抛出异常：
        IllegalArgumentException — 如果为maxDepth < 0 ，则 RealmObject 不可再访问或是一个DynamicRealmObject 。
        另请参阅：
        copyToRealmOrUpdate(RealmModel, ImportFlag...)

      • WHERE

        public <E extends RealmModel> RealmQuery<E> where​(Class<E> clazz)
        返回类型化 RealmQuery，可用于查询该类型的特定对象
        参数：
        clazz - 要查询的对象的类。
        返回：
        类型化 RealmQuery，可用于查询该类型的特定对象。
        另请参阅：
        RealmQuery

      • 删除所有变更监听器

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

      • 删除

        public void delete​(Class<? extends RealmModel> clazz)
        从 Realm 中删除指定类的所有对象。
        参数：
        clazz - 应删除对象的类。
        抛出异常：
        IllegalStateException - 如果 Realm 已关闭或从不正确的线程调用。

      • deleteRealm

        public static boolean deleteRealm​(RealmConfiguration configuration)
        从文件系统中删除 Realm 文件以及由给定RealmConfiguration指定的相关临时文件。 带有“.lock”的临时文件 扩展不会被删除。

        在调用此方法之前，必须关闭所有 Realm 实例。

        警告：对于同步 Realm，即使所有用户控制的 Realm 实例都已关闭，背景线程上的内部 Realm 实例也有可能未关闭。这将产生一个IllegalStateException 。 请参阅问题 https://github.com/realm/realm-java/issues/5416 。

        参数：
        configuration - 一个RealmConfiguration 。
        返回：
        false 如果无法删除 Realm 文件。 临时文件删除失败不会影响返回值。 所有失败的文件删除操作都将被记录。
        抛出异常：
        IllegalStateException - 如果有在其他线程或其他进程上打开的 Realm 实例。

      • compactRealm

        public static boolean compactRealm​(RealmConfiguration configuration)
        压缩 Realm 文件。 Realm 文件通常包含可用/未使用的空间。 此方法会删除此可用空间，从而减小文件大小。 Realm 文件中的对象保持不变。

        调用此方法之前必须关闭文件，否则将返回false 。
        文件系统应具有至少可容纳 Realm 文件副本的可用空间。
        如果任何文件操作失败，Realm 文件将保持不变。

        参数：
        configuration - 指向 Realm 文件的RealmConfiguration 。
        返回：
        true 如果成功，如果任何文件操作失败，则为false 。

      • 冻结

        公共Realm冻结（）
        返回当前 Realm 的冻结快照。可以从任何线程读取和查询此 Realm，而不会抛出IllegalStateException 。 冻结的 Realm 有自己的生命周期，可以通过调用Closeable.close()来关闭，但完全关闭生成冻结副本的 Realm 也会关闭冻结的 Realm。

        可以正常查询冻结数据，但尝试以任何方式更改数据或尝试注册任何侦听器都会抛出IllegalStateException 。

        注意：保持大量不同版本的 Realm 活动可能会对 Realm 的文件大小产生负面影响。 为了避免这种情况，可以设置RealmConfiguration.Builder.maxNumberOfActiveVersions(long) 。

        返回：
        此 Realm 的冻结副本。

      • getDefaultModule

        @Nullable
public static Object getDefaultModule()
        返回默认 Realm 模块。 该模块包含当前项目中的所有 Realm 类，但不包括来自库或项目依赖项的类。 其中的 Realm 类应使用自己的模块公开。
        返回：
        默认 Realm 模块，如果默认模块不存在，则为null 。
        抛出异常：
        RealmException - 如果无法创建该模块的实例。
        另请参阅：
        RealmConfiguration.Builder.modules(Object, Object...)

      • getGlobalInstanceCount

        public static int getGlobalInstanceCount​(RealmConfiguration configuration)
        返回当前进程中使用此配置的所有线程中当前打开的 Realm 实例数。 这包括动态 Realm 和普通 Realm。
        参数：
        configuration — Realm 的RealmConfiguration 。
        返回：
        所有线程中打开的 Realm 实例数。

      • getLocalInstanceCount

        public static int getLocalInstanceCount​(RealmConfiguration configuration)
        返回调用此方法的线程上当前打开的 Realm 实例数。 这包括动态 Realm 和普通 Realm。
        参数：
        configuration — Realm 的RealmConfiguration 。
        返回：
        调用者线程上打开的 Realm 实例数。

      • setAutoRefresh

        public void setAutoRefresh​(boolean autoRefresh)
        设置 Realm 实例的自动刷新状态。

        自动刷新功能可以在对另一个线程中作用于同一文件的 Realm 上执行提交时自动更新当前 Realm 实例及其所有派生对象（RealmResults 和 RealmObject 实例）。 仅当 Realm 实例位于启用了Looper的线程上时，此功能才可用。

        参数：
        autoRefresh - true将打开自动刷新， false将关闭自动刷新。
        抛出异常：
        IllegalStateException - 如果从非 Looper 线程调用。

      • isAutoRefresh

        public boolean isAutoRefresh()
        检索 Realm 实例的自动刷新状态。
        返回：
        自动刷新状态。

      • isInTransaction

        public boolean isInTransaction()
        检查 Realm 当前是否处于事务中。
        返回：
        true 如果在事务中，则为false ，否则为 。

      • writeCopyTo

        public void writeCopyTo​(File destination)
        将 Realm 的压缩副本写入给定的目标文件。 生成的文件可用作初始数据集，以在其他设备中引导本地或同步的 Realm。

        目标文件不能是已经存在的文件。

        请注意，如果这是从事务内部调用的，则它会写入当前数据，而不是提交最后一个事务时的数据。

        参数：
        destination - 要保存 Realm 的文件。
        抛出异常：
        IllegalArgumentException - 如果目标参数为 null。
        RealmFileException - 如果在访问底层 Realm 文件或写入目标文件时发生错误。
        IllegalStateException - 如果从用户界面线程调用。
        IllegalStateException - 如果并非所有客户端更改都集成在服务器中。

      • writeEncryptedCopyTo

        public void writeEncryptedCopyTo​(File destination,
                                 byte[] key)
        将 Realm 的压缩和加密副本写入给定的目标文件。 生成的文件可用作初始数据集，以在其他设备中引导本地或同步的 Realm。

        目标文件不能是已经存在的文件。

        请注意，如果这是从事务内部调用的，则它会写入当前数据，而不是提交最后一个事务时的数据。

        参数：
        destination - 要保存 Realm 的文件。
        key - 64 字节加密密钥。
        抛出异常：
        IllegalArgumentException - 如果目标参数为 null。
        RealmFileException - 如果在访问底层 Realm 文件或写入目标文件时发生错误。
        IllegalStateException - 如果从用户界面线程调用。
        IllegalStateException - 如果并非所有客户端更改都集成在服务器中。

      • waitForChange

        @Deprecated public boolean waitForChange()
        已弃用。
        此方法将在下一个主要版本中删除。
        阻塞当前线程，直到 Realm 有新的更改可用或从另一个线程调用stopWaitForChange() 。 调用 stopWaitForChange 后，以后对此方法的所有调用都将立即返回 false。
        返回：
        true 如果 Realm 已更新到最新版本，则false如果通过调用 stopWaitForChange 取消。
        抛出异常：
        IllegalStateException - 如果从事务中或 Looper 线程中调用此方法。
        RealmMigrationNeededException - 如果最新版本包含不兼容的模式更改，则在键入Realm时执行。

      • stopWaitForChange

        @Deprecated
public void stopWaitForChange()
        已弃用。
        该方法将在下一个主要版本中删除
        使任何当前的waitForChange()立即返回false 。 调用此方法后，以后对 waitForChange 的所有调用都将立即返回false 。

        此方法具有线程安全性，_只能_从调用 waitForChange 的线程以外的其他线程调用。

        抛出异常：
        IllegalStateException - 如果Realm实例已关闭。

      • beginTransaction

        public void beginTransaction()
        启动必须由BaseRealm.commitTransaction()关闭或由BaseRealm.cancelTransaction()中止的事务。 事务用于以原子方式创建、更新和删除 Realm 中的对象。

        在开始事务之前，Realm 实例会更新到最新版本，以包含其他线程的所有更改。 此更新不会触发任何已注册的RealmChangeListener 。

        因此，建议从事务内部查询应修改的项目。 否则，在事务开始时，可能存在部分结果被删除或修改的风险。 

         
 // Don't do this
 RealmResults<Person> persons = realm.where(Person.class).findAll();
 realm.beginTransaction();
 persons.first().setName("John");
 realm.commitTransaction();

 // Do this instead
 realm.beginTransaction();
 RealmResults<Person> persons = realm.where(Person.class).findAll();
 persons.first().setName("John");
 realm.commitTransaction();

        注意：无法嵌套事务。 如果在事务中启动事务，则会引发异常。

        抛出异常：
        RealmMigrationNeededException - 如果最新版本包含不兼容的模式更改，则在键入Realm时执行。

      • commitTransaction

        public void commitTransaction()
        自BaseRealm.beginTransaction()以来的所有更改都会持久保存到磁盘，并且 Realm 恢复为只读。 系统会发送一个事件，通知所有其他 Realm 实例已发生更改。 收到该事件后，其他 Realm 将更新其对象和RealmResults以反映本次提交的更改。

      • cancelTransaction

        public void cancelTransaction()
        恢复在当前写事务（write transaction）中进行的所有写入（创建、更新或删除的对象）并结束事务。

        Realm 将恢复为只读。

        不在事务中时调用此方法会引发异常。

      • IsFrozen

        public boolean isFrozen()
        返回此 Realm 是否被冻结。
        返回：
        true 如果 Realm 已冻结，则为false ，否则为 。
        另请参阅：
        freeze()

      • getNumberOfActiveVersions

        public long getNumberOfActiveVersions()
        返回此 Realm 当前持有的活动版本的当前数量。

        拥有大量的活动版本会对 Realm 文件的大小产生负面影响。 请参阅常见问题解答以了解更多信息。

        返回：
        Realm 当前持有的活动版本数。
        另请参阅：
        RealmConfiguration.Builder.maxNumberOfActiveVersions(long)

      • getPath

        public String getPath()
        返回此 Realm 在磁盘上持久保存的规范路径。
        返回：
        Realm 文件的规范路径。
        另请参阅：
        File.getCanonicalPath()

      • getVersion

        public long getVersion()
        返回此 Realm 的模式版本。
        返回：
        支持此 Realm 的 Realm 文件的模式版本。

      • 关闭

        public void close()
        关闭 Realm 实例及其所有资源。

        请务必记住在使用完 Realm 实例后关闭 Realm 实例，以免泄漏内存、文件描述符或 Realm 文件大小增长不正常。

        指定者：
        close 在接口中 AutoCloseable
        指定者：
        close 在接口中 Closeable
        抛出异常：
        IllegalStateException - 如果尝试从另一个线程关闭。

      • isClosed

        public boolean isClosed()
        检查Realm实例是否已关闭。
        返回：
        true 如果已关闭，则为false 。
        抛出异常：
        IllegalStateException - 如果尝试从另一个线程关闭。

      • getSubscriptions

        public SubscriptionSet getSubscriptions()
        返回与此 Realm 关联的订阅集。 订阅集定义了一组查询，这些查询定义了在此域和服务器之间同步哪些数据。

        此方法仅适用于使用 Flexible Sync 的同步 Realm。

        返回：
        与此 Realm 关联的订阅集。
        抛出异常：
        IllegalStateException - 如果此 Realm 是本地 Realm 或基于分区的同步 Realm。

      • deleteAll

        public void deleteAll()
        删除此 Realm 中的所有对象。
        抛出异常：
        IllegalStateException - 如果 Realm 已关闭或从不正确的线程调用。