La clase Integer es una clase contenedora para el tipo primitivo int que contiene varios métodos para manejar de manera efectiva un valor int como convertirlo en una representación de string y viceversa. Un objeto de la clase Integer puede contener un único valor int.
Constructores:
- Integer(int b): Crea un objeto Integer inicializado con el valor proporcionado.
Sintaxis:
public Integer(int b)
Parámetros:
b : value with which to initialize
- Integer(String s): crea un objeto Integer inicializado con el valor int proporcionado por la representación de string. La raíz predeterminada se toma como 10.
Sintaxis:
public Integer(String s) throws NumberFormatException
Parámetros:
s : string representation of the int value
Lanza:
NumberFormatException : If the string provided does not represent any int value.
Métodos:
1. toString() : Devuelve la string correspondiente al valor int.
Sintaxis:
public String toString(int b)
Parámetros:
b : int value for which string representation required.
2. toHexString() : Devuelve la string correspondiente al valor int en formato hexadecimal, es decir, devuelve una string que representa el valor int en caracteres hexadecimales-[0-9][af]
Sintaxis:
public String toHexString(int b)
Parámetros:
b : int value for which hex string representation required.
3. toOctalString() : Devuelve la string correspondiente al valor int en forma octal, es decir, devuelve una string que representa el valor int en caracteres octales-[0-7]
Sintaxis:
public String toOctalString(int b)
Parámetros:
b : int value for which octal string representation required.
4. toBinaryString() : Devuelve la string correspondiente al valor int en dígitos binarios, es decir, devuelve una string que representa el valor int en caracteres hexadecimales-[0/1]
Sintaxis:
public String toBinaryString(int b)
Parámetros:
b : int value for which binary string representation required.
5. valueOf() : devuelve el objeto Integer inicializado con el valor proporcionado.
Sintaxis:
public static Integer valueOf(int b)
Parámetros:
b : a int value
- valueOf(String val,int radix) : Otra función sobrecargada que proporciona una función similar a new Integer(Integer.parseInteger(val,radix))
Sintaxis:
public static Integer valueOf(String val, int radix) throws NumberFormatException
Parámetros:
val : String to be parsed into int value radix : radix to be used while parsing
Lanza:
NumberFormatException : if String cannot be parsed to a int value in given radix.
- valueOf(String val) : Otra función sobrecargada que proporciona una función similar a new Integer(Integer.parseInt(val,10))
Sintaxis:
public static Integer valueOf(String s) throws NumberFormatException
Parámetros:
s : a String object to be parsed as int
Lanza:
NumberFormatException : if String cannot be parsed to a int value in given radix.
6. parseInt() : devuelve el valor int analizando la string en la raíz proporcionada. Se diferencia de valueOf() en que devuelve un valor int primitivo y valueOf() devuelve un objeto Integer.
Sintaxis:
public static int parseInt(String val, int radix) throws NumberFormatException
Parámetros:
val : String representation of int radix : radix to be used while parsing
Lanza:
NumberFormatException : if String cannot be parsed to a int value in given radix.
- Otro método sobrecargado que contiene solo String como parámetro, radix se establece de forma predeterminada en 10.
Sintaxis:
public static int parseInt(String val) throws NumberFormatException
Parámetros:
val : String representation of int
Lanza:
NumberFormatException : if String cannot be parsed to a int value in given radix.
7. getInteger(): devuelve el objeto Integer que representa el valor asociado con la propiedad del sistema dada o nulo si no existe.
Sintaxis:
public static Integer getInteger(String prop)
Parámetros:
prop : System property
- Otro método sobrecargado que devuelve el segundo argumento si la propiedad no existe, es decir, no devuelve un valor nulo sino un valor predeterminado proporcionado por el usuario.
Sintaxis:
public static Integer getInteger(String prop, int val)
Parámetros:
prop : System property val : value to return if property does not exist.
- Otro método sobrecargado que analiza el valor de acuerdo con el valor devuelto, es decir, si el valor devuelto comienza con «#», entonces se analiza como hexadecimal, si comienza con «0», entonces se analiza como octal, de lo contrario, decimal.
Sintaxis:
public static Integer getInteger(String prop, Integer val)
Parámetros:
prop : System property val : value to return if property does not exist.
8. decode() : devuelve un objeto Integer que contiene el valor decodificado de la string proporcionada. La string proporcionada debe tener el siguiente formato; de lo contrario, se lanzará NumberFormatException-
Decimal- (Signo)Decimal_Number
Hex- (Signo)”0x”Hex_Digits
Hex- (Signo)”0X”Hex_Digits
Octal- (Signo)”0″Octal_Digits
Sintaxis:
public static Integer decode(String s) throws NumberFormatException
Parámetros:
s : encoded string to be parsed into int val
Lanza:
NumberFormatException : If the string cannot be decoded into a int value
9. rotar a la izquierda() : devuelve un int primitivo al rotar los bits que quedan por la distancia dada en forma de complemento a dos del valor dado. Al girar a la izquierda, el bit más significativo se mueve hacia el lado derecho, oa la posición menos significativa, es decir, tiene lugar un movimiento cíclico de bits. La distancia negativa significa rotación a la derecha.
Sintaxis:
public static int rotateLeft(int val, int dist)
Parámetros:
val : int value to be rotated dist : distance to rotate
10. rotarDerecha() : Devuelve un int primitivo rotando los bits a la derecha por la distancia dada en la forma de complemento a dos del valor dado. Cuando gira a la derecha, el bit menos significativo se mueve hacia el lado izquierdo, o la posición más significativa, es decir, tiene lugar un movimiento cíclico de bits. La distancia negativa significa rotación a la izquierda.
Sintaxis:
public static int rotateRight(int val, int dist)
Parámetros:
val : int value to be rotated dist : distance to rotate
Java
// Java program to illustrate
// various Integer methods
public class Integer_test {
public static void main(String args[])
{
int b = 55;
String bb = "45";
// Construct two Integer objects
Integer x = new Integer(b);
Integer y = new Integer(bb);
// toString()
System.out.println("toString(b) = "
+ Integer.toString(b));
// toHexString(),toOctalString(),toBinaryString()
// converts into hexadecimal, octal and binary
// forms.
System.out.println("toHexString(b) ="
+ Integer.toHexString(b));
System.out.println("toOctalString(b) ="
+ Integer.toOctalString(b));
System.out.println("toBinaryString(b) ="
+ Integer.toBinaryString(b));
// valueOf(): return Integer object
// an overloaded method takes radix as well.
Integer z = Integer.valueOf(b);
System.out.println("valueOf(b) = " + z);
z = Integer.valueOf(bb);
System.out.println("ValueOf(bb) = " + z);
z = Integer.valueOf(bb, 6);
System.out.println("ValueOf(bb,6) = " + z);
// parseInt(): return primitive int value
// an overloaded method takes radix as well
int zz = Integer.parseInt(bb);
System.out.println("parseInt(bb) = " + zz);
zz = Integer.parseInt(bb, 6);
System.out.println("parseInt(bb,6) = " + zz);
// getInteger(): can be used to retrieve
// int value of system property
int prop
= Integer.getInteger("sun.arch.data.model");
System.out.println(
"getInteger(sun.arch.data.model) = " + prop);
System.out.println("getInteger(abcd) ="
+ Integer.getInteger("abcd"));
// an overloaded getInteger() method
// which return default value if property not found.
System.out.println(
"getInteger(abcd,10) ="
+ Integer.getInteger("abcd", 10));
// decode() : decodes the hex,octal and decimal
// string to corresponding int values.
String decimal = "45";
String octal = "005";
String hex = "0x0f";
Integer dec = Integer.decode(decimal);
System.out.println("decode(45) = " + dec);
dec = Integer.decode(octal);
System.out.println("decode(005) = " + dec);
dec = Integer.decode(hex);
System.out.println("decode(0x0f) = " + dec);
// rotateLeft and rotateRight can be used
// to rotate bits by specified distance
int valrot = 2;
System.out.println(
"rotateLeft(0000 0000 0000 0010 , 2) ="
+ Integer.rotateLeft(valrot, 2));
System.out.println(
"rotateRight(0000 0000 0000 0010,3) ="
+ Integer.rotateRight(valrot, 3));
}
}
Producción:
toString(b) = 55 toHexString(b) =37 toOctalString(b) =67 toBinaryString(b) =110111 valueOf(b) = 55 ValueOf(bb) = 45 ValueOf(bb,6) = 29 parseInt(bb) = 45 parseInt(bb,6) = 29 getInteger(sun.arch.data.model) = 64 getInteger(abcd) =null getInteger(abcd,10) =10 decode(45) = 45 decode(005) = 5 decode(0x0f) = 15 rotateLeft(0000 0000 0000 0010 , 2) =8 rotateRight(0000 0000 0000 0010,3) =1073741824
11. byteValue() : devuelve un valor de byte correspondiente a este objeto entero.
Sintaxis:
public byte byteValue()
12. shortValue() : devuelve un valor corto correspondiente a este objeto entero.
Sintaxis:
public short shortValue()
13. intValue() : devuelve un valor int correspondiente a este objeto entero.
Sintaxis:
public int intValue()
13. longValue() : devuelve un valor largo correspondiente a este objeto entero.
Sintaxis:
public long longValue()
14. doubleValue() : devuelve un valor doble correspondiente a este objeto entero.
Sintaxis:
public double doubleValue()
15. floatValue() : devuelve un valor flotante correspondiente a este objeto entero.
Sintaxis:
public float floatValue()
16. hashCode() : devuelve el código hash correspondiente a este objeto entero.
Sintaxis:
public int hashCode()
17. bitcount() : Devuelve el número de bits establecidos en complemento a dos del entero dado.
Sintaxis:
public static int bitCount(int i)
Parámetros:
i : int value whose set bits to count
18. numberOfLeadingZeroes() : Devuelve el número de 0 bits que preceden al 1 bit más alto en forma de complemento de dos del valor, es decir, si el número en forma de complemento de dos es 0000 1010 0000 0000, entonces esta función devolverá 4.
Sintaxis:
public static int numberofLeadingZeroes(int i)
Parámetros:
i : int value whose leading zeroes to count in twos complement form
19. numberOfTrailingZeroes() : Devuelve el número de 0 bits que siguen al último 1 bit en forma de complemento a dos del valor, es decir, si el número en forma de complemento a dos es 0000 1010 0000 0000, entonces esta función devolvería 9.
Sintaxis:
public static int numberofTrailingZeroes(int i)
Parámetros:
i : int value whose trailing zeroes to count in twos complement form
20.highOneBit() : Devuelve un valor con un solo bit como máximo, en la posición del bit más alto en el valor dado. Devuelve 0 si el valor dado es 0, es decir, si el número es 0000 0000 0000 1111, entonces esta función devuelve 0000 0000 0000 1000 (uno como máximo un bit en el número dado)
Sintaxis:
public static int highestOneBit(int i)
Parámetros:
i : int value
21. LowestOneBit() : Devuelve un valor con un solo bit como máximo, en la posición del bit más bajo en el valor dado. Devuelve 0 si el valor dado es 0, es decir, si el número es 0000 0000 0000 1111, entonces esta función devuelve 0000 0000 0000 0001 (uno como máximo un bit en el número dado)
Sintaxis:
public static int LowestOneBit(int i)
Parámetros:
i : int value
22. equals() : Se utiliza para comparar la igualdad de dos objetos Integer. Este método devuelve verdadero si ambos objetos contienen el mismo valor int. Debe usarse solo si se verifica la igualdad. En todos los demás casos, se debe preferir el método compareTo.
Sintaxis:
public boolean equals(Object obj)
Parámetros:
obj : object to compare with
23. compareTo() : se utiliza para comparar dos objetos enteros en busca de igualdad numérica. Esto debe usarse cuando se comparan dos valores enteros para la igualdad numérica, ya que diferenciaría entre valores menores y mayores. Devuelve un valor menor que 0,0, un valor mayor que 0 para menor que, igual a y mayor que.
Sintaxis:
public int compareTo(Integer b)
Parámetros:
b : Integer object to compare with
24. compare() : se utiliza para comparar dos valores int primitivos para la igualdad numérica. Como es un método estático, por lo tanto, se puede usar sin crear ningún objeto de Integer.
Sintaxis:
public static int compare(int x,int y)
Parámetros:
x : int value y : another int value
25. signum() : devuelve -1 para valores negativos, 0 para 0 y +1 para valores mayores que 0.
Sintaxis:
public static int signum(int val)
Parámetros:
val : int value for which signum is required.
26. reverse() : devuelve un valor int primitivo invirtiendo el orden de los bits en forma de complemento a dos del valor int dado.
Sintaxis:
public static int reverseBytes(int val)
Parámetros:
val : int value whose bits to reverse in order.
27. reverseBytes() : devuelve un valor int primitivo invirtiendo el orden de los bytes en forma de complemento a dos del valor int dado.
Sintaxis:
public static int reverseBytes(int val)
Parámetros:
val : int value whose bits to reverse in order.
28. static int compareUnsigned(int x, int y) : este método compara dos valores int numéricamente tratando los valores como sin signo.
Sintaxis:
public static int compareUnsigned(int x, int y)
29. static int divideUnsigned(int dividend, int divisor) : este método devuelve el cociente sin signo de dividir el primer argumento por el segundo donde cada argumento y el resultado se interpretan como un valor sin signo.
Sintaxis:
public static int divideUnsigned(int dividend, int divisor)
30. static int max(int a, int b) : este método devuelve el mayor de dos valores int como si llamara a Math.max.
Sintaxis:
public static int max(int a, int b)
31. static int min(int a, int b) : este método devuelve el menor de dos valores int como si llamara a Math.min.
Sintaxis:
public static int min(int a, int b)
32. static int parseUnsignedInt(CharSequence s, int beginIndex, int endIndex, int radix) : este método analiza el argumento CharSequence como un int sin signo en la base especificada, comenzando en el beginIndex especificado y extendiéndose hasta endIndex – 1.
Sintaxis:
public static int parseUnsignedInt(CharSequence s,
int beginIndex,
int endIndex,
int radix)
throws NumberFormatException
33. static int parseUnsignedInt(String s) : este método analiza el argumento de string como un entero decimal sin signo.
Sintaxis:
public static int parseUnsignedInt(String s) throws NumberFormatException
34. static int parseUnsignedInt(String s, int radix) : este método analiza el argumento de string como un entero sin signo en la base especificada por el segundo argumento.
Sintaxis:
public static int parseUnsignedInt(String s,
int radix)
throws NumberFormatException
35. static int restUnsigned(int dividend, int divisor) : este método devuelve el resto sin signo de dividir el primer argumento por el segundo donde cada argumento y el resultado se interpretan como un valor sin signo.
Sintaxis:
public static int remainderUnsigned(int dividend, int divisor)
36. static int sum(int a, int b) : este método suma dos números enteros según el operador +.
Sintaxis:
public static int sum(int a, int b)
37. static long toUnsignedLong(int x) : este método convierte el argumento en un largo mediante una conversión sin firmar.
Sintaxis:
public static long toUnsignedLong(int x)
38. static String toUnsignedString(int i) : este método devuelve una representación de string del argumento como un valor decimal sin signo.
Sintaxis:
public static String toUnsignedString(int i, int radix)
Java
// Java program to illustrate
// various Integer class methods
public class Integer_test {
public static void main(String args[])
{
int b = 55;
String bb = "45";
// Construct two Integer objects
Integer x = new Integer(b);
Integer y = new Integer(bb);
// xxxValue can be used to retrieve
// xxx type value from int value.
// xxx can be int,byte,short,long,double,float
System.out.println("bytevalue(x) = "
+ x.byteValue());
System.out.println("shortvalue(x) = "
+ x.shortValue());
System.out.println("intvalue(x) = " + x.intValue());
System.out.println("longvalue(x) = "
+ x.longValue());
System.out.println("doublevalue(x) = "
+ x.doubleValue());
System.out.println("floatvalue(x) = "
+ x.floatValue());
int value = 45;
// bitcount() : can be used to count set bits
// in twos complement form of the number
System.out.println("Integer.bitcount(value)="
+ Integer.bitCount(value));
// numberOfTrailingZeroes and numberOfLeadingZeroes
// can be used to count prefix and postfix sequence
// of 0
System.out.println(
"Integer.numberOfTrailingZeros(value)="
+ Integer.numberOfTrailingZeros(value));
System.out.println(
"Integer.numberOfLeadingZeros(value)="
+ Integer.numberOfLeadingZeros(value));
// highestOneBit returns a value with one on highest
// set bit position
System.out.println("Integer.highestOneBit(value)="
+ Integer.highestOneBit(value));
// highestOneBit returns a value with one on lowest
// set bit position
System.out.println("Integer.lowestOneBit(value)="
+ Integer.lowestOneBit(value));
// reverse() can be used to reverse order of bits
// reverseBytes() can be used to reverse order of
// bytes
System.out.println("Integer.reverse(value)="
+ Integer.reverse(value));
System.out.println("Integer.reverseBytes(value)="
+ Integer.reverseBytes(value));
// signum() returns -1,0,1 for negative,0 and
// positive values
System.out.println("Integer.signum(value)="
+ Integer.signum(value));
// hashcode() returns hashcode of the object
int hash = x.hashCode();
System.out.println("hashcode(x) = " + hash);
// equals returns boolean value representing
// equality
boolean eq = x.equals(y);
System.out.println("x.equals(y) = " + eq);
// compare() used for comparing two int values
int e = Integer.compare(x, y);
System.out.println("compare(x,y) = " + e);
// compareTo() used for comparing this value with
// some other value
int f = x.compareTo(y);
System.out.println("x.compareTo(y) = " + f);
}
}
Producción :
bytevalue(x) = 55 shortvalue(x) = 55 intvalue(x) = 55 longvalue(x) = 55 doublevalue(x) = 55.0 floatvalue(x) = 55.0 Integer.bitcount(value)=4 Integer.numberOfTrailingZeros(value)=0 Integer.numberOfLeadingZeros(value)=26 Integer.highestOneBit(value)=32 Integer.lowestOneBit(value)=1 Integer.reverse(value)=-1275068416 Integer.reverseBytes(value)=754974720 Integer.signum(value)=1 hashcode(x) = 55 x.equals(y) = false compare(x,y) = 1 x.compareTo(y) = 1
Inicialización de la clase contenedora Integer en Java:
Tipo 1: inicializando directamente:
Se creará un objeto constante de clase Integer dentro del espacio de constantes en la memoria del montón. Espacio de constantes: es solo imaginar para una mejor comprensión que hay algo de espacio para las constantes en la memoria del montón.
Ejemplo:
Integer x = 200; //initializing directly x = 300; //modifying x x = 10; //modifying x again
Entero x = 200
- El compilador convierte la declaración anterior en: Integer x=Integer.valueOf(200) . Esto se conoce como “Autoboxeo” . El valor entero primitivo 200 se convierte en un objeto.
(Para comprender Autoboxing y Unboxing, consulte aquí: https://www.geeksforgeeks.org/autoboxing-unboxing-java/ )
- x apunta a 200 que está presente en el espacio de constantes. Consulte la figura 1.
Figura 1
x = 300
- El autoboxing se realiza nuevamente porque x es un objeto de clase Integer que se inicializa directamente.
- Nota: El objeto inicializado directamente (x) no se puede modificar ya que es una constante. Cuando tratamos de modificar el objeto apuntando a una nueva constante (300), la constante anterior (200) estará presente en la memoria del montón, pero el objeto apuntará a la nueva constante.
- x apunta a 300 que está presente en el espacio de constantes. Consulte la figura 2.
Figura 2
X = 10
- Nota: De forma predeterminada, para los valores -128 a 127, el método Integer.valueOf() no creará una nueva instancia de Integer. Devuelve un valor de su caché.
- x puntos 10 que está presente en caché.
Fig. 3
Si asignamos x = 200 o x = 300 la próxima vez, apuntará al valor 200 o 300 que ya está presente en el espacio de constantes. Si asignamos valores a x distintos de estos dos valores, entonces crea una nueva constante.
(Consulte el tema de comparación de clases de envoltura de enteros para una mejor comprensión)
Tipo 2: inicializando dinámicamente:
Un objeto de clase Integer que no sea una constante se creará fuera del espacio de las constantes. También crea una constante entera dentro del espacio de constantes. La variable apuntará al objeto Integer y no a la constante Integer.
Ejemplo:
Integer a = new Integer(250); //Initializing dynamically a = 350; //Type 1 initialization
Entero a = nuevo Entero (250)
- 250 se crea dentro y fuera del espacio de las constantes. La variable ‘a’ estará señalando el valor que está fuera del espacio de constantes. Consulte la figura 4.
Figura 4
a = 350;
- Después del autoboxing, ‘a’ apuntará a 350. Consulte la Fig. 5.
Figura 5
Si asignamos a = 250 la próxima vez, no apuntará al objeto ya presente con el mismo valor, creará un nuevo objeto.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Referencias: documentación oficial de Java
Este artículo es una contribución de Rishabh Mahrsee . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA