Pacote io.realm

Classe RealmObject

  • Todas as interfaces implementadas:
    io.realm.internal.ManageableObject, RealmModel
    Subclasses diretas conhecidas:
    DynamicRealmObject
    public abstract class RealmObject
extends Object
implements RealmModel, io.realm.internal.ManageableObject
    No Realm, você define suas classes RealmObject subclassificando RealmObject e adicionando campos para serem persistidos. Em seguida, você cria seus objetos dentro de um Realm e usa suas subclasses personalizadas em vez de usar a classe RealmObject diretamente.

    Um processador de anotações criará uma classe proxy para sua subclasse RealmObject.

    Os seguintes tipos de dados de campo são aceitos:

    • boolean/Boolean
    • curto/curto
    • int/Integer
    • longo/longo
    • flutuar/flutuar
    • duplo/duplo
    • byte[]
    • String
    • Data
    • UUID
    • org.bson.types.Decimal128
    • org.bson.types.ObjectId
    • Qualquer subclasse de RealmObject
    • Lista de domínios
    • Dicionário Realm

    Os tipos short, int e long são mapeados para long ao armazenar dentro de um Realm.

    A única restrição que um RealmObject tem é que os campos não podem ser finais ou temporários. Qualquer método, bem como campos públicos, são permitidos. Ao fornecer construtores personalizados, um construtor público sem argumentos deve ser declarado.

    Os campos anotados com Ignore não têm essas restrições e não exigem um getter ou setter.

    O Realm criará índices para campos anotados com Index. Isso acelerará as query, mas terá um impacto negativo nas inserções e atualizações.

    Um RealmObject não pode ser passado entre threads diferentes.

    Veja também:
    Realm.createObject(Class), Realm.copyToRealm(RealmModel, ImportFlag...)

    • Detalhes do construtor

      • RealmObject

        público RealmObject()

    • Detalhes do método

      • deleteFromRealm

        public final void deleteFromRealm()
        Exclui o objeto do Realm ao qual está associado no momento.

        Depois que esse método for chamado, o objeto será inválido e qualquer operação (leitura ou gravação) executada nele falhará com uma IllegalStateException.

        Lançamentos:
        IllegalStateException - se o Realm correspondente estiver fechado ou em um thread incorreto.
        Veja também:
        isValid()

      • deleteFromRealm

        public static <E extends RealmModel> void deleteFromRealm​(E object)
        Exclui o objeto do Realm com o qual ele está associado no momento.

        Depois que esse método for chamado, o objeto será inválido e qualquer operação (leitura ou gravação) executada nele falhará com uma IllegalStateException.

        Lançamentos:
        IllegalStateException - se o Realm correspondente estiver fechado ou em um thread incorreto.
        Veja também:
        isValid()

      • é válido

        public final boolean isValid()
        Verifica se o RealmObject ainda é válido para usar, ou seja, o RealmObject não foi excluído nem o Realm foi fechado. Ele sempre retornará true para objetos não gerenciados.

        Note que isto pode ser utilizado para verificar a validade de certas condições como ser null quando observado. 

         
 realm.where(BannerRealm.class).equalTo("type", type).findFirstAsync().asFlowable()
      .filter(result.isLoaded() && result.isValid())
      .first()
        Especificado por:
        isValid na interface io.realm.internal.ManageableObject
        Retorna:
        true se o objeto ainda estiver acessível ou um objeto não gerenciado, false caso contrário.
        Veja também:
        Exemplos de uso do Realm com RxJava

      • é válido

        public static <E extends RealmModel> boolean isValid​(@Nullable
                                                     E object)
        Verifica se o RealmObject ainda é válido para usar, ou seja, o RealmObject não foi excluído nem o Realm foi fechado. Ele sempre retornará true para objetos não gerenciados.
        Parâmetros:
        object - RealmObject para verificar a validade.
        Retorna:
        true se o objeto ainda estiver acessível ou um objeto não gerenciado, false caso contrário.

      • IsFrozen

        public final boolean isFrozen()
        Retorna se este RealmObject está congelado ou não.
        Especificado por:
        isFrozen na interface io.realm.internal.ManageableObject
        Retorna:
        true se o RealmObject estiver congelado, false se não estiver.
        Veja também:
        freeze()

      • congelar

        public final <E extends RealmModel> E freeze()
        Retorna um snapshot congelado deste objeto. A cópia congelada pode ser lida e query de qualquer thread sem lançar um IllegalStateException.

        Congelar um RealmObject também cria um Realm congelado que tem seu próprio ciclo de vida, mas se o Realm que gerou a collection original estiver totalmente fechado (ou seja, todas as instâncias em todos os threads estão fechadas), o Realm e o objeto congelados também serão fechados.

        Objetos congelados podem ser consultados normalmente, mas tentar modificá-los de qualquer forma ou tentar registrar um ouvinte lançará um IllegalStateException .

        Observação: manter um grande número de objetos congelados com diferentes versões vivos pode ter um impacto negativo no tamanho do arquivo do Realm. Para evitar tal situação, é possível definir RealmConfiguration.Builder.maxNumberOfActiveVersions(long).

        Retorna:
        uma cópia congelada deste objeto.
        Lançamentos:
        IllegalStateException - se esse método for chamado de dentro de uma transação de escrita.

      • IsFrozen

        public static <E extends RealmModel> boolean isFrozen​(E object)
        Retorna se este RealmObject está congelado ou não.
        Retorna:
        true se o RealmObject estiver congelado, false se não estiver.
        Veja também:
        freeze()

      • congelar

        public static <E extends RealmModel> E freeze​(E object)
        Retorna um snapshot congelado deste objeto. A cópia congelada pode ser lida e query de qualquer thread sem lançar um IllegalStateException.

        Congelar um RealmObject também cria um Realm congelado que tem seu próprio ciclo de vida, mas se o Realm que gerou a collection original estiver totalmente fechado (ou seja, todas as instâncias em todos os threads estão fechadas), o Realm e o objeto congelados também serão fechados.

        Objetos congelados podem ser consultados normalmente, mas tentar modificá-los de qualquer forma ou tentar registrar um ouvinte lançará um IllegalStateException .

        Observação: manter um grande número de objetos congelados com diferentes versões vivos pode ter um impacto negativo no tamanho do arquivo do Realm. Para evitar tal situação, é possível definir RealmConfiguration.Builder.maxNumberOfActiveVersions(long).

        Retorna:
        uma cópia congelada deste objeto.
        Lançamentos:
        IllegalStateException - se esse método for chamado de dentro de uma transação de escrita.

      • isLoaded

        public final boolean isLoaded()
        Verifica se a query usada para localizar este RealmObject foi concluída.

        Métodos assíncronos como RealmQuery.findFirstAsync() retornam um RealmObject que representa o resultado futuro do RealmQuery. Pode ser considerado semelhante a um Future a este respeito.

        Depois que isLoaded() retorna true, o objeto representa o resultado da query mesmo que a query não tenha encontrado nenhum objeto que corresponda aos parâmetros da query. Neste caso, o RealmObject se tornará um objeto "nulo".

        Objeto "nulo" representam null. Uma exceção é lançada se qualquer acessador for chamado, portanto, é importante verificar também isValid() antes de chamar qualquer método. Um padrão comum é: 

         
 Person person = realm.where(Person.class).findFirstAsync();
 person.isLoaded(); // == false
 person.addChangeListener(new RealmChangeListener() {
      \@Override
      public void onChange(Person person) {
          person.isLoaded(); // Always true here
          if (person.isValid()) {
              // It is safe to access the person.
          }
      }
 });

        Os RealmObjects síncronos são, por definição, bloqueantes, portanto, este método sempre retornará true para eles. Esse método retornará true se for chamado em um objeto não gerenciado (criado fora do Realm).

        Retorna:
        true se a query tiver sido concluída, false se a query estiver em andamento.
        Veja também:
        isValid()

      • isLoaded

        public static <E extends RealmModel> boolean isLoaded​(E object)
        Verifica se a query usada para localizar este RealmObject foi concluída.

        Métodos assíncronos como RealmQuery.findFirstAsync() retornam um RealmObject que representa o resultado futuro do RealmQuery. Pode ser considerado semelhante a um Future a este respeito.

        Depois que isLoaded() retorna true, o objeto representa o resultado da query mesmo que a query não tenha encontrado nenhum objeto que corresponda aos parâmetros da query. Neste caso, o RealmObject se tornará um objeto "nulo".

        Objeto "nulo" representam null. Uma exceção é lançada se qualquer acessador for chamado, portanto, é importante verificar também isValid() antes de chamar qualquer método. Um padrão comum é: 

         
 Person person = realm.where(Person.class).findFirstAsync();
 RealmObject.isLoaded(person); // == false
 RealmObject.addChangeListener(person, new RealmChangeListener() {
      \@Override
      public void onChange(Person person) {
          RealmObject.isLoaded(person); // always true here
          if (RealmObject.isValid(person)) {
              // It is safe to access the person.
          }
      }
 });

        Os RealmObjects síncronos são, por definição, bloqueantes, portanto, este método sempre retornará true para eles. Esse método retornará true se for chamado em um objeto não gerenciado (criado fora do Realm).

        Parâmetros:
        object - RealmObject para verificar.
        Retorna:
        true se a query tiver sido concluída, false se a query estiver em andamento.
        Veja também:
        isValid(RealmModel)

      • isManaged

        public boolean isManaged()
        Verifica se este objeto é managed pelo Realm. Um objeto managed é apenas um wrapper em torno dos dados no Arquivo de Realm subjacente. No loop de eventos threads, um managed objeto será atualizado ao vivo para que sempre ponto para os dados mais recentes. É possível registrar um ouvinte de alterações usando addChangeListener(RealmChangeListener) para ser notificado quando as alterações acontecerem. managed objeto são confinados por threads para que não possam ser acessados de outros threads além daquele que os criou.

        Se este método retornar false, o objeto não será gerenciado. Um objeto não gerenciado é apenas um objeto Java normal, portanto, pode ser analisado livremente entre threads, mas os dados no objeto não estão conectados ao Realm subjacente, portanto, não serão atualizados ao vivo.

        É possível criar um managed objeto a partir de um objeto não gerenciado usando Realm.copyToRealm(RealmModel, ImportFlag...). Um objeto não managed pode ser criado a partir de um objeto managed usando Realm.copyFromRealm(RealmModel).

        Especificado por:
        isManaged na interface io.realm.internal.ManageableObject
        Retorna:
        true se o objeto for managed, false se não for managed.

      • isManaged

        public static <E extends RealmModel> boolean isManaged​(E object)
        Verifica se este objeto é managed pelo Realm. Um objeto managed é apenas um wrapper em torno dos dados no Arquivo de Realm subjacente. No loop de eventos threads, um managed objeto será atualizado ao vivo para que sempre ponto para os dados mais recentes. É possível registrar um ouvinte de alterações usando addChangeListener(RealmModel, RealmChangeListener) para ser notificado quando as alterações acontecerem. managed objeto são confinados por threads para que não possam ser acessados de outros threads além daquele que os criou.

        Se este método retornar false, o objeto não será gerenciado. Um objeto não gerenciado é apenas um objeto Java normal, portanto, pode ser analisado livremente entre threads, mas os dados no objeto não estão conectados ao Realm subjacente, portanto, não serão atualizados ao vivo.

        É possível criar um managed objeto a partir de um objeto não gerenciado usando Realm.copyToRealm(RealmModel, ImportFlag...). Um objeto não managed pode ser criado a partir de um objeto managed usando Realm.copyFromRealm(RealmModel).

        Retorna:
        true se o objeto for managed, false se não for managed.

      • getRealm

        public Realm getRealm()
        Retorna a instância Realm onde este RealmObject pertence.

        Você não deve chamar Closeable.close() contra a instância retornada.

        Retorna:
        Instância Realm onde este objeto pertence ou null se este objeto não for gerenciado.
        Lançamentos:
        IllegalStateException - se este objeto for uma instância de DynamicRealmObject ou se este objeto já tiver sido excluído ou o Realm correspondente já estiver fechado.

      • carregar

        public final boolean load()
        Cria um bloqueio de query assíncrono. Isso também trigger os ouvintes registrados.

        Observação: isso retornará true se for chamado para um objeto não gerenciado (criado fora do Realm).

        Retorna:
        true se concluiu a query com sucesso, false caso contrário.

      • carregar

        public static <E extends RealmModel> boolean load​(E object)
        Cria um bloqueio de query assíncrono. Isso também trigger os ouvintes registrados.

        Observação: isso retornará true se for chamado para um objeto não gerenciado (criado fora do Realm).

        Parâmetros:
        object - RealmObject para forçar a carga.
        Retorna:
        true se concluiu a query com sucesso, false caso contrário.

      • addChangeListener

        public final <E extends RealmModel> void addChangeListener​(RealmObjectChangeListener<E> listener)
        Adiciona um ouvinte de alterações a este RealmObject para obter informações detalhadas sobre as alterações. The listener will be triggered if any value field or referenced RealmObject field is changed, or the RealmList field itself is changed.

        Registering a change listener will not prevent the underlying RealmObject from being garbage collected. Se o RealmObject for coletado como lixo, o ouvinte de alterações deixará de ser acionado. Para evitar isso, mantenha uma referência forte pelo tempo apropriado, por exemplo, em uma variável de classe. 

         
 public class MyActivity extends Activity {

     private Person person; // Strong reference to keep listeners alive

     \@Override
     protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       person = realm.where(Person.class).findFirst();
       person.addChangeListener(new RealmObjectChangeListener<Person>() {
           \@Override
           public void onChange(Person person, ObjectChangeSet changeSet) {
               // React to change
           }
       });
     }
 }
        Parâmetros:
        listener - o ouvinte de alterações a ser notificado.
        Lançamentos:
        IllegalArgumentException - se o ouvinte de alteração for null ou o objeto for um objeto não gerenciado.
        IllegalStateException - se você tentar adicionar um ouvinte de um tópico que não seja do Looper ou IntentService .
        IllegalStateException - se você tentar adicionar um ouvinte dentro de uma transação.

      • addChangeListener

        public final <E extends RealmModel> void addChangeListener​(RealmChangeListener<E> listener)
        Adiciona um ouvinte de alterações a esse RealmObject que será acionado se qualquer campo de valor ou campo RealmObject referenciado for alterado ou se o próprio campo RealmList for alterado.

        Registering a change listener will not prevent the underlying RealmObject from being garbage collected. Se o RealmObject for coletado como lixo, o ouvinte de alterações deixará de ser acionado. Para evitar isso, mantenha uma referência forte pelo tempo apropriado, por exemplo, em uma variável de classe. 

         
 public class MyActivity extends Activity {

     private Person person; // Strong reference to keep listeners alive

     \@Override
     protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       person = realm.where(Person.class).findFirst();
       person.addChangeListener(new RealmChangeListener<Person>() {
           \@Override
           public void onChange(Person person) {
               // React to change
           }
       });
     }
 }
        Parâmetros:
        listener - o ouvinte de alterações a ser notificado.
        Lançamentos:
        IllegalArgumentException - se o ouvinte de alteração for null ou o objeto for um objeto não gerenciado.
        IllegalStateException - se você tentar adicionar um ouvinte de um tópico que não seja do Looper ou IntentService .
        IllegalStateException - se você tentar adicionar um ouvinte dentro de uma transação.

      • addChangeListener

        public static <E extends RealmModel> void addChangeListener​(E object,
                                                            RealmObjectChangeListener<E> listener)
        Adiciona um ouvinte de alterações a um RealmObject para obter informações detalhadas sobre as alterações. O ouvinte será acionado se qualquer campo de valor ou campo RealmObject referenciado for alterado, ou se o próprio campo RealmList for alterado.

        Registering a change listener will not prevent the underlying RealmObject from being garbage collected. Se o RealmObject for coletado como lixo, o ouvinte de alterações deixará de ser acionado. Para evitar isso, mantenha uma referência forte pelo tempo apropriado, por exemplo, em uma variável de classe. 

         
 public class MyActivity extends Activity {

     private Person person; // Strong reference to keep listeners alive

     \@Override
     protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       person = realm.where(Person.class).findFirst();
       person.addChangeListener(new RealmObjectChangeListener<Person>() {
           \@Override
           public void onChange(Person person, ObjectChangeSet changeSet) {
               // React to change
           }
       });
     }
 }
        Parâmetros:
        object - RealmObject ao qual adicionar o ouvinte.
        listener - o ouvinte de alterações a ser notificado.
        Lançamentos:
        IllegalArgumentException - se o object for null ou um objeto não gerenciado, ou o ouvinte de alterações for null .
        IllegalStateException - se você tentar adicionar um ouvinte de um tópico que não seja do Looper ou IntentService .
        IllegalStateException - se você tentar adicionar um ouvinte dentro de uma transação.

      • addChangeListener

        public static <E extends RealmModel> void addChangeListener​(E object,
                                                            RealmChangeListener<E> listener)
        Adiciona um ouvinte de alterações a um RealmObject que será acionado se qualquer campo de valor ou campo RealmObject referenciado for alterado ou se o próprio campo RealmList for alterado.

        Registering a change listener will not prevent the underlying RealmObject from being garbage collected. Se o RealmObject for coletado como lixo, o ouvinte de alterações deixará de ser acionado. Para evitar isso, mantenha uma referência forte pelo tempo apropriado, por exemplo, em uma variável de classe. 

         
 public class MyActivity extends Activity {

     private Person person; // Strong reference to keep listeners alive

     \@Override
     protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       person = realm.where(Person.class).findFirst();
       person.addChangeListener(new RealmChangeListener<Person>() {
           \@Override
           public void onChange(Person person) {
               // React to change
           }
       });
     }
 }
        Parâmetros:
        object - RealmObject ao qual adicionar o ouvinte.
        listener - o ouvinte de alterações a ser notificado.
        Lançamentos:
        IllegalArgumentException - se o object for null ou um objeto não gerenciado, ou o ouvinte de alterações for null .
        IllegalStateException - se você tentar adicionar um ouvinte de um tópico que não seja do Looper ou IntentService .
        IllegalStateException - se você tentar adicionar um ouvinte dentro de uma transação.

      • removeChangeListener

        public final void removeChangeListener​(RealmObjectChangeListener listener)
        Remove um ouvinte registrado anteriormente.
        Parâmetros:
        listener - a instância a ser removida.
        Lançamentos:
        IllegalArgumentException - se o ouvinte de alteração for null ou o objeto for um objeto não gerenciado.
        IllegalStateException - se você tentar remover um ouvinte de um thread não loop de eventos.

      • removeChangeListener

        public final void removeChangeListener​(RealmChangeListener listener)
        Remove um ouvinte registrado anteriormente.
        Parâmetros:
        listener - a instância a ser removida.
        Lançamentos:
        IllegalArgumentException - se o ouvinte de alteração for null ou o objeto for um objeto não gerenciado.
        IllegalStateException - se você tentar remover um ouvinte de um thread não loop de eventos.

      • removeChangeListener

        public static <E extends RealmModel> void removeChangeListener​(E object,
                                                               RealmObjectChangeListener listener)
        Remove um ouvinte registrado anteriormente no RealmObject fornecido.
        Parâmetros:
        object - RealmObject para remover o ouvinte.
        listener - a instância a ser removida.
        Lançamentos:
        IllegalArgumentException - se o object ou o ouvinte de alteração for null.
        IllegalArgumentException - se o objeto for um RealmObject não gerenciado.
        IllegalStateException - se você tentar remover um ouvinte de um thread não loop de eventos.

      • removeChangeListener

        public static <E extends RealmModel> void removeChangeListener​(E object,
                                                               RealmChangeListener<E> listener)
        Remove um ouvinte registrado anteriormente no RealmObject fornecido.
        Parâmetros:
        object - RealmObject para remover o ouvinte.
        listener - a instância a ser removida.
        Lançamentos:
        IllegalArgumentException - se o object ou o ouvinte de alteração for null.
        IllegalArgumentException - se o objeto for um RealmObject não gerenciado.
        IllegalStateException - se você tentar remover um ouvinte de um thread não loop de eventos.

      • Remover todos os ouvintes de alterações

        public final void removeAllChangeListeners()
        Remove todos os ouvintes registrados.

      • Remover todos os ouvintes de alterações

        public static <E extends RealmModel> void removeAllChangeListeners​(E object)
        Remove todos os ouvintes registrados do RealmObject fornecido.
        Parâmetros:
        object - RealmObject para remover todos os ouvintes.
        Lançamentos:
        IllegalArgumentException - se o objeto for null ou não for managed pelo Realm.

      • asFlowable

        public final <E extends RealmObject> Flowable<E> asFlowable()
        Retorna um RxJava Flowable que monitora as alterações neste RealmObject. Ele emitirá o objeto atual quando for assinado. As atualizações de objetos serão emitidas continuamente à medida que o RealmObject for atualizado - onComplete nunca será chamado.

        Ao encadear um RealmObject, use obj.<MyRealmObjectClass>asFlowable() para passar informações de tipo, caso contrário, o tipo dos seguintes observáveis será RealmObject .

        Os itens emitidos do Realm Flowables estão congelados (consulte freeze(). Isso significa que eles são imutáveis e podem ser lidos em qualquer thread.

        Os Realm Flowables sempre emitem itens do tópico que contém o Realm ativo. Isso significa que, se você precisar fazer processamento adicional, é recomendável observar os valores em um agendador de computação:

        obj.asFlowable() .observeOn(Schedulers.computation()) .map((rxObj) -> doExpensiveWork(rxObj)) .observeOn(AndroidSchedulers.mainThread()) .subscribe( ... );

        Se você quiser que o asFlowable() pare de emitir itens, você pode instruir o RxJava a emitir apenas somente o primeiro item usando o operador first() : 

         
 obj.asFlowable()
      .filter(obj -> obj.isLoaded())
      .first()
      .subscribe( ... ) // You only get the object once

        Parâmetros do tipo:
        E - Classe RealmObject que está sendo observada. Must be this class or its super types.
        Retorna:
        RxJava Observable que chama apenas onNext. Ele nunca chamará onComplete ou OnError.
        Lançamentos:
        UnsupportedOperationException - se a estrutura RxJava necessária não estiver no caminho de classe ou a Instância de Realm correspondente não suportar RxJava.
        IllegalStateException - se o Realm não tiver sido aberto em uma thread do loop de eventos.
        Veja também:
        RxJava e Realm

      • asChangesetObservable

        public final <E extends RealmObject> Observable<ObjectChange<E>> asChangesetObservable()
        Retorna um Rx Observable que monitora as alterações neste RealmObject. Ele emitirá o RealmObject atual quando for assinado. Para cada atualização no RealmObject, um par que consiste no RealmObject e no ObjectChangeSet será enviado. O changeset será null na primeira vez que o RealmObject for emitido.

        O RealmObject será emitido continuamente à medida que for atualizado - onComplete nunca será chamado.

        Os itens emitidos do Realm Observables estão congelados (consulte freeze(). Isso significa que eles são imutáveis e podem ser lidos em qualquer thread.

        Realm Observables sempre emitem itens do thread que contém o Realm ativo. Isso significa que, se você precisar fazer processamento adicional, é recomendável observar os valores em um agendador de computação:

        obj.asChangesetObservable() .observeOn(Schedulers.computation()) .map((rxObj, changes) -> doExpensiveWork(rxObj, changeså)) .observeOn(AndroidSchedulers.mainThread()) .subscribe( ... );

        Retorna:
        RxJava Observable que chama apenas onNext. Ele nunca chamará onComplete ou OnError.
        Lançamentos:
        UnsupportedOperationException - se a estrutura RxJava necessária não estiver no caminho de classe ou a Instância de Realm correspondente não suportar RxJava.
        IllegalStateException - se o Realm não tiver sido aberto em uma thread do loop de eventos.
        Veja também:
        RxJava e Realm

      • asFlowable

        public static <E extends RealmModel> Flowable<E> asFlowable​(E object)
        Retorna um RxJava Flowable que monitora as alterações neste RealmObject. Ele emitirá o objeto atual quando for assinado. As atualizações de objetos serão emitidas continuamente à medida que o RealmObject for atualizado - onComplete nunca será chamado.

        Ao encadear um RealmObject observável, use obj.<MyRealmObjectClass>asFlowable() para passar informações de tipo, caso contrário, o tipo dos seguintes observáveis será RealmObject.

        Os itens emitidos do Realm Flowables estão congelados (consulte freeze(). Isso significa que eles são imutáveis e podem ser lidos em qualquer thread.

        Os Realm Flowables sempre emitem itens do tópico que contém o Realm ativo. Isso significa que, se você precisar fazer processamento adicional, é recomendável observar os valores em um agendador de computação:

        obj.asFlowable() .observeOn(Schedulers.computation()) .map((rxObj) -> doExpensiveWork(rxObj)) .observeOn(AndroidSchedulers.mainThread()) .subscribe( ... );

        Se você quiser que o asFlowable() pare de emitir itens, você pode instruir o RxJava a emitir apenas o primeiro item usando o operador first() : 

         
 obj.asFlowable()
      .filter(obj -> obj.isLoaded())
      .first()
      .subscribe( ... ) // You only get the object once
        Parâmetros:
        object - Classe RealmObject que está sendo observada. Must be this class or its super types.
        Retorna:
        RxJava Observable que chama apenas onNext. Ele nunca chamará onComplete ou OnError.
        Lançamentos:
        UnsupportedOperationException - se a estrutura RxJava necessária não estiver no classpath.
        IllegalStateException - se o Realm não tiver sido aberto em uma thread do loop de eventos.
        Veja também:
        RxJava e Realm

      • asChangesetObservable

        public static <E extends RealmModel> Observable<ObjectChange<E>> asChangesetObservable​(E object)
        Retorna um Rx Observable que monitora as alterações neste RealmObject. Ele emitirá o RealmObject atual quando for assinado. Para cada atualização no RealmObject, um par que consiste no RealmObject e no ObjectChangeSet será enviado. O changeset será null na primeira vez que o RealmObject for emitido.

        O RealmObject será emitido continuamente à medida que for atualizado - onComplete nunca será chamado.

        Os itens emitidos do Realm Observables estão congelados (consulte freeze(). Isso significa que eles são imutáveis e podem ser lidos em qualquer thread.

        Realm Observables sempre emitem itens do thread que contém o Realm ativo. Isso significa que, se você precisar fazer processamento adicional, é recomendável observar os valores em um agendador de computação:

        obj.asChangesetObservable() .observeOn(Schedulers.computation()) .map((rxObj, changes) -> doExpensiveWork(rxObj, changeså)) .observeOn(AndroidSchedulers.mainThread()) .subscribe( ... );

        Parâmetros:
        object - Classe RealmObject que está sendo observada. Must be this class or its super types.
        Retorna:
        RxJava Observable que chama apenas onNext. Ele nunca chamará onComplete ou OnError.
        Lançamentos:
        UnsupportedOperationException - se a estrutura RxJava necessária não estiver no caminho de classe ou a Instância de Realm correspondente não suportar RxJava.
        IllegalStateException - se o Realm não tiver sido aberto em uma thread do loop de eventos.
        Veja também:
        RxJava e Realm