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

votos
222

Estaba leyendo Más Joel sobre software cuando me encontré con Joel Spolsky diciendo algo acerca de un tipo particular de programador que conocía la diferencia entre una inty una Integeren Java / C # (Lenguajes de Programación Orientada a Objetos).

¿Entonces cuál es la diferencia?

Publicado el 02/08/2008 a las 22:47
fuente por usuario
En otros idiomas...                            


27 respuestas

votos
216

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.Int32y 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 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, los primitivos son tipos inmutables que se pasan por valor y a menudo se asignan desde la pila .

Respondida el 02/08/2008 a las 22:55
fuente por usuario

votos
135

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 programado 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

Respondida el 02/08/2008 a las 23:05
fuente por usuario

votos
11

En C #, int es solo un alias para System.Int32, string for System.String, double para System.Doubleetc ...

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

Respondida el 03/08/2008 a las 00:37
fuente por usuario

votos
32

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, intes solo un número (llamado el 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 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<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 de Java 5, ambas versiones generan bytecode idéntico. Por lo tanto, aunque la auto-boxeo y el auto-unboxing es muy conveniente ya que escribe menos código, estas operaciones no sucederá 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!

Respondida el 03/08/2008 a las 03:32
fuente por usuario

votos
26

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, pero 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.

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 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 pila, en la memoria, o como un objeto de montón referenciado depende del contexto y cómo lo usa.

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 de 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 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 de los contenidos de ien 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).

Respondida el 04/08/2008 a las 15:11
fuente por usuario

votos
7

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<int>() );
}

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

string GetTypeName<T>()
{
    return (typeof (T)).FullName;
}
Respondida el 04/08/2008 a las 22:02
fuente por usuario

votos
18

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 programa 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

Respondida el 05/08/2008 a las 21:49
fuente por usuario

votos
17

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?

Respondida el 06/08/2008 a las 12:08
fuente por usuario

votos
6

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 programa Java, los literales de cadena se almacenan en una parte separada de la memoria de pila, solo una instancia de literal, para ahorrar memoria y reutilizar esas instancias.

Respondida el 06/08/2008 a las 15:33
fuente por usuario

votos
8

En plataformas como Java, ints son primitivas, mientras que Integeres 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.

Respondida el 31/01/2009 a las 03:49
fuente