Existe uma maneira de declarar um int não assinado em Java?

Ou a pergunta também pode ser enquadrada da seguinte maneira: Qual é o equivalente em Java de não assinado?

Só para dizer o contexto que eu estava observando na implementação do Java String.hashcode(). Eu queria testar a possibilidade de colisão se o número inteiro fosse 32 int sem sinal.

Java não possui um tipo de dados para números inteiros não assinados .

Você pode definir um em longvez de um intse precisar armazenar valores grandes.

Você também pode usar um número inteiro assinado como se não estivesse assinado. O benefício da representação de complemento de dois é que a maioria das operações (como adição, subtração, multiplicação e deslocamento à esquerda) são idênticas em nível binário para números inteiros assinados e não assinados. Algumas operações (divisão, mudança à direita, comparação e elenco), no entanto, são diferentes. No Java SE 8, novos métodos na Integerclasse permitem usar totalmente o inttipo de dados para executar aritmética não assinada :

No Java SE 8 e posterior, é possível usar o tipo de dados int para representar um número inteiro de 32 bits não assinado, que possui um valor mínimo de 0 e um valor máximo de 2 ^ 32-1. Use a classe Integer para usar o tipo de dados int como um número inteiro não assinado. Os métodos estáticos, como compareUnsigned, divideUnsignedetc foram adicionados à classe Integer para apoiar as operações aritméticas em números inteiros sem sinal.

Observe que as intvariáveis ​​ainda são assinadas quando declaradas, mas a aritmética não assinada agora é possível usando esses métodos na Integerclasse.

Há uma API para Inteiro e Longo sem sinal no Java 8!

Se um valor em um int é assinado ou não assinado depende de como os bits são interpretados - Java interpreta os bits como um valor assinado (ele não possui primitivas não assinadas).

Se você tem um int que deseja interpretar como um valor não assinado (por exemplo, você lê um int de um DataInputStream que você sabe que contém um valor não assinado), pode executar o seguinte truque.

int fourBytesIJustRead = someObject.getInt();
long unsignedValue = fourBytesIJustRead & 0xffffffffl;

Observe que é importante que o literal hexadecimal seja um literal longo, não um literal int - daí o 'l' no final.

Precisávamos números não assinados para modelar do MySQL não assinado TINYINT, SMALLINT, INT, BIGINTem jOOQ , que é por isso que criamos jOOU , uma oferta biblioteca minimalista invólucro tipos para números inteiros não assinados em Java. Exemplo:

import static org.joou.Unsigned.*;

// and then...
UByte    b = ubyte(1);
UShort   s = ushort(1);
UInteger i = uint(1);
ULong    l = ulong(1);

Todos esses tipos se estendem java.lang.Numbere podem ser convertidos em tipos primitivos e de ordem superior BigInteger. Espero que isto ajude.

(Aviso: trabalho para a empresa por trás dessas bibliotecas)

Para números não assinados, você pode usar estas classes da biblioteca Guava :

• UnsignedInteger
• UnsignedLong

Eles suportam várias operações:

• mais
• menos
• vezes
• mod
• dividido por

O que parece estar faltando no momento são os operadores de troca de bytes. Se você precisar, pode usar o BigInteger a partir de Java.

Use charpara números inteiros não assinados de 16 bits.

Talvez seja isso que você quis dizer?

long getUnsigned(int signed) {
    return signed >= 0 ? signed : 2 * (long) Integer.MAX_VALUE + 2 + signed;
}

• getUnsigned(0) → 0
• getUnsigned(1) → 1
• getUnsigned(Integer.MAX_VALUE) → 2147483647
• getUnsigned(Integer.MIN_VALUE) → 2147483648
• getUnsigned(Integer.MIN_VALUE + 1) → 2147483649

Parece que você pode lidar com o problema de assinatura executando um "AND lógico" nos valores antes de usá-los:

Exemplo (o valor de byte[] header[0]é 0x86):

System.out.println("Integer "+(int)header[0]+" = "+((int)header[0]&0xff));

Resultado:

Integer -122 = 134

Há boas respostas aqui, mas não vejo nenhuma demonstração de operações bit a bit. Como Visser (a resposta atualmente aceita) diz, o Java assina números inteiros por padrão (o Java 8 tem números inteiros não assinados, mas eu nunca os usei). Sem mais delongas, vamos fazê-lo ...

Exemplo RFC 868

O que acontece se você precisar gravar um número inteiro não assinado no IO? Um exemplo prático é quando você deseja exibir o tempo de acordo com a RFC 868 . Isso requer um número inteiro não assinado de 32 bits, big endian, que codifica o número de segundos desde 00:00 de 1º de janeiro de 1900. Como você codificaria isso?

Crie seu próprio número inteiro de 32 bits não assinado como este:

Declarar uma matriz de bytes de 4 bytes (32 bits)

Byte my32BitUnsignedInteger[] = new Byte[4] // represents the time (s)

Isso inicializa a matriz, consulte As matrizes de bytes são inicializadas como zero em Java? . Agora você precisa preencher cada byte na matriz com informações na ordem big-endian (ou little-endian se você quiser causar estragos). Supondo que você tenha um longo contendo o tempo (inteiros longos têm 64 bits em Java) chamado secondsSince1900(que utiliza apenas os primeiros 32 bits, e você já lidou com o fato de que Date faz referência a 00:00 em 1º de janeiro de 1970), você pode usar o AND lógico para extrair bits dele e mudar esses bits para posições (dígitos) que não serão ignorados quando colocados em um byte e na ordem big endian.

my32BitUnsignedInteger[0] = (byte) ((secondsSince1900 & 0x00000000FF000000L) >> 24); // first byte of array contains highest significant bits, then shift these extracted FF bits to first two positions in preparation for coersion to Byte (which only adopts the first 8 bits)
my32BitUnsignedInteger[1] = (byte) ((secondsSince1900 & 0x0000000000FF0000L) >> 16);
my32BitUnsignedInteger[2] = (byte) ((secondsSince1900 & 0x000000000000FF00L) >> 8);
my32BitUnsignedInteger[3] = (byte) ((secondsSince1900 & 0x00000000000000FFL); // no shift needed

my32BitUnsignedIntegerAgora, nosso é equivalente a um número inteiro big endian não assinado de 32 bits que adere ao padrão RCF 868. Sim, o tipo de dados longo é assinado, mas ignoramos esse fato, porque assumimos que os segundosSince1900 usavam apenas os 32 bits inferiores). Por envolver o comprimento em um byte, todos os bits maiores que 2 ^ 7 (dois primeiros dígitos em hexadecimal) serão ignorados.

Fonte referenciada: Java Network Programming, 4ª Edição.

Acabei de criar esse pedaço de código, que converte "this.altura" de número negativo em positivo. Espero que isso ajude alguém em necessidade

       if(this.altura < 0){    

                        String aux = Integer.toString(this.altura);
                        char aux2[] = aux.toCharArray();
                        aux = "";
                        for(int con = 1; con < aux2.length; con++){
                            aux += aux2[con];
                        }
                        this.altura = Integer.parseInt(aux);
                        System.out.println("New Value: " + this.altura);
                    }

Você pode usar a função Math.abs (number). Retorna um número positivo.