¿Cuál es la diferencia entre un int y un entero en Java y C #?

Estaba leyendo Más Joel sobre software cuando me encontré con Joel Spolsky diciendo algo acerca de un tipo particular de progtwigdor que conocía la diferencia entre un int y un Integer en Java / C # (lenguajes de progtwigción orientados a objetos).

¿Entonces cuál es la diferencia?

En Java, el tipo ‘int’ es una primitiva, mientras que el tipo ‘Integer’ es un objeto.

En C #, el tipo ‘int’ es el mismo que System.Int32 y es un tipo de valor (es decir, más parecido al java ‘int’). Un entero (al igual que cualquier otro tipo de valor) se puede encajonar (“envolver”) en un objeto.


Las diferencias entre los objetos y las primitivas están más allá del scope de esta pregunta, pero para resumir:

Los objetos proporcionan facilidades para el polymorphism, se pasan por referencia (o más exactamente tienen referencias pasadas por valor) y se asignan desde el montón . Por el contrario, los primitivos son tipos inmutables que se pasan por valor y a menudo se asignan desde la stack .

Bueno, en Java una int es una primitiva, mientras que un entero es un objeto. Es decir, si creó un nuevo entero:

 Integer i = new Integer(6); 

Puedes llamar a algún método en i:

 String s = i.toString();//sets s the string representation of i 

Mientras que con un int:

 int i = 6; 

No puede llamar a ningún método, porque es simplemente un primitivo. Asi que:

 String s = i.toString();//will not work!!! 

produciría un error, porque int no es un objeto.

int es uno de los pocos primitivos en Java (junto con char y algunos otros). No estoy 100% seguro, pero estoy pensando que el objeto entero más o menos solo tiene una propiedad int y un montón de métodos para interactuar con esa propiedad (como el método toString () por ejemplo). Así que Integer es una forma elegante de trabajar con un int (así como quizás String es una forma elegante de trabajar con un grupo de caracteres).

Sé que Java no es C, pero como nunca he progtwigdo en C, esto es lo más cerca que pude llegar a la respuesta. ¡Espero que esto ayude!

Objeto entero javadoc

Integer Ojbect vs. int primitive comparison

Agregaré las excelentes respuestas dadas anteriormente y hablaré sobre boxeo y desempaquetado, y cómo esto se aplica a Java (aunque C # también lo tiene). Usaré solo la terminología de Java, porque estoy más al día con eso.

Como las respuestas mencionadas, int es solo un número (llamado el tipo unboxed ), mientras que Integer es un objeto (que contiene el número, por lo tanto, un tipo encuadrado ). En términos de Java, eso significa (aparte de no poder llamar a los métodos en int ), no puede almacenar int u otros tipos de no objetos en colecciones ( List , Map , etc.). Para poder almacenarlos, primero debe colocarlos en su tipo en caja correspondiente.

Java 5 en adelante tiene algo llamado auto-boxing y auto-unboxing que permite que el boxeo / unboxing se haga detrás de las escenas. Comparar y contrastar: versión de Java 5:

 Deque queue; void add(int n) { queue.add(n); } int remove() { return queue.remove(); } 

Java 1.4 o anterior (tampoco generics):

 Deque queue; void add(int n) { queue.add(Integer.valueOf(n)); } int remove() { return ((Integer) queue.remove()).intValue(); } 

Cabe señalar que a pesar de la brevedad en la versión de Java 5, ambas versiones generan bytecode idéntico. Por lo tanto, aunque el auto-boxing y el auto-unboxing son muy convenientes porque usted escribe menos código, estas operaciones ocurren detrás de escena, con los mismos costos de tiempo de ejecución, por lo que aún debe ser consciente de su existencia.

¡Espero que esto ayude!

Solo publicaré aquí porque algunas de las otras publicaciones son ligeramente inexactas en relación con C #.

Correcto: int es un alias para System.Int32 .
Incorrecto: float no es un alias para System.Float , sino para System.Single

Básicamente, int es una palabra clave reservada en el lenguaje de progtwigción C # y es un alias para el tipo de valor System.Int32 .

Float y Float no son lo mismo, sin embargo, dado que el tipo de sistema correcto para ” float ” es System.Single. Hay algunos tipos como este que tienen palabras clave reservadas que no parecen coincidir directamente con los nombres de los tipos.

En C # no hay diferencia entre ” int ” y ” System.Int32 ”, o cualquiera de los otros pares o palabras clave / tipos de sistema, excepto cuando se definen enums. Con las enumeraciones, puede especificar el tamaño de almacenamiento que desea usar y, en este caso, solo puede usar la palabra clave reservada, y no el nombre del tipo de tiempo de ejecución del sistema.

Si el valor en el int se almacenará en la stack, en la memoria, o como un objeto de montón referenciado depende del contexto y cómo lo usa.

Esta statement en un método:

 int i; 

define una variable i de tipo System.Int32 , que vive en un registro o en la stack, dependiendo de las optimizaciones. La misma statement en un tipo (estructura o clase) define un campo de miembro. La misma statement en una lista de argumentos de método define un parámetro, con las mismas opciones de almacenamiento que para una variable local. (tenga en cuenta que este párrafo no es válido si comienza a usar métodos de iteración en la mezcla, estas son bestias diferentes por completo)

Para obtener un objeto de montón, puede usar el boxeo:

 object o = i; 

esto creará una copia en caja del contenido de i en el montón. En IL, puede acceder a los métodos en el objeto Heap directamente, pero en C # necesita volver a convertirlo en int, lo que creará otra copia. Por lo tanto, el objeto en el montón no se puede cambiar fácilmente en C # sin crear una nueva copia encuadrada de un nuevo valor int. (Ugh, este párrafo no lee todo eso fácilmente).

Con respecto a Java 1.5 y al autoboxing, existe una importante “peculiaridad” que se presenta cuando se comparan los objetos enteros.

En Java, los objetos enteros con los valores -128 a 127 son inmutables (es decir, para un valor entero particular, por ejemplo 23, todos los objetos enteros instanciados a través de su progtwig con el valor 23 puntos para el mismo objeto exacto ).

Ejemplo, esto devuelve verdadero:

 Integer i1 = new Integer(127); Integer i2 = new Integer(127); System.out.println(i1 == i2); // true 

Si bien esto devuelve falso:

 Integer i1 = new Integer(128); Integer i2 = new Integer(128); System.out.println(i1 == i2); // false 

El == se compara por referencia (¿las variables apuntan al mismo objeto)?

Este resultado puede diferir o no según la JVM que esté utilizando. La especificación de autoboxing para Java 1.5 requiere que los enteros (-128 a 127) siempre encajen en el mismo objeto contenedor.

¿Una solución? =) Siempre se debe usar el método Integer.equals () al comparar objetos enteros.

 System.out.println(i1.equals(i2)); // true 

Más información en java.net Ejemplo en bexhuff.com

En Java hay dos tipos básicos en la JVM . 1) tipos primitivos y 2) tipos de referencia. int es un tipo primitivo y entero es un tipo de clase (que es una especie de tipo de referencia).

Los valores primitivos no comparten estado con otros valores primitivos. Una variable cuyo tipo es un tipo primitivo siempre contiene un valor primitivo de ese tipo.

 int aNumber = 4; int anotherNum = aNumber; aNumber += 6; System.out.println(anotherNum); // Prints 4 

Un objeto es una instancia de clase creada dinámicamente o una matriz. Los valores de referencia (a menudo solo referencias) son punteros a estos objetos y una referencia nula especial, que se refiere a ningún objeto. Puede haber muchas referencias al mismo objeto.

 Integer aNumber = Integer.valueOf(4); Integer anotherNumber = aNumber; // anotherNumber references the // same object as aNumber 

También en Java todo se pasa por valor. Con los objetos, el valor que se pasa es la referencia al objeto. Entonces, otra diferencia entre int e Integer en Java es cómo se pasan en las llamadas a métodos. Por ejemplo en

 public int add(int a, int b) { return a + b; } final int two = 2; int sum = add(1, two); 

La variable dos se pasa como el tipo entero primitivo tipo 2. Mientras que en

 public int add(Integer a, Integer b) { return a.intValue() + b.intValue(); } final Integer two = Integer.valueOf(2); int sum = add(Integer.valueOf(1), two); 

La variable dos se pasa como referencia a un objeto que contiene el valor entero 2.


@WolfmanDragon: pasar por referencia funcionaría así:

 public void increment(int x) { x = x + 1; } int a = 1; increment(a); // a is now 2 

Cuando se llama al incremento, pasa una referencia (puntero) a la variable a . Y la función de incremento modifica directamente la variable a .

Y para los tipos de objeto funcionaría de la siguiente manera:

 public void increment(Integer x) { x = Integer.valueOf(x.intValue() + 1); } Integer a = Integer.valueOf(1); increment(a); // a is now 2 

¿Ves la diferencia ahora?

En C #, int es solo un alias para System.Int32 , string para System.String , double para System.Double etc …

Personalmente prefiero int, string, double, etc. porque no requieren un using System; statement 🙂 Una razón tonta, lo sé …

En plataformas como Java, int s son primitivas, mientras que Integer es un objeto que contiene un campo entero. La distinción importante es que los primitivos siempre se transmiten por valor y, por definición, son inmutables.

Cualquier operación que involucre una variable primitiva siempre devuelve un nuevo valor. Por otro lado, los objetos se pasan por referencia. Se podría argumentar que el punto del objeto (también conocido como la referencia) también se está pasando por valor, pero los contenidos no lo están.

Hay muchas razones para usar clases de contenedor:

  1. Obtenemos un comportamiento adicional (por ejemplo, podemos usar métodos)
  2. Podemos almacenar valores nulos mientras que en primitivos no podemos
  3. Las colecciones admiten almacenar objetos y no primitivas.

Esto ya ha sido respondido para Java, esta es la respuesta de C #:

“Entero” no es un nombre de tipo válido en C # e “int” es solo un alias para System.Int32. Además, a diferencia de Java (o C ++), no hay ningún tipo primitivo especial en C #, cada instancia de un tipo en C # (incluido int) es un objeto. Aquí hay un código demostrativo:

 void DoStuff() { System.Console.WriteLine( SomeMethod((int)5) ); System.Console.WriteLine( GetTypeName() ); } string SomeMethod(object someParameter) { return string.Format("Some text {0}", someParameter.ToString()); } string GetTypeName() { return (typeof (T)).FullName; } 

int se usa para declarar variable primitiva

 eg int i=10; 

Entero se utiliza para crear la variable de referencia de la clase Entero

 Integer a = new Integer(); 

Java:

int , double , long , byte , float , double , short , boolean , char – primitivas. Se utiliza para mantener los tipos de datos básicos admitidos por el idioma. los tipos primitivos no son parte de la jerarquía de objetos, y no heredan Object. No se puede pasar por referencia a un método.

Double , Float , Long , Integer , Short , Byte , Character y Boolean , son tipo Wrappers, empaquetados en java.lang . Todas las envolturas de tipo numérico definen constructores que permiten que un objeto se construya a partir de un valor dado, o una representación de cadena de ese valor. Usar objetos puede agregar una sobrecarga incluso al más simple de los cálculos.

A partir de JDK 5, Java ha incluido dos características muy útiles: autoboxing y autounboxing. El autoboxing / unboxing simplifica y agiliza en gran medida el código que debe convertir los tipos primitivos en objetos, y viceversa.

Ejemplo de constructores:

 Integer(int num) Integer(String str) throws NumberFormatException Double(double num) Double(String str) throws NumberFormatException 

Ejemplo de boxeo / unboxing:

 class ManualBoxing { public static void main(String args[]) { Integer objInt = new Integer(20); // Manually box the value 20. int i = objInt.intValue(); // Manually unbox the value 20 System.out.println(i + " " + iOb); // displays 20 20 } } 

Ejemplo de autoboxing / autounboxing:

 class AutoBoxing { public static void main(String args[]) { Integer objInt = 40; // autobox an int int i = objInt ; // auto-unbox System.out.println(i + " " + iOb); // displays 40 40 } } 

El libro de PS Herbert Schildt fue tomado como referencia.

Una cosa más que no veo en las respuestas anteriores: en Java, se supone que las clases de envoltorios primitivos como Integer, Double, Float, Boolean … y String son invariables, de modo que cuando pasas una instancia de esas clases invocado método no podría alterar sus datos de ninguna manera, en oposición con la mayoría de las otras clases, que los datos internos podrían ser alterados por sus métodos públicos. De modo que esta clase solo tiene métodos ‘getter’, no ‘setters’, además del constructor.

En un progtwig Java, los literales de cadena se almacenan en una parte separada de la memoria de stack, solo una instancia de literal, para ahorrar memoria y reutilizar esas instancias.

¿Alguna vez has progtwigdo antes? (int) es uno de los tipos primitivos que puedes establecer para tus variables (como char, float, …).

pero Integer es una clase contenedora que puede usar para realizar algunas funciones en una variable int (por ejemplo, convertirla en cadena o viceversa, …), pero tenga en cuenta que los métodos en las clases contenedoras son estáticos para que pueda usarlos en cualquier momento sin crear una instancia de clase Integer. como resumen:

 int x; Integer y; 

xey son ambas variables de tipo int pero y está envuelto por una clase Integer y tiene varios métodos que usted usa, pero en caso de que necesite llamar a algunas funciones de la clase contenedora Integer, puede hacerlo de manera simple.

 Integer.toString(x); 

pero tenga en cuenta que tanto x como y son corect, pero si desea usarlos solo como un tipo primitivo, use la forma simple (usada para definir x).

Una variable int contiene un valor entero con signo de 32 bits. Un Entero (con mayúscula I) contiene una referencia a un objeto de (clase) tipo Entero, o nulo.

Java lanza automáticamente entre los dos; de entero a int siempre que el objeto entero se presente como un argumento para un operador int o se asigne a una variable int, o se asigne un valor int a una variable entero. Este casting se llama boxeo / unboxing.

Si una variable entera que hace referencia a null se desempaqueta, explícita o implícitamente, se lanza una NullPointerException.

Un int y un entero en Java y C # son dos términos diferentes que se usan para representar cosas diferentes. Es uno de los tipos de datos primitivos que se pueden asignar a una variable que puede almacenar exactamente. Un valor de su tipo declarado a la vez.

Por ejemplo:

 int number = 7; 

Donde int es el tipo de datos asignado al número variable que contiene el valor siete. Entonces, un int es solo un primitivo, no un objeto.

Mientras que un Integer es una clase contenedora para un tipo de datos primitivo que tiene métodos estáticos. Esto se puede usar como un argumento para un método que requiere un objeto, donde como int se puede usar como un argumento para un método que requiere un valor entero, que se puede usar para la expresión aritmética.

Por ejemplo:

 Integer number = new Integer(5); 

En ambos idiomas (Java y C #) int es un entero de 4 bytes con signo.

A diferencia de Java, C # proporciona valores enteros firmados y no firmados. Como Java y C # son objetos orientados a objetos, algunas operaciones en estos idiomas no se asignan directamente a las instrucciones proporcionadas por el tiempo de ejecución, por lo que deben definirse como parte de un objeto de algún tipo.

C # proporciona System.Int32 que es un tipo de valor que utiliza una parte de la memoria que pertenece al tipo de referencia en el montón.

java proporciona java.lang.Integer que es un tipo de referencia que opera en int . Los métodos en Integer no se pueden comstackr directamente para ejecutar instrucciones de tiempo. Así que colocamos un valor int para convertirlo en una instancia de Integer y usamos los métodos que esperan una instancia de algún tipo (como toString() , parseInt() , valueOf() etc).

En C #, la variable int se refiere a System.Int32.Any . Cualquier valor de 4 bytes en la memoria se puede interpretar como una primitiva int, que puede ser manipulada por instancia de System.Int32.So int es un alias para System.Int32.When usar enteros, métodos relacionados como int.Parse() , int.ToString() etc. El entero se comstack en FCL System.Int32 struct llamando a los métodos respectivos, como Int32.Parse() , Int32.ToString() .

En Java, el tipo int es un tipo de datos primitivo, mientras que el tipo Integer es un objeto.

En C #, el tipo int también es un tipo de datos igual que System.Int32 . Un integer (al igual que cualquier otro tipo de valor) se puede encajonar (“envolver”) en un objeto.

En Java int es un tipo de datos primitivo, mientras que Integer es una clase Helper, se usa para convertir un tipo de datos a otro.

Por ejemplo:

 double doubleValue = 156.5d; Double doubleObject = new Double(doubleValue); Byte myByteValue = doubleObject.byteValue (); String myStringValue = doubleObject.toString(); 

Los tipos de datos primitivos almacenan la memoria más rápida disponible donde la clase Helper es compleja y se almacena en la memoria Heep.

referencia de “David Gassner” Java Essential Training.

“int” es el tipo de datos primitivo y “entero” en Wrapper Class en Java. “Entero” puede usarse como un argumento para un método que requiere un objeto, donde como “int” puede usarse como un argumento para un método que requiere un valor entero, que se puede usar para la expresión aritmética.

int está predefinido en la función de la biblioteca c # pero en java podemos crear el objeto de Integer

(Versión de Java) En palabras simples int es primitivo y entero es objeto de envoltura para int.

Un ejemplo donde usar Integer vs int, cuando quiera comparar e int otra variable null arrojará un error.

 int a; //assuming a value you are getting from data base which is null if(a ==null) // this is wrong - cannot compare primitive to null { do something...} Instead you will use, Integer a; //assuming a value you are getting from data base which is null if(a ==null) // this is correct/legal { do something...} 

01. El entero puede ser nulo. Pero int no puede ser nulo.

 Integer value1 = null; //OK int value2 = null //Error 

02. Solo puede pasar los valores de tipo de Clases de Contenedor a cualquier clase de colección.

(Clases de Contenedor – Booleano, Carácter, Byte, Corto, Entero, Largo, Flotante, Doble)

 List element = new ArrayList<>(); int valueInt = 10; Integer valueInteger = new Integer(value); element.add(valueInteger); 

¿Pero normalmente agregamos valores primitivos a la clase de colección? ¿Es correcto el punto 02?

 List element = new ArrayList<>(); element.add(5); 

Sí 02 es correcto, beacouse autoboxing.

Autoboxing es la conversión automática que hace el comstackdor java entre el tipo primitivo y su clase contenedora correspondiente.

Luego 5 convertir como valor entero por autoboxing.

En java, según mi conocimiento, si aprendiste entonces, cuando escribes int a; luego, en java generic comstackrá código como Integer a = new Integer() . Entonces, como por genérico no se usa Integer pero se usa int . entonces hay tanta diferencia allí.