java.lang.Object
- io.realm.MutableRealmInteger

Todas as interfaces implementadas:

io.realm.internal.ManageableObject, Comparable<MutableRealmInteger>
```
public abstract class MutableRealmInteger
extends Object
implements Comparable<MutableRealmInteger>, io.realm.internal.ManageableObject
```
Um MutableRealmInteger é uma quantidade numérica mutável do tipo Long . Ele se comporta quase exatamente como uma referência a Long. Mais especificamente:
- Um MutableRealmInteger pode ter o valor null.
- O operador equals(java.lang.Object) compara os valores Long contidos. nullcom valor MutableRealmInteger é .equals
- O operador compareTo(io.realm.MutableRealmInteger) compara os valores Long contidos. Considera null < qualquer valor nãonull .
- Os operadores increment(long) e decrement(long) lançam IllegalStateException quando aplicados a um nullcom valor MutableRealmInteger.
MutableRealmIntegers são mais interessantes como membros de um objeto RealmModel managed. Quando managed, os operadores increment(long) e decrement(long) implementam um tipo de dados replicado sem conflitos: incrementos e decréscimos simultâneos de vários clientes distribuídos serão agregados corretamente. Por exemplo, se o valor do campo counter para o objeto que representa o usuário "Fred" for atualmente 0, o código a seguir, executado em dois dispositivos diferentes, simultaneamente, mesmo que conectado apenas por uma rede lenta e não confiável, sempre causará o valor de counter para convergir, eventualmente, sobre o valor 2.
```
  MutableRealmInteger counter = realm.where(Users.class)
     .equalTo("name", Fred)
     .findFirst()
     .counter.increment(1);
 
```
Observe que o operador set(Long) deve ser usado com muito cuidado. Ele anulará os efeitos de quaisquer chamadas anteriores para increment(long) ou decrement(long). Embora o valor de um MutableRealmInteger sempre converja entre dispositivos, o valor específico para o qual ele converge dependerá da ordem real em que as operações ocorreram. Portanto, misturar set(Long) com increment(long) e decrement(long) não é recomendado, a menos que a contagem difusa seja aceitável.
MutableRealmIntegers podem não ser chaves primárias. Suas implementações não são seguras para threads. Como todos os objetos de Realm gerenciados, os MutableRealmIntegers gerenciados não podem ser movidos entre threads. MutableRealmIntegers não gerenciados podem ser movidos entre threads, mas exigem publicação segura.
Um MutableRealmInteger, em uma classe de modelo, deve sempre ser declarado final. Por exemplo:
```
 public final MutableRealmInteger counter = MutableRealmInteger.ofNull(); 
 
```
Embora inicializar o MutableRealmInteger como null possa funcionar em circunstâncias muito limitadas, os desenvolvedores são aconselhados a não fazer isso:
```
 
  public final MutableRealmInteger counter = null; // DO NOT DO THIS! 
 
```
Observe também que, quando um MutableRealmInteger é @Required, é melhor, embora não seja necessário, inicializá-lo com um valor não nulo.
```
 
 @Required
  public final MutableRealmInteger counter = MutableRealmInteger.valueOf(0L);
 
```
Uma referência a um MutableRealmInteger managed está sujeita a todas as restrições que se aplicam ao objeto do modelo do qual foi obtida: ele só pode ser mutado dentro de uma transação e se torna inválido se o Realm que o apoia estiver fechado. Use os operadores isManaged() e isValid() para determinar se um MutableRealmInteger está em um estado consistente. Observe, em particular, que uma referência a um MutableRealmInteger managed retém uma referência ao objeto de modelo ao qual pertence. Por exemplo neste código:
```
 MutableRealmInteger counter = realm.where(Users.class).findFirst().counter; 
 
```
o counter contém uma referência ao objeto de modelo User do qual foi obtido. Nenhum dos dois pode ser agrupado até que todas as referências a ambos sejam inacessíveis.

Resumo do método

Todos os métodos Métodos estáticos Métodos de instância Métodos abstratos Métodos concretos
Modificador e tipo	Método	Descrição
`int`	`compareTo(MutableRealmInteger o)`	`MutableRealmInteger`s se comparam estritamente por seus valores.
`abstract void`	`decrement(long dec)`	Diminui o `MutableRealmInteger`, subtraindo o valor do argumento.
`boolean`	`equals(Object o)`	Dois `MutableRealmInteger`s são `.equals` se e somente se seus `longValues` forem iguais.
`abstract Long`	`get()`	Obtém o valor `MutableRealmInteger` .
`int`	`hashCode()`	O código hash de um `MutableRealmInteger` é, exatamente, o código hash do seu valor.
`abstract void`	`increment(long inc)`	Aumenta o `MutableRealmInteger`, adicionando o valor do argumento.
`boolean`	`isNull()`
`static MutableRealmInteger`	`ofNull()`	Cria um novo `MutableRealmInteger` não gerenciado cujo valor é `null`.
`void`	`set(long newValue)`	Define o valor `MutableRealmInteger` .
`abstract void`	`set(Long newValue)`	Define o valor `MutableRealmInteger` .
`static MutableRealmInteger`	`valueOf(long value)`	Cria um novo `MutableRealmInteger` não gerenciado com o valor inicial especificado.
`static MutableRealmInteger`	`valueOf(Long value)`	Cria um novo `MutableRealmInteger` não gerenciado com o valor inicial especificado.
`static MutableRealmInteger`	`valueOf(String value)`	Cria um novo `MutableRealmInteger` não gerenciado com o valor inicial especificado.

Métodos herdados da classe java.lang.objeto
getClass, notify, notifyAll, toString, wait, wait, wait

Métodos herdados da interface io.realm.internal.ManageableObject
isFrozen, isManaged, isValid

- Detalhes do método
  - valor de
```
public static MutableRealmInteger valueOf(Long value)
```
    Cria um novo MutableRealmInteger não gerenciado com o valor inicial especificado.
    
    Parâmetros:
    
    value - valor inicial.
  - ofNull
```
public static MutableRealmInteger ofNull()
```
    Cria um novo MutableRealmInteger não gerenciado cujo valor é null.
  - valor de
```
public static MutableRealmInteger valueOf(long value)
```
    Cria um novo MutableRealmInteger não gerenciado com o valor inicial especificado.
    
    Parâmetros:
    
    value - valor inicial.
  - valor de
```
public static MutableRealmInteger valueOf(String value)
```
    Cria um novo MutableRealmInteger não gerenciado com o valor inicial especificado.
    
    Parâmetros:
    
    value - valor inicial: analisado por Long.parseLong(java.lang.String, int).
  - obter
```
@Nullable
public abstract Long get()
```
    Obtém o valor MutableRealmInteger . O valor pode ser nulo.
    
    Retorna:
    
    o valor.
  - set
```
public abstract void set(@Nullable
                         Long newValue)
```
    Define o valor MutableRealmInteger . Calling set forcibly sets the MutableRealmInteger to the provided value. Isso elimina os efeitos de quaisquer chamadas para increment(long) e decrement(long) recebidas antes da chamada para set.
    
    Parâmetros:
    
    newValue - novo valor.
  - set
```
public final void set(long newValue)
```
    Define o valor MutableRealmInteger . Chamar set(java.lang.Long) define forçosamente o MutableRealmInteger para o valor fornecido. Doing this obliterates the effects of any calls to increment(long) and decrement(long) perceived before the call to set(java.lang.Long).
    
    Parâmetros:
    
    newValue - novo valor.
  - Incremento
```
public abstract void increment(long inc)
```
    Aumenta o MutableRealmInteger, adicionando o valor do argumento. O incremento/decremento de todos os dispositivos é refletido no novo valor, que é garantido que convergirá.
    
    Parâmetros:
    
    inc - quantidade a ser adicionada ao MutableRealmInteger.
  - diminuir
```
public abstract void decrement(long dec)
```
    Diminui o MutableRealmInteger, subtraindo o valor do argumento. O incremento/decremento de todos os dispositivos é refletido no novo valor, que é garantido que convergirá.
    
    Parâmetros:
    
    dec - quantidade a ser subtraída do MutableRealmInteger.
  - IsNull
```
public final boolean isNull()
```
    Retorna:
    
    verdadeiro se e somente se get() retornará null.
  - compareTo
```
public final int compareTo(MutableRealmInteger o)
```
    MutableRealmIntegers se comparam estritamente por seus valores. Nulo é um valor legal para um MutableRealmInteger e null < qualquer valor nãonull
    
    Especificado por:
    
    compareTo na interface Comparable<MutableRealmInteger>
    
    Parâmetros:
    
    o - o alvo de comparação
    
    Retorna:
    
    -1, 0 ou 1, dependendo se o valor deste objeto é <, =, ou > do destino.
  - hashCode
```
public final int hashCode()
```
    O código hash de um MutableRealmInteger é, exatamente, o código hash do seu valor.
    
    Substitui:
    
    hashCode na aula Object
    
    Retorna:
    
    verdadeiro se o destino tiver o mesmo valor.
  - é igual a
```
public final boolean equals(Object o)
```
    Dois MutableRealmIntegers são .equals se e somente se seus longValues forem iguais.
    
    Substitui:
    
    equals na aula Object
    
    Parâmetros:
    
    o - comparar alvo
    
    Retorna:
    
    verdadeiro se o destino tiver o mesmo valor.

Classe MutableRealmInteger

Resumo do método

Métodos herdados da classe java.lang.objeto

Métodos herdados da interface io.realm.internal.ManageableObject

Detalhes do método

valor de

ofNull

valor de

valor de

obter

set

set

Incremento

diminuir

IsNull

compareTo

hashCode

é igual a