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

Bueno, en Java un int es un primitivo mientras que un Entero es un Objeto. Es decir, si usted hizo un nuevo entero:

Integer i = new Integer(6);

Podrías llamar a algún método en i:

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

Considerando que con un int:

int i = 6;

No se puede llamar a 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 Integer object 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 (al igual que quizás 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 vs int comparación primitiva

Agregaré a las excelentes respuestas dadas anteriormente, y hablaré sobre el boxeo y el unboxing, y cómo esto se aplica a Java (aunque C# también lo tiene). Voy a utilizar sólo la terminología Java, porque soy más au fait 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 boxed). En términos de Java, eso significa (aparte de no poder llamar a métodos en int), no se puede almacenar int u otros tipos no objeto en colecciones (List, Map, etc.). Para almacenarlos, primero debe encajonarlos en su tipo de caja correspondiente.

Java 5 en adelante tiene algo llamado auto-boxing y auto-unboxing que permiten que el boxeo/unboxing se realice detrás de escena. Comparar y contrastar: Java 5 version:

Deque<Integer> queue;

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

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

Java 1.4 o anterior (sin genéricos tampoco):

Deque queue;

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

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

Hay que señalar que a pesar de la brevedad en la Versión Java 5, ambas versiones generan bytecode idéntico. Por lo tanto, aunque el auto-boxing y el auto-unboxing es muy conveniente porque se 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!

Simplemente 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 para System.Single

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

Float y Float no es lo mismo, ya que el tipo de sistema correcto para "float" es System.Solo. Hay algunos tipos como esto que tiene palabras clave reservadas que no parecen coincidir con los nombres de tipo directamente.

En C# no hay diferencia entre "int" y "System.Int32", o cualquiera de los otros pares o tipos de palabras clave/sistema, excepto cuando se definen enumeraciones. Con enumeraciones puede especificar el tamaño de almacenamiento a 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 pila, en memoria o como un montón referenciado el objeto depende del contexto y de cómo lo uses.

Esta declaración en un método:

int i;

Define una variable i de tipo System.Int32, que vive en un registro o en la pila, dependiendo de las optimizaciones. La misma declaración en un tipo (struct o clase) define un campo miembro. La misma declaración 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 extraer los métodos iteradores en la mezcla, estos son diferentes bestias en conjunto)

Para obtener un objeto heap, puede usar boxeo:

object o = i;

Esto creará una copia en caja del contenido de i en el montón. En IL puede acceder directamente a los métodos del objeto heap, pero en C# necesita volver a enviarlo a un int, 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. (Ugh, este párrafo no lee todo eso facilmente.)

Con respecto a Java 1.5 y autoboxing hay una "peculiaridad" importante que viene a jugar cuando se comparan objetos enteros.

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 al exacto mismo objeto).

Ejemplo, esto devuelve true:

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

Mientras que esto devuelve false:

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

El = = compara por referencia (las variables apuntan al mismo objeto).

Este resultado puede o no diferir dependiendo de qué JVM esté utilizando. La especificación autoboxing para Java 1.5 requiere que los enteros (-128 a 127) siempre encajonen en el mismo objeto de envoltura.

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

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

Más info 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 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 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 null 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 objetos el valor que se pasa es la referencia al objeto. Así que otra diferencia entre int y Integer en Java es cómo se pasan en llamadas de método. Por ejemplo, en

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

La variable two se pasa como el entero primitivo tipo 2. Considerando 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 two 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 increment 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 una alias para System.Int32, cadena para System.String, doble para System.Double etc...

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

En plataformas como Java, ints 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 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 está pasando por valor, pero el contenido no lo es.

Hay muchas razones para usar clases wrapper:

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 de primitivas.

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

"Integer" 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# (incluyendo 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 utiliza para crear la variable de referencia de la clase Integer

Integer a = new Integer();

Java:

int, double, long, byte, float, double, short, boolean, char - primitivas. Utilizado para mantener los tipos de datos básicos soportado por el idioma. los tipos primitivos no son parte de la jerarquía de objetos, y no heredan Objeto. Puede pasarse por referencia a un método.

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

Comenzando con JDK 5, Java ha incluido dos características muy útiles: autoboxing y auto-boxing. Autoboxing / unboxing simplifica y agiliza enormemente el código que debe convertir 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
    }
}

P.D. El libro de Herbert Schildt fue tomado como referencia.

Una cosa más que no veo en las respuestas anteriores: En Java las clases de envoltorios primitivos como Integer, Double, Float, Boolean... y se supone que las cadenas son invariantes, de modo que cuando se pasa una instancia de esas clases el método invocado 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. De modo que esta clase solo tiene métodos 'getter', no 'setters', además del constructor.

En java los literales de cadena de programa se almacenan en una porción separada de la memoria del montón, solo una instancia para literal, para guardar la memoria reutilizando esas instancias

¿Alguna vez ha programado antes entonces (int) es uno de los tipos primitivos que puede establecer para sus variables (al igual que char, float,...).

Pero Integer es una clase de envoltura que se puede utilizar para hacer algunas funciones en una variable int (por ejemplo, convertir a cadena o viceversa,...), pero tenga en cuenta que los métodos en las clases wrapper son estáticos, por lo que puede usarlos en cualquier momento sin crear una instancia de 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 se utilizan, pero si necesita llamar a algunas funciones de la clase Integer wrapper puede hacerlo simplemente.

Integer.toString(x);

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

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

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

Si una variable entera que hace referencia a null no está empaquetada, explícitamente o implícitamente, se lanza una excepción NullPointerException.

Un int y un Entero en Java y C# son dos términos diferentes utilizados 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 de variable que contiene el valor siete. Así que un int es solo un primitivo no un objeto.

Mientras que un Integer es una clase de envoltura para un dato primitivo tipo que tiene métodos estáticos. Esto puede ser usado como argumento para un método que requiere un objeto, donde as int puede ser usado como argumento para un método que requiere un valor entero, que puede ser usado para una expresión aritmética.

Por ejemplo:

Integer number = new Integer(5);

En ambos lenguajes (Java y C#) int es 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.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 compilar directamente en tiempo de ejecución instructions.So encajonamos un valor int para convertirlo en una instancia de Integer y usamos los métodos que esperan instancia de algún tipo (como toString(), parseInt(), valueOf() etc).

En C # la variable int se refiere a System.Int32.Any el valor de 4 bytes en memoria puede interpretarse como un int primitivo, que puede ser manipulado por instancia de System.Int32.So int es un alias para System.Int32.When usando métodos relacionados con enteros como int.Parse(), int.ToString() etc. Integer se compila en la estructura FCL System.Int32 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 es también un tipo de datos igual que System.Int32. Un integer (al igual que cualquier otro tipo de valor) puede ser encajonado ("envuelto") en un objeto.

En Java int es un tipo de datos primitivo, mientras que Integer es una clase auxiliar, 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 Auxiliar es compleja y se almacenan en la memoria heep.

Referencia de "David Gassner" Java Essential Training.

"int" es un tipo de datos primitivo y "Integer" en la clase Wrapper en Java. "Integer "se puede utilizar como argumento para un método que requiere un objeto, donde como" int " se puede utilizar como argumento para un método que requiere un valor entero, que se puede utilizar para la expresión aritmética.

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

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

Un ejemplo donde usar Integer vs int, Cuando desea comparar y int variable de nuevo null arrojará 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 valores de tipo de clase Wrapper a cualquier clase de colección.

(Clases de envoltura - Booleano,Character,Byte,Short,Integer,Long,Float,Double)

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

Pero normalmente agregamos valores primitivos a la clase collection? ¿Es correcto el punto 02?

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

Sí 02 es correcto, beacouse autoboxing.

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

Entonces 5 convertir como valor entero por autoboxing.

En java según mi conocimiento si aprendes entonces, cuando escribes int a; entonces en java generic compilará código como Integer a = new Integer(). Por lo tanto, según los genéricos Integer no se utiliza, pero int se utiliza. así que hay tanta diferencia allí.