¿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...                            


24 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
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
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
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
8

Hay muchas razones para utilizar clases de contenedor:

  1. Obtenemos la conducta extra (por ejemplo, podemos utilizar métodos)
  2. Podemos almacenar valores nulos, mientras que en las primitivas que no podemos
  3. Colecciones soporte para almacenar objetos y no primitivas.
Respondida el 31/07/2014 a las 11:07
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 por usuario

votos
7

Java:

int, double, long, byte, float, double, short, boolean, char- primitivas. Se utiliza para mantener los tipos de datos básicos soportados por el lenguaje. los tipos primitivos no son parte de la jerarquía de objetos, y no se heredan del objeto. Thet can'be paso por referencia a un método.

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

Comenzando con JDK 5, Java ha incluido dos características muy útiles: autoboxing y autounboxing. Autoboxing / unboxing simplifica en gran medida y agiliza código que debe convertir los tipos de primitivas 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 Herbert Schildt PS fue tomada como referencia.

Respondida el 13/06/2016 a las 16:31
fuente por usuario

votos
7

int se utiliza para declarar la variable primitiva

e.g. int i=10;

Número entero se utiliza para crear la variable de referencia de la clase Integer

Integer a = new Integer();
Respondida el 11/12/2011 a las 08:19
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
6

¿alguna vez has programado antes de esa fecha (int) es uno de los tipos primitivos se pueden establecer para sus variables (al igual que char, float, ...).

pero entero es una clase de contenedor que se puede usar para hacer algunas funciones de una variable int (por ejemplo, convertirlo a cadena o viceversa, ...), pero tenga en cuenta que los métodos de clases de envoltura son estáticas para que pueda usarlos en cualquier momento sin necesidad de crear una instancia de la clase Integer. como un resumen:

int x;
Integer y; 

X e Y son dos variables de tipo int, pero Y es envuelto por una clase de enteros y tiene varios métodos que se utilizan, pero por si necesita llamar a algunas funciones de la clase de contenedor entero puede hacerlo simplemente.

Integer.toString(x);

pero tenga en cuenta que tanto x e y son corect pero si desea utilizarlos sólo como un tipo primitivo, utilizan la forma simple (utilizado para la definición de x).

Respondida el 17/05/2014 a las 12:56
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
4

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

En C #, el inttipo también es un tipo de datos mismo que System.Int32. Un integer(al igual que cualquier otro tipo de valor) se puede en caja ( "envuelta") en un objeto.

Respondida el 27/04/2017 a las 04:25
fuente por usuario

votos
4

Un int Entero y 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 puede almacenar exactamente. Un valor de su tipo declarado a la vez.

Por ejemplo:

int number = 7;

¿Dónde intes el tipo de datos asignado al número variable que contiene el valor de siete. Por lo que una intes sólo una primitiva no un objeto.

Mientras que una Integeres una clase contenedora para un tipo de datos primitivo que tiene métodos estáticos. Que se puede utilizar como un argumento a un método que requiere un objeto, donde como int puede ser utilizado como un argumento a un método que requiere un valor entero, que puede ser utilizado para la expresión aritmética.

Por ejemplo:

Integer number = new Integer(5);
Respondida el 07/08/2014 a las 11:50
fuente por usuario

votos
4

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

A diferencia de Java, C # proporciona tanto valores enteros con y sin signo. Como Java y C # son objeto orientado a objetos, algunas operaciones en idiomas no se asignan directamente a las instrucciones proporcionadas por el tiempo de ejecución y por lo tanto necesita ser definido como parte de un objeto de algún tipo.

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

Java proporciona java.lang.Integerque es un tipo de referencia de funcionamiento en int. Los métodos en Integerque no puede ser compilado 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 # variable entero se refiere a System.Int32.Anyvalor de 4 bytes en la memoria puede ser interpretado como un int primitivo, que puede ser manipulado por ejemplo de System.Int32.So int es un alias para System.Int32.Whenel uso de métodos relacionados enteros-como int.Parse(), int.ToString()etc. Entero se compila en la LCF System.Int32struct llamando a los métodos respectivos como Int32.Parse(), Int32.ToString().

Respondida el 17/07/2014 a las 07:02
fuente por usuario

votos
3

En int de Java es un tipo de datos primitivo mientras entero es una clase de ayuda, es utilizar para convertir de 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();

tipos de datos primitivos son almacenar la memoria más rápida disponible en la clase Helper es compleja y almacenar en la memoria heep.

referencia de "David Gassner" Java Formación esencial.

Respondida el 28/02/2016 a las 15:42
fuente por usuario

votos
3

Una variable int tiene un valor entero de 32 bits. Un número entero (con el capital I) contiene una referencia a un objeto de (clase) de tipo entero, o a null.

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

Si una referencia nula variable entera es sin embalaje, explícita o implícitamente, una NullPointerException es lanzada.

Respondida el 26/11/2015 a las 07:54
fuente por usuario

votos
1

"Int" es primitiva de tipo de datos y "entero" en la clase contenedora en Java. "Entero" puede ser utilizado como un argumento a un método que requiere un objeto, donde como "int" puede ser utilizado como un argumento a un método que requiere un valor entero, que puede ser utilizado para la expresión aritmética.

Respondida el 04/08/2017 a las 06:57
fuente por usuario

votos
1

int está predefinida en función de biblioteca C #, pero en Java que puede crear oject de Entero

Respondida el 06/03/2017 a las 02:08
fuente por usuario

votos
0

01. Entero puede ser nulo. Pero int no puede ser nulo.

Integer value1 = null; //OK

int value2 = null      //Error

02. Sólo puede pasar la envoltura de valores de tipo de clases a cualquier clase de colección.

(Clases de contenedor - Boole, carácter, Byte, Short, Integer, Long, Float, Double)

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

Pero normalmente añadimos valores primitivos de clase de colección? Es punto 02 correcto?

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

Si 02 es la correcta, beacouse autoboxing.

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

A continuación, convertir 5 como valor entero por autoboxing.

Respondida el 05/06/2018 a las 11:35
fuente por usuario

votos
0

(Java Version) en palabras sencillas int es primitivo y Entero es objeto contenedor para int.

Un ejemplo en el uso de enteros vs int, cuando se desea comparar y variable int nuevo nulo 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...}
Respondida el 15/02/2018 a las 18:04
fuente por usuario

votos
0

En java según mi leal saber si Learner entonces, cuando se escribe int a; a continuación, en java genérico se compilará código como número entero a = nuevo número entero. Así, según los genéricos número entero no se utiliza, pero se utiliza int. por lo que no es tan dicha diferencia allí.

Respondida el 22/09/2016 a las 06:53
fuente por usuario

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more