¿Hay alguna manera de declarar un int sin firmar en Java?

O la pregunta también puede enmarcarse así: ¿Cuál es el equivalente Java de unsigned?

Solo para decirte el contexto en el que estaba mirando la implementación de Java String.hashcode(). Quería probar la posibilidad de colisión si el entero fuera 32 unsigned int.

Java no tiene un tipo de datos para enteros sin signo .

Puede definir un en longlugar de un intsi necesita almacenar valores grandes.

También puede usar un entero con signo como si no estuviera firmado. El beneficio de la representación del complemento a dos es que la mayoría de las operaciones (como suma, resta, multiplicación y desplazamiento a la izquierda) son idénticas a nivel binario para enteros con y sin signo. Sin embargo, algunas operaciones (división, desplazamiento a la derecha, comparación y fundición) son diferentes. A partir de Java SE 8, los nuevos métodos en la Integerclase le permiten utilizar completamente el inttipo de datos para realizar operaciones aritméticas sin signo :

En Java SE 8 y versiones posteriores, puede usar el tipo de datos int para representar un entero de 32 bits sin signo, que tiene un valor mínimo de 0 y un valor máximo de 2 ^ 32-1. Use la clase Integer para usar el tipo de datos int como un entero sin signo. Se han agregado métodos estáticos como compareUnsigned, divideUnsignedetc. a la clase Integer para admitir las operaciones aritméticas para enteros sin signo.

Tenga en cuenta que las intvariables todavía están firmadas cuando se declaran, pero ahora es posible utilizar la aritmética sin signo utilizando esos métodos en la Integerclase.

¡Hay una API para Entero sin signo y Largo en Java 8!

Si un valor en un int es con signo o sin signo depende de cómo se interpreten los bits: Java interpreta los bits como un valor con signo (no tiene primitivas sin signo).

Si tiene un int que desea interpretar como un valor sin signo (por ejemplo, si lee un int de un DataInputStream que sabe que contiene un valor sin signo), puede hacer el siguiente truco.

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

Tenga en cuenta que es importante que el literal hexadecimal sea un literal largo, no un literal int, de ahí la 'l' al final.

Necesitábamos números sin signo de modelar de MySQL sin signo TINYINT, SMALLINT, INT, BIGINTen jOOQ , por lo que hemos creado Joou , una oferta biblioteca minimalista envoltorio tipos de números enteros sin signo en Java. Ejemplo:

import static org.joou.Unsigned.*;

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

Todos estos tipos se extienden java.lang.Numbery se pueden convertir en tipos primitivos y de orden superior BigInteger. Espero que esto ayude.

(Descargo de responsabilidad: trabajo para la empresa detrás de estas bibliotecas)

Para números sin signo, puede usar estas clases de la biblioteca Guava :

• Entero sin firmar
• UnsignedLong

Apoyan varias operaciones:

• más
• menos
• veces
• modificación
• dividido por

Lo que parece faltar en este momento son los operadores de cambio de bytes. Si los necesita, puede usar BigInteger de Java.

Úselo charpara enteros sin signo de 16 bits.

Quizás esto es lo que quisiste decir?

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 puede manejar el problema de firma haciendo un "AND lógico" en los valores antes de usarlos:

Ejemplo (valor de byte[] header[0]is 0x86):

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

Resultado:

Integer -122 = 134

Aquí hay buenas respuestas, pero no veo ninguna demostración de operaciones bit a bit. Como dice Visser (la respuesta actualmente aceptada), Java firma enteros por defecto (Java 8 tiene enteros sin signo, pero nunca los he usado). Sin más preámbulos, hagámoslo ...

RFC 868 Ejemplo

¿Qué sucede si necesita escribir un entero sin signo en IO? Un ejemplo práctico es cuando desea generar el tiempo de acuerdo con RFC 868 . Esto requiere un número entero de 32 bits, big-endian, sin signo que codifique el número de segundos desde las 12:00 AM del 1 de enero de 1900. ¿Cómo codificaría esto?

Haga su propio entero de 32 bits sin signo como este:

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

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

Esto inicializa la matriz, consulte ¿Las matrices de bytes se inicializan a cero en Java? . Ahora tiene que llenar cada byte en la matriz con información en el orden big-endian (o little-endian si quiere causar estragos). Suponiendo que tiene un tiempo que contiene el tiempo (los enteros largos son de 64 bits en Java) llamado secondsSince1900(que solo utiliza los primeros 32 bits, y ha manejado el hecho de que Date hace referencia a las 12:00 AM del 1 de enero de 1970), luego puede usar el AND lógico para extraer bits de él y cambiar esos bits a posiciones (dígitos) que no se ignorarán cuando se conviertan en un Byte, y en orden 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

Nuestro my32BitUnsignedIntegerahora es equivalente a un entero big endian sin signo de 32 bits que se adhiere al estándar RCF 868. Sí, el tipo de datos largo está firmado, pero ignoramos ese hecho, porque asumimos que los segundosSince1900 solo usaron los 32 bits inferiores). Debido a convertir el largo en un byte, se ignorarán todos los bits superiores a 2 ^ 7 (primeros dos dígitos en hexadecimal).

Fuente referenciada: Java Network Programming, cuarta edición.

Acabo de hacer este código, que convierte "this.altura" de negativo a positivo. Espero que esto ayude a alguien que lo necesita

       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);
                    }

Puede usar la función Math.abs (número). Devuelve un número positivo.