Pacote io.realm

Classe RealmResults<E>

  • Parâmetros do tipo:
    E - A classe de objetos nesta lista.
    Todas as interfaces implementadas:
    io.realm.internal.Freezable<RealmCollection<E>>, io.realm.internal.ManageableObject, OrderedRealmCollection<E>, RealmCollection<E>, Iterable<E>, Collection<E>, List<E>
    public class RealmResults<E>
extends AbstractList<E>
    Esta classe contém todas as correspondências de um RealmQuery para um determinado Realm. Os objetos não são copiados do Realm para a lista RealmResults, mas são apenas referenciados do RealmResult. Isso economiza memória e aumenta a velocidade.

    Os RealmResults são visualizações em tempo real, o que significa que, se ele estiver em um thread Looper , atualizará automaticamente seus resultados de query após a confirmação de uma transação. Se estiver em uma thread sem loop de eventos, BaseRealm.refresh() deverá ser chamado para atualizar os resultados.

    As atualizações do RealmObjects a partir de uma lista do RealmResults devem ser feitas de dentro de uma transação e os objeto modificados devem ser mantidos no Arquivo de Realm durante a confirmação da transação.

    Um objeto RealmResults não pode ser passado entre threads diferentes.

    Observe que um RealmResults nunca é null nem mesmo no caso em que não contém objetos. Você deve sempre usar o método List.size() para verificar se um RealmResults está vazio ou não.

    Se um RealmResults for criado no RealmList por meio RealmList.where(), ele ficará vazio quando o RealmList de origem for excluído.

    RealmResults pode conter mais elementos do que Integer.MAX_VALUE. Nesse caso, você pode acessar apenas os primeiros elementos Integer.MAX_VALUE nele.

    Veja também:
    RealmQuery.findAll(), Realm.executeTransaction(Realm.Transaction)

    • Detalhes do campo

      • baseRealm

        public final io.realm.BaseRealm baseRealm
        A instância BaseRealm na qual reside esta collection.

        Aviso: este campo está exposto apenas para uso interno e não deve ser usado.

    • Detalhes do método

      • ONDE

        public RealmQuery<E> where()
        Retorna um RealmQuery , que pode ser utilizado para fazer query de objetos específicos desta coleção.
        Retorna:
        um objeto RealmQuery.
        Veja também:
        RealmQuery

      • sort

        public RealmResults<E> sort​(String fieldName1,
                            Sort sortOrder1,
                            String fieldName2,
                            Sort sortOrder2)
        Classifica uma collection com base nos campos fornecidos e nas ordens de classificação.
        Especificado por:
        sort na interface OrderedRealmCollection<E>
        Parâmetros:
        fieldName1 - nome do primeiro campo. Somente campos do tipo booleano, curto, int, longo, flutuante, duplo, Data e String são permitidos.
        sortOrder1 - ordem de classificação para o primeiro campo.
        fieldName2 - nome do segundo campo. Somente campos do tipo booleano, curto, int, longo, flutuante, duplo, Data e String são permitidos.
        sortOrder2 - ordem de classificação para o segundo campo.
        Retorna:
        um novo RealmResults ordenado será criado e devolvido. A collection original permanece inalterada.

      • isLoaded

        public boolean isLoaded()
        Retorna false se os resultados ainda não estiverem carregados, true se estiverem carregados.
        Retorna:
        true se a query tiver sido concluída e os dados estiverem disponíveis, false se a query ainda estiver em execução em segundo plano.

      • carregar

        carga booleana pública()
        Cria um bloqueio de query assíncrono. Isso também trigger qualquer RealmChangeListener registrado quando a query for concluída.
        Retorna:
        true se concluiu a query com sucesso, false caso contrário.

      • Definir valor

        public void setValue​(String fieldName,
                     @Nullable
                     Object value)
        Atualiza o campo fornecido por fieldName em todos os objetos dentro do resultado da query.

        Este método tentará converter automaticamente números e booleanos fornecidos como String para o tipo apropriado. Por exemplo "10" será convertido em 10 se o tipo de campo for RealmFieldType.INTEGER.

        Usar os setters digitados como setInt(String, int) será mais rápido do que usar este método.

        Parâmetros:
        fieldName - campo para atualizar
        value - valor com o qual atualizar.
        Lançamentos:
        IllegalArgumentException - se o campo não pôde ser encontrado, não pôde ser atualizado ou o argumento não correspondeu ao tipo de campo ou não pôde ser convertido para corresponder ao tipo de campo subjacente.

      • setNull

        public void setNull​(String fieldName)
        Define o valor para null para o campo fornecido em todos os objeto na collection.
        Parâmetros:
        fieldName - nome do campo a ser atualizado.
        Lançamentos:
        IllegalArgumentException - se o nome do campo não existir ou for uma propriedade de chave primária.
        IllegalStateException - se o campo não puder conter null valores .

      • setBoolean

        public void setBoolean​(String fieldName,
                       boolean value)
        Define o valor boolean do campo fornecido em todos os objetos na coleção.
        Parâmetros:
        fieldName - nome do campo a ser atualizado.
        value - novo valor para o campo.
        Lançamentos:
        IllegalArgumentException - se o nome do campo não existir, for uma propriedade de chave primária ou não for um campo booleano.

      • setByte

        public void setByte​(String fieldName,
                    byte value)
        Define o valor byte do campo fornecido em todos os objetos na coleção.
        Parâmetros:
        fieldName - nome do campo a ser atualizado.
        value - novo valor para o campo.
        Lançamentos:
        IllegalArgumentException - se o nome do campo não existir, for uma propriedade de chave primária ou não for um campo de byte.

      • setcurto

        public void setShort​(String fieldName,
                     short value)
        Define o valor short do campo fornecido em todos os objetos na coleção.
        Parâmetros:
        fieldName - nome do campo a ser atualizado.
        value - novo valor para o campo.
        Lançamentos:
        IllegalArgumentException - se o nome do campo não existir, for uma propriedade de chave primária ou não for um campo curto.

      • setInt

        public void setInt​(String fieldName,
                   int value)
        Define o valor int do campo fornecido em todos os objetos na coleção.
        Parâmetros:
        fieldName - nome do campo a ser atualizado.
        value - novo valor para o campo.
        Lançamentos:
        IllegalArgumentException - se o nome do campo não existir, for uma propriedade de chave primária ou não for um campo inteiro.

      • setLong

        public void setLong​(String fieldName,
                    long value)
        Define o valor long do campo fornecido em todos os objetos na coleção.
        Parâmetros:
        fieldName - nome do campo a ser atualizado.
        value - novo valor para o campo.
        Lançamentos:
        IllegalArgumentException - se o nome do campo não existir, for uma propriedade de chave primária ou não for um campo longo.

      • setFloat

        public void setFloat​(String fieldName,
                     float value)
        Define o valor float do campo fornecido em todos os objetos na coleção.
        Parâmetros:
        fieldName - nome do campo a ser atualizado.
        value - novo valor para o campo.
        Lançamentos:
        IllegalArgumentException - se o nome do campo não existir, for uma propriedade de chave primária ou não for um campo flutuante.

      • setDouble

        public void setDouble​(String fieldName,
                      double value)
        Define o valor double do campo fornecido em todos os objetos na coleção.
        Parâmetros:
        fieldName - nome do campo a ser atualizado.
        value - novo valor para o campo.
        Lançamentos:
        IllegalArgumentException - se o nome do campo não existir, for uma propriedade de chave primária ou não for um campo duplo.

      • setString

        public void setString​(String fieldName,
                      @Nullable
                      String value)
        Define o valor String do campo fornecido em todos os objetos na coleção.
        Parâmetros:
        fieldName - nome do campo a ser atualizado.
        value - novo valor para o campo.
        Lançamentos:
        IllegalArgumentException - se o nome do campo não existir, for uma propriedade de chave primária ou não for um campo de cadeia de caracteres.

      • setBlob

        public void setBlob​(String fieldName,
                    @Nullable
                    byte[] value)
        Define o valor binário do campo fornecido em todos os objeto na collection.
        Parâmetros:
        fieldName - nome do campo a ser atualizado.
        value - novo valor para o campo.
        Lançamentos:
        IllegalArgumentException - se o nome do campo não existir, for uma propriedade de chave primária ou não for um campo binário.

      • setDate

        public void setDate​(String fieldName,
                    @Nullable
                    Date value)
        Define o valor Date do campo fornecido em todos os objetos na coleção.
        Parâmetros:
        fieldName - nome do campo a ser atualizado.
        value - novo valor para o campo.
        Lançamentos:
        IllegalArgumentException - se o nome do campo não existir, for uma propriedade de chave primária ou não for um campo Date .

      • setObject

        public void setObject​(String fieldName,
                      @Nullable
                      RealmModel value)
        Define uma referência a outro objeto no campo fornecido em todos os objetos da collection.
        Parâmetros:
        fieldName - nome do campo a ser atualizado.
        value - novo objeto referenciado por este campo.
        Lançamentos:
        IllegalArgumentException - se o nome do campo não existir, for uma propriedade de chave primária ou não for um campo de referência do objeto .

      • setDecimal128

        public void setDecimal128​(String fieldName,
                          @Nullable
                          Decimal128 value)
        Define o valor Decimal128 do campo fornecido em todos os objetos na coleção.
        Parâmetros:
        fieldName - nome do campo a ser atualizado.
        value - novo valor para o campo.
        Lançamentos:
        IllegalArgumentException - se o nome do campo não existir, for uma propriedade de chave primária ou não for um campo Decimal128 .

      • setObjectId

        public void setObjectId​(String fieldName,
                        @Nullable
                        ObjectId value)
        Define o valor ObjectId do campo fornecido em todos os objetos na coleção.
        Parâmetros:
        fieldName - nome do campo a ser atualizado.
        value - novo valor para o campo.
        Lançamentos:
        IllegalArgumentException - se o nome do campo não existir, for uma propriedade de chave primária ou não for um campo ObjectId .

      • setUUID

        public void setUUID​(String fieldName,
                    @Nullable
                    UUID value)
        Define o valor UUID do campo fornecido em todos os objetos na coleção.
        Parâmetros:
        fieldName - nome do campo a ser atualizado.
        value - novo valor para o campo.
        Lançamentos:
        IllegalArgumentException - se o nome do campo não existir, for uma propriedade de chave primária ou não for um campo UUID .

      • setList

        public <T> void setList​(String fieldName,
                        RealmList<T> list)
        Substitui o RealmList no campo fornecido em todos os objeto nesta collection.
        Parâmetros:
        fieldName - nome do campo a ser atualizado.
        list - novo valor para o campo.
        Lançamentos:
        IllegalArgumentException - se o nome do campo não existir, não for um campo RealmList, se os objetos na lista não forem gerenciados ou o tipo dos objetos na lista estiver errado.

      • IsFrozen

        public boolean isFrozen()

      • addChangeListener

        public void addChangeListener​(RealmChangeListener<RealmResults<E>> listener)
        Adiciona um ouvinte de alteração a este RealmResults.

        Registrar um ouvinte de alterações não impedirá que o RealmResults subjacente seja coletado o lixo. Se o RealmResults 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 RealmResults<Person> results; // Strong reference to keep listeners alive

     \@Override
     protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       results = realm.where(Person.class).findAllAsync();
       results.addChangeListener(new RealmChangeListener<RealmResults<Person>>() {
           \@Override
           public void onChange(RealmResults<Person> persons) {
               // React to change
           }
       });
     }
 }
        Parâmetros:
        listener - o ouvinte de alterações a ser notificado.
        Lançamentos:
        IllegalArgumentException - se 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 .

      • addChangeListener

        public void addChangeListener​(OrderedRealmCollectionChangeListener<RealmResults<E>> listener)
        Adiciona um ouvinte de alteração a este RealmResults.

        Registrar um ouvinte de alterações não impedirá que o RealmResults subjacente seja coletado o lixo. Se o RealmResults 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 RealmResults<Person> results; // Strong reference to keep listeners alive

     \@Override
     protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       results = realm.where(Person.class).findAllAsync();
       results.addChangeListener(new OrderedRealmCollectionChangeListener<RealmResults<Person>>() {
           \@Override
           public void onChange(RealmResults<Person> persons, OrderedCollectionChangeSet changeSet) {
               // React to change
           }
       });
     }
 }
        Parâmetros:
        listener - o ouvinte de alterações a ser notificado.
        Lançamentos:
        IllegalArgumentException - se 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 .

      • Remover todos os ouvintes de alterações

        public void removeAllChangeListeners()
        Remove todos os ouvintes de alterações definidos pelo usuário.
        Lançamentos:
        IllegalStateException - se você tentar remover ouvintes de um thread que não seja do loop de eventos.
        Veja também:
        RealmChangeListener

      • asFlowable

        public Flowable<RealmResults<E>> asFlowable()
        Retorna um Rx Flowable que monitora as alterações neste RealmResults. Ele emitirá o RealmResults atual quando for inscrito. O RealmResults será emitido continuamente à medida que o RealmResults for atualizado - onComplete nunca será chamado.

        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 thread que mantém o RealmResults ativo. Isso significa que, se você precisar fazer processamento adicional, é recomendável observar os valores em um agendador de computação:

        realm.where(Foo.class).findAllAsync().asFlowable() .observeOn(Schedulers.computation()) .map(rxResults -> doExpensiveWork(rxResults)) .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() : 

         
 realm.where(Foo.class).findAllAsync().asFlowable()
      .filter(results -> results.isLoaded())
      .first()
      .subscribe( ... ) // You only get the results once

        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 Observable<CollectionChange<RealmResults<E>>> asChangesetObservable()
        Retorna um Rx Observable que monitora as alterações neste RealmResults. Ele emitirá o RealmResults atual quando for inscrito. Para cada atualização do RealmResult, um par que consiste no RealmResults e no OrderedCollectionChangeSet será enviado. O changeset será null na primeira vez que um RealmResults for emitido.

        O RealmResults será emitido continuamente à medida que o RealmResults 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:

        realm.where(Foo.class).findAllAsync().asChangesetObservable() .observeOn(Schedulers.computation()) .map((rxResults, changes) -> doExpensiveWork(rxResults, 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

      • asJSON

        string pública asJSON()
        Retorna uma representação JSON das correspondências de um RealmQuery. Os ciclos serão retornados como índices de linha. Este é um método auxiliar usado para inspecionar dados ou, para fins de depuração, esse método pode puxar uma string grande, o que pode causar um erro de OutOfMemory.
        Retorna:
        representação de string de uma array JSON contendo entradas do RealmQuery resultante.

      • é válido

        public boolean isValid()
        Verifica se a collection ainda é válida para uso, ou seja, a instância Realm não foi fechada. Ele sempre retornará true para uma coleção não gerenciada.
        Especificado por:
        isValid na interface io.realm.internal.ManageableObject
        Especificado por:
        isValid na interface RealmCollection<E>
        Retorna:
        true se ainda for válido para usar ou uma collection não gerenciada, false caso contrário.

      • obter

        @Nullable
public E get(localização int)
        Retorna o elemento no local especificado nesta lista.
        Especificado por:
        get na interface List<E>
        Especificado por:
        get na aula AbstractList<E>
        Parâmetros:
        location - o índice do elemento a ser retornado.
        Retorna:
        o elemento no índice especificado.
        Lançamentos:
        IndexOutOfBoundsException - se location < 0 || location >= size().

      • primeiro

        @Nullable E public E first( @Nullable E defaultValue)
        Obtém o primeiro objeto da collection. Se a collection estiver vazia, o padrão fornecido será usado.
        Especificado por:
        first na interface OrderedRealmCollection<E>
        Retorna:
        o primeiro objeto ou o padrão fornecido.

      • último

        @Nullable
public E last(@Nullable
              E defaultValue)
        Obtém o último objeto da collection. Se a collection estiver vazia, o padrão fornecido será usado.
        Especificado por:
        last na interface OrderedRealmCollection<E>
        Retorna:
        o último objeto ou o padrão fornecido.

      • deleteFromRealm

        public void deleteFromRealm​(int location)
        Exclui o objeto no índice fornecido do Realm. Isso também o remove da coleção.
        Especificado por:
        deleteFromRealm na interface OrderedRealmCollection<E>
        Parâmetros:
        location - o índice da array identificando o objeto a ser removido.

      • deleteAllFromRealm

        public boolean deleteAllFromRealm()
        Isso exclui todos os objetos da collection do Realm subjacente e da collection.
        Especificado por:
        deleteAllFromRealm na interface RealmCollection<E>
        Retorna:
        true se os objetos foram excluídos, false caso contrário.

      • sort

        public RealmResults<E> sort​(String fieldName)
        Classifica uma collection com base no campo fornecido em ordem crescente.
        Especificado por:
        sort na interface OrderedRealmCollection<E>
        Parâmetros:
        fieldName - o nome do campo pelo qual classificar. Somente campos do tipo booleano, curto, int, longo, flutuante, duplo, Data e String são permitidos.
        Retorna:
        um novo RealmResults ordenado será criado e devolvido. A collection original permanece inalterada.

      • sort

        public RealmResults<E> sort​(String fieldName,
                            Sort sortOrder)
        Classifica uma collection com base no campo fornecido e na ordem de classificação.
        Especificado por:
        sort na interface OrderedRealmCollection<E>
        Parâmetros:
        fieldName - o nome do campo pelo qual classificar. Somente campos do tipo booleano, curto, int, longo, flutuante, duplo, Data e String são permitidos.
        sortOrder - a direção pela qual classificar.
        Retorna:
        um novo RealmResults ordenado será criado e devolvido. A collection original permanece inalterada.

      • sort

        public RealmResults<E> sort​(String[] fieldNames,
                            Sort[] sortOrders)
        Classifica uma collection com base nos campos fornecidos e nas ordens de classificação.
        Especificado por:
        sort na interface OrderedRealmCollection<E>
        Parâmetros:
        fieldNames - uma array de nomes de campos para classificar. Somente campos do tipo booleano, curto, int, longo, flutuante, duplo, Data e String são permitidos.
        sortOrders - as instruções para classificar por.
        Retorna:
        um novo RealmResults ordenado será criado e devolvido. A collection original permanece inalterada.

      • Tamanho

        public int size()
        Retorna o número de elementos neste resultado da query.
        Especificado por:
        size na interface Collection<E>
        Especificado por:
        size na interface List<E>
        Especificado por:
        size na aula AbstractCollection<E>
        Retorna:
        o número de elementos neste resultado da query.

      • min

        Número público min(String fieldName)
        Localiza o valor mínimo de um campo.
        Especificado por:
        min na interface RealmCollection<E>
        Parâmetros:
        fieldName - o campo para procurar um mínimo. Somente campos numéricos são permitidos.
        Retorna:
        se não existirem objetos ou se todos eles tiverem null como o valor para o campo fornecido, null será retornado. Caso contrário, o valor mínimo é devolvido. Ao determinar o valor mínimo, os objetos com valores null são ignorados.

      • minDate

        data pública minDate(String fieldName)
        Encontra a data mínima.
        Especificado por:
        minDate na interface RealmCollection<E>
        Parâmetros:
        fieldName - o campo para procurar a data mínima. Se fieldName não for do tipo Date, uma exceção será lançada.
        Retorna:
        se não existirem objetos ou se todos eles tiverem null como valor para o campo de data fornecido, null será retornado. Caso contrário, a data mínima é retornada. Ao determinar a data mínima, os objetos com valores null são ignorados.

      • max

        Número público máximo (String fieldName)
        Localiza o valor máximo de um campo.
        Especificado por:
        max na interface RealmCollection<E>
        Parâmetros:
        fieldName - o campo para procurar um máximo. Somente campos numéricos são permitidos.
        Retorna:
        se não existirem objetos ou se todos eles tiverem null como o valor para o campo fornecido, null será retornado. Caso contrário, o valor máximo é retornado. Ao determinar o valor máximo, os objetos com valores null são ignorados.

      • maxDate

        @Nullable
public Date maxDate(String fieldName)
        Encontra a data máxima.
        Especificado por:
        maxDate na interface RealmCollection<E>
        Parâmetros:
        fieldName - o campo para procurar a data máxima. Se fieldName não for do tipo Date, uma exceção será lançada.
        Retorna:
        se não existirem objetos ou se todos eles tiverem null como valor para o campo de data fornecido, null será retornado. Caso contrário, a data máxima é retornada. Ao determinar a data máxima, os objetos com valores null são ignorados.
        Lançamentos:
        IllegalArgumentException - se fieldName não for um campo de data.

      • soma

        soma de número público (string fieldName )
        Calcula a soma de um determinado campo.
        Especificado por:
        sum na interface RealmCollection<E>
        Parâmetros:
        fieldName - o campo a ser somado. Somente campos numéricos são permitidos.
        Retorna:
        a soma. Se não existirem objetos ou todos eles tiverem null como o valor para o campo fornecido, 0 será retornado. Ao calcular a soma, objetos com valores null são ignorados.

      • média

        média dupla pública (String fieldName)
        Retorna a média de um determinado campo.
        Especificado por:
        average na interface RealmCollection<E>
        Parâmetros:
        fieldName - o campo para calcular a média. Somente campos numéricos são permitidos.
        Retorna:
        a média do campo fornecido entre os objetos nos resultados da query. Isso será do tipo double para todos os tipos de campos numéricos. Se não existirem objetos ou todos eles tiverem null como o valor para o campo fornecido, 0 será retornado. Ao calcular a média, objetos com valores null são ignorados.

      • deleteLastFromRealm

        public boolean deleteLastFromRealm()
        Remove o último objeto da lista. Isso também exclui o objeto do Realm subjacente.
        Especificado por:
        deleteLastFromRealm na interface OrderedRealmCollection<E>
        Retorna:
        true se um objeto foi excluído, false caso contrário.
        Lançamentos:
        IllegalStateException - se o Realm correspondente estiver fechado ou em um thread incorreto.

      • deleteFirstFromRealm

        public boolean deleteFirstFromRealm()
        Remove o primeiro objeto da lista. Isso também exclui o objeto do Realm subjacente.
        Especificado por:
        deleteFirstFromRealm na interface OrderedRealmCollection<E>
        Retorna:
        true se um objeto foi excluído, false caso contrário.
        Lançamentos:
        IllegalStateException - se o Realm correspondente estiver fechado ou em um thread incorreto.

      • getRealm

        public Realm getRealm()
        Retorna a instância Realm à qual esta coleção pertence.

        Chamar Closeable.close() na instância retornada não é recomendado, pois é o mesmo que chamá-la na instância original do Realm, o que pode fazer com que o Realm feche totalmente, invalidando o resultado da query.

        Retorna:
        Realm instância à qual esta collection pertence.
        Lançamentos:
        IllegalStateException - se o Realm for uma instância de DynamicRealm ou se o Realm já estiver fechado.