Pregunta

estaba leyendo Más Joel sobre software cuando me encontré joel spolsky decir algo sobre un tipo particular de programador que conoce la diferencia entre un int y un Integer en Java/C# (lenguajes de programación orientados a objetos).

¿Entonces cuál es la diferencia?

¿Fue útil?

Solución

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

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 número entero (como cualquier otro tipo de valor) puede ser en caja ("envuelto") en un objeto.


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

Objetos proporcionan facilidades para el polimorfismo, se pasan por referencia (o más exactamente, las referencias se pasan por valor) y se asignan desde el montón.En cambio, primitivos son tipos inmutables que se pasan por valor y a menudo se asignan desde el pila.

Otros consejos

Bueno, en Java un int es una primitiva mientras que un entero es un objeto.Es decir, si creaste un nuevo número 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

Mientras que con un int:

int i = 6;

No puedes llamar a ningún método porque es simplemente una primitiva.Entonces:

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 creo que el objeto Integer tiene más o menos 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 (al igual que quizás String sea 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 puedo llegar a la respuesta.¡Espero que esto ayude!

javadoc de objeto entero

Objeto entero vs.comparación primitiva int

Agregaré a las excelentes respuestas dadas anteriormente y hablaré sobre boxing y unboxing, y cómo esto se aplica a Java (aunque C# también lo tiene).Usaré sólo terminología Java, porque soy más familiarizado con ese.

Como mencionan las respuestas, int es solo un número (llamado sin caja tipo), mientras que Integer es un objeto (que contiene el número, por lo tanto un en caja tipo).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 que no son objetos en colecciones (List, Map, etc.).Para poder almacenarlos, primero deberás empaquetarlos en su correspondiente tipo de caja.

Java 5 en adelante tiene algo llamado auto-boxeo y desempaquetado automático que permiten que el boxeo/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 de la versión Java 5, ambas versiones generan un código de bytes idéntico.Por lo tanto, aunque el autoboxing y el autounboxing son muy convenientes porque escribes menos código, estas operaciones hacer ocurren detrás de escena, con los mismos costos de tiempo de ejecución, por lo que aún debes estar al tanto 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.
Equivocado: float no es un alias para System.Float, pero para System.Single

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

Sin embargo, float y Float no son lo mismo 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 enumeraciones puede especificar el tamaño de almacenamiento que se 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 int se almacenará en la pila, en la memoria o como un objeto de montón referenciado depende del contexto y de cómo lo use.

Esta declaración en un método:

int i;

define una variable i de tipo System.Int32, viviendo en un registro o en la pila, dependiendo de las optimizaciones.La misma declaración en un tipo (estructura o clase) define un campo miembro.La misma declaración en la lista de argumentos de un 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 incorporar métodos iteradores a la mezcla, estos son animales completamente diferentes)

Para obtener un objeto de montón, puedes 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 del objeto del montón 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).

Respecto a Java 1.5 y autoboxing Hay una "peculiaridad" importante que entra en juego al comparar objetos enteros.

En Java, los objetos Integer con los valores -128 a 127 son inmutables (es decir, para un valor entero particular, digamos 23, todos los objetos Integer instanciados a través de su programa con el valor 23 apuntan al exacto 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 diferir o no según la JVM que esté utilizando.La especificación autoboxing para Java 1.5 requiere que los números enteros (-128 a 127) siempre se encuadren en el mismo objeto contenedor.

¿Una solución?=) Siempre se debe utilizar 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 el 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 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 o una matriz creada dinámicamente.Los valores de referencia (a menudo solo referencias) son punteros a estos objetos y una referencia nula especial, que no hace referencia 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 entero primitivo tipo 2.Mientras 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 el incremento la función modifica directamente la variable a.

Y para 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 sólo un alias para System.Int32, cuerda para System.String, doble para System.Double etc...

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

Hay muchas razones para utilizar clases contenedoras:

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

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 tipos primitivos especiales 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 variables primitivas

e.g. int i=10;

Integer se utiliza para crear una variable de referencia de clase Integer

Integer a = new Integer();

En plataformas como Java, ints son primitivos mientras Integer es 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 involucre una variable primitiva siempre devuelve un nuevo valor.Por otro lado, los objetos se transmiten por referencia.Se podría argumentar que el punto al objeto (también conocido como la referencia) también se transmite por valor, pero el contenido no.

Una cosa más que no veo en las respuestas anteriores:En Java, las clases contenedoras primitivas como Integer, Double, Float, Boolean...y String se supone que son invariantes, de modo que cuando pasas una instancia de esas clases, el método invocado no puede alterar tus datos de ninguna manera, a diferencia de 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 tenga métodos 'getter', no 'establecedores', además del constructor.

En un programa Java, los literales de cadena se almacenan en una porción separada de la memoria del montón, solo una instancia para el literal, para ahorrar memoria al reutilizar 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 contenedora que puedes usar para realizar algunas funciones en una variable int (por ejemplo, convertirla en una cadena o viceversa,...), pero ten en cuenta que los métodos en las clases contenedoras son estáticos, por lo que puedes usarlos. en cualquier momento sin crear una instancia de la clase Integer.como resumen:

int x;
Integer y; 

xey son ambas variables de tipo int, pero y está envuelta por una clase Integer y tiene varios métodos que puedes usar, pero en caso de que necesites llamar a algunas funciones de la clase contenedora Integer, puedes hacerlo de manera simple.

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 (usada para definir x).

Java:

int, double, long, byte, float, double, short, boolean, char - primitivos.Utilizado para mantener los tipos de datos básicos compatibles con el idioma.Los tipos primitivos no son parte de la jerarquía de objetos, y no heredan el objeto.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.Todos los contenedores de tipos numéricos 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 suponer una sobrecarga incluso para los cálculos más simples.

A partir de JDK 5, Java ha incluido dos características muy útiles:autoboxing y autounboxing.El 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
    }
}

PDSe tomó como referencia el libro de Herbert Schildt.

En t es un tipo de datos primitivo.Entero es una clase contenedora.Puede almacenar datos int como objetos.

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

Java convierte automáticamente entre los dos;de Integer a int siempre que el objeto Integer aparece 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 nulo no está encuadrada, explícita o implícitamente, se genera una excepción NullPointerException.

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

Por ejemplo:

int number = 7;

Dónde int es el tipo de datos asignado a la variable número que contiene el valor siete.entonces un int es solo un primitivo, no un objeto.

mientras un Integer es una clase contenedora para un tipo de datos primitivo que tiene métodos estáticos.Eso se puede usar como argumento para un método que requiere un objeto, mientras que int se puede usar como argumento para un método que requiere un valor entero, que se puede usar para expresiones aritméticas.

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 puede compilar directamente para ejecutar instrucciones en tiempo de ejecución. Por lo tanto, encuadramos 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 El valor de 4 bytes en la memoria se puede interpretar como un int primitivo, que se puede manipular mediante una instancia de System.Int32. Entonces int es un alias para System.Int32.When usando métodos relacionados con números enteros como int.Parse(), int.ToString() etc.El entero se compila en FCL System.Int32 estructura llamando a los métodos respectivos como Int32.Parse(), Int32.ToString().

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

En C#, el int type también es un tipo de datos igual que System.Int32.Un integer (al igual que 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 auxiliar, se utiliza 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 se almacenan en la memoria disponible más rápida 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 y "Entero" en la clase Wrapper en Java."Entero" se puede usar como argumento para un método que requiere un objeto, mientras que "int" se puede usar como argumento para un método que requiere un valor entero, que se puede usar para expresiones aritméticas.

01.El número 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 contenedoras: booleano, 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 Java entre el tipo primitivo y su clase de envoltorio correspondiente.

Luego 5 convierte como valor entero mediante autoboxing.

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 el entero es objeto de envoltura 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 aprendes, cuando escribes int a;luego en java genérico compilará código como Integer a = new Integer().Entonces, según los genéricos. Integer no se usa pero int se utiliza.entonces hay tanta diferencia allí.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top