¿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 sobre un tipo particular de programador que sabía la diferencia entre anintyIntegeren Java / C # (Lenguajes de programación orientados a objetos).

¿Entonces cuál es la diferencia?

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

En C #, el tipo 'int' es el mismo System.Int32y es un tipo de valor (es decir, más parecido al 'int' de java). Un entero (como cualquier otro tipo de valor) se puede encuadrar ("envolver") en un objeto.

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

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

Bueno, en Java un int es un primitivo, mientras que un entero es un objeto. Es decir, si hiciste un nuevo entero:

Integer i = new Integer(6);

Podría 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 invocar ningún método en él, porque es simplemente un primitivo. Entonces:

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

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

int es una de las pocas primitivas en Java (junto con char y algunos otros). No estoy 100% seguro, pero estoy pensando que el objeto Integer 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). Entonces Integer es una forma elegante de trabajar con un int (tal como String es una forma elegante de trabajar con un grupo de caracteres).

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

Objeto entero javadoc

Entero Ojbect versus comparación primitiva int

Agregaré a las excelentes respuestas dadas anteriormente, y hablaré sobre boxeo y unboxing, 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 au fait con eso.

Como se mencionó en las respuestas, intes solo un número (llamado tipo sin caja ), mientras que Integeres un objeto (que contiene el número, por lo tanto, un tipo en caja ). En términos de Java, que los medios (aparte de no ser capaz de llamar a métodos en int), no se puede almacenar into de otro tipo no-objeto en colecciones ( List, Map, etc.). Para almacenarlos, primero debe encuadrarlos en su tipo encuadrado correspondiente.

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

Deque<Integer> queue;

void add(int n) {
    queue.add(n);
}

int remove() {
    return queue.remove();
}

Java 1.4 o anterior (tampoco genéricos):

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 Java 5, ambas versiones generan un código de bytes idéntico. Por lo tanto, aunque la auto-boxeo y el auto-unboxing son muy convenientes porque se escribe menos código, estas operaciones hacen que sucede detrás de las escenas, con los mismos costes de tiempo de ejecución, por lo que aún tiene que estar al tanto de su existencia.

¡Espero que esto ayude!

Solo publicaré aquí, ya que 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 paraSystem.Single

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

Sin embargo, float y Float no son lo mismo, ya 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 enumeraciones. Con las enumeraciones, puede especificar el tamaño de almacenamiento a utilizar y, en este caso, solo puede usar la palabra clave reservada, y no el nombre del tipo de tiempo de ejecución del sistema.

Ya sea que el valor en int se almacene en la pila, en la memoria o como un objeto de pila referenciado, depende del contexto y de cómo lo use.

Esta declaración en un método:

int i;

define una variable ide tipo System.Int32, que vive en un registro o en la pila, según las optimizaciones. La misma declaración en un tipo (estructura o clase) define un campo miembro. La misma declaración en una lista de argumentos del 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 introducir métodos iteradores en la mezcla, estas son bestias completamente diferentes)

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

object o = i;

esto creará una copia en caja de los contenidos de ien el montón. En IL, puede acceder a los métodos en el objeto de almacenamiento dinámico directamente, pero en C # debe volver a convertirlo en un 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 en caja de un nuevo valor int. (Uf, este párrafo no se lee tan fácilmente).

Con respecto a Java 1.5 y el autoboxing, hay una "peculiaridad" importante que se juega cuando se comparan objetos Integer.

En Java, los objetos enteros con los valores -128 a 127 son inmutables (es decir, para un valor entero particular, digamos 23, todos los objetos enteros instanciados a través de su programa con el valor 23 apuntan exactamente al mismo objeto).

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 o no diferir 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? =) Uno siempre debe usar el método Integer.equals () al comparar objetos Integer.

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 Integer es un tipo de clase (que es un tipo de tipo de referencia).

Los valores primitivos no comparten estado con otros valores primitivos. Una variable cuyo tipo es un tipo primitivo siempre tiene 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 no 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 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 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 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 objetos 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, cadena para System.String, doble para System.Doubleetc.

Personalmente prefiero int, string, double, etc. porque no requieren una using System;declaración :) Una razón tonta, lo sé ...

Hay muchas razones para usar clases de contenedor:

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

Esto ya ha sido respondido para Java, aquí está la respuesta de C #:

"Entero" no es un nombre de tipo válido en C # y "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<int>() );
}

string SomeMethod(object someParameter)
{
    return string.Format("Some text {0}", someParameter.ToString());
}

string GetTypeName<T>()
{
    return (typeof (T)).FullName;
}

int se usa para declarar la variable primitiva

e.g. int i=10;

Integer se usa para crear una variable de referencia de la clase Integer

Integer a = new Integer();

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

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

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 invariantes, de modo que cuando pasa una instancia de esas clases, se invoca El método no podría alterar sus datos de ninguna manera, en oposición con la mayoría de las otras clases, cuyos datos internos podrían ser alterados por sus métodos públicos. Para que esta clase solo tenga métodos 'getter', no 'setters', además del constructor.

En un programa de Java, los literales de cadena se almacenan en una porción separada de la memoria de almacenamiento dinámico, solo una instancia para el literal, para ahorrar memoria reutilizando esas instancias

¿alguna vez has programado antes? (int) es uno de los tipos primitivos que puedes configurar para tus variables (como char, float, ...).

pero Integer es una clase de contenedor 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 de contenedor son estáticos para que pueda usarlos en cualquier momento sin crear una instancia de la clase Integer. como resumen:

int x;
Integer y; 

x e y son variables de tipo int, pero y está envuelto por una clase Integer y tiene varios métodos que puede usar, pero en caso de que necesite llamar a algunas funciones de la clase contenedora Integer, puede hacerlo simplemente.

Integer.toString(x);

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

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 forman 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 de tipo envolturas, envasados en java.lang. Todos los envoltorios de tipo numérico definen constructores que permiten construir un objeto a partir de un valor dado, o una representación de cadena de ese valor. El uso de 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. Autoboxing / unboxing simplifica enormemente y optimiza 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 del PS Herbert Schildt fue tomado como referencia.

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

Java lanza automáticamente entre los dos; de Integer a int cada vez que el objeto Integer ocurre como argumento para un operador int o se asigna a una variable int, o se asigna un valor int a una variable Integer. Este casting se llama boxeo / unboxing.

Si una variable entera que hace referencia a un valor nulo no está en caja, explícita o implícitamente, se genera una excepción NullPointerException.

Un int e Integer 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;

¿Dónde intestá el tipo de datos asignado al número de variable que contiene el valor siete? Entonces, an intes simplemente un primitivo, no un objeto.

Mientras que an Integeres una clase de contenedor para un tipo de datos primitivo que tiene métodos estáticos. Eso se puede usar como argumento de un método que requiere un objeto, mientras que int se puede usar como argumento de 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 lenguajes (Java y C #) inthay un entero con signo de 4 bytes.

A diferencia de Java, C # proporciona valores enteros con y sin signo. Como Java y C # están orientados a objetos, algunas operaciones en estos lenguajes no se asignan directamente a las instrucciones proporcionadas por el tiempo de ejecución y, por lo tanto, deben definirse como parte de un objeto de algún tipo.

C # proporciona System.Int32cuál 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.Integercuál es un tipo de referencia que funciona int. Los métodos en Integerlata no compilarse directamente para ejecutar tiempo instructions.So nos cuadro de un valor int para convertirlo en una instancia de Entero y utilizar los métodos que espera ejemplo de algún tipo (como toString(), parseInt(), valueOf()etc).

En C #, la variable int se refiere al System.Int32.Anyvalor de 4 bytes en la memoria que se puede interpretar como un int primitivo, que se puede manipular mediante la instancia de System.Int32.So int es un alias para System.Int32.Whenusar métodos relacionados con enteros como int.Parse(), int.ToString()etc. la LCF System.Int32struct llamando a los métodos respectivos como Int32.Parse(), Int32.ToString().

En Java, el inttipo es un tipo de datos primitivo, donde el Integertipo es un objeto.

En C #, el inttipo también es un tipo de datos igual que System.Int32. Un integer(como cualquier otro tipo de valor) se puede encuadrar ("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 un tipo de datos primitivo e "Integer" en Wrapper Class en Java. "Entero" puede usarse como argumento para un método que requiere un objeto, mientras que "int" puede usarse como argumento para un método que requiere un valor entero, que puede usarse para la expresión aritmética.

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

Integer value1 = null; //OK

int value2 = null      //Error

02. Solo se pueden pasar valores de tipo Wrapper Classes a cualquier clase de colección.

(Clases de envoltura: booleana, carácter, byte, corto, entero, largo, flotante, doble)

List<Integer> 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<Integer> element = new ArrayList<>();
element.add(5);

Sí 02 es correcto, porque autoboxing.

Autoboxing es la conversión automática que realiza el compilador de Java entre el tipo primitivo y su clase de contenedor correspondiente.

Luego 5 convertir como valor entero mediante autoboxing.

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

(Versión Java) En palabras simples, int es primitivo e Integer es un objeto contenedor para int.

Un ejemplo de dónde usar Integer vs int, cuando desee comparar y la variable int nuevamente sea nula, 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...}

En Java, según mi conocimiento, si usted aprende entonces, cuando escribe int a; entonces en java generic compilará código como Integer a = new Integer(). Entonces, según los genéricos, Integerno se usa, pero intse usa. así que hay tanta diferencia allí.

int es un tipo de datos primitivo. Integer es una clase de contenedor. Puede almacenar datos int como objetos.

int es un tipo de datos primitivo, mientras que Integer es un objeto. Crear un objeto con Integer le dará acceso a todos los métodos disponibles en la clase Integer. Pero, si crea un tipo de datos primitivo con int, no podrá usar esos métodos incorporados y tendrá que definirlos usted mismo. Pero, si no desea ningún otro método y desea hacer que el programa sea más eficiente en la memoria, puede usar un tipo de datos primitivo porque crear un objeto aumentará el consumo de memoria.