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




variables en c# (18)

"int" es un tipo de datos primitivo y "Integer" en Wrapper Class en Java. "Integer" se puede usar como un argumento para un método que requiere un objeto, mientras que "int" se puede usar como un argumento para un método que requiere un valor entero, que se puede usar para expresiones aritméticas.

Estaba leyendo More Joel on Software cuando me encontré con Joel Spolsky diciendo algo sobre un tipo particular de programador que sabía la diferencia entre un int y un Integer en Java / C # (Lenguajes de programación orientados a objetos).

¿Entonces cuál es la diferencia?


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

pero Integer es una clase de envoltorio 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 de las clases de envoltorios son estáticos para que pueda usarlos En cualquier momento sin crear una instancia de clase Integer. como un resumen:

int x;
Integer y; 

x y y son variables del tipo int, pero y está envuelto por una clase Integer y tiene varios métodos que utiliza, pero en caso de que necesite llamar a algunas funciones de la clase envoltura Integer, puede 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 (utilizada para definir x).


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

Integer i = new Integer(6);

Podrías llamar 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 puede llamar a ningún método en él, 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 una de las pocas primitivas en Java (junto con char y algunas otras). 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). 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 cercano a la respuesta. ¡Espero que esto ayude!

Objeto entero javadoc

Ojbect entero vs. comparación primitiva int


En C #, int es solo un alias para System.Int32 , cadena 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é ...


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

En C #, el tipo int también es un tipo de datos igual a 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 de ayuda, 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 son los que almacenan la memoria disponible más rápida en la que la clase Helper es compleja y se almacena en la memoria heep.

Referencia de "David Gassner" Java Essential Training.


En lo que respecta a Java 1.5 y autoboxing hay una importante "peculiaridad" que viene a jugar cuando se comparan objetos de Integer.

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

Ejemplo, esto devuelve verdadero:

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

Mientras esto devuelve falso:

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

El == se compara por referencia (¿apuntan las variables al mismo objeto)?

Este resultado puede o no ser diferente 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 () cuando se comparan objetos Integer.

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

Más información en java.net Ejemplo en bexhuff.com


En plataformas como Java, las int son primitivas, mientras que 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 pasan por referencia. Se podría argumentar que el punto al objeto (AKA la referencia) también se está pasando por valor, pero los contenidos no.


Hay muchas razones para usar clases de envoltura:

  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 objetos de almacenamiento y no primitivos.

Lo agregaré a las excelentes respuestas dadas anteriormente, y hablaré sobre el boxeo y el 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 tanto de eso.

Como se mencionó en las respuestas, int es solo un número (llamado tipo sin caja ), mientras que Integer es un objeto (que contiene el número, por lo tanto, un tipo de caja ). En términos de Java, eso significa (aparte de no poder llamar a los métodos en int ), no puede almacenar int u otros tipos de objetos no en colecciones ( List , Map , etc.). Para almacenarlos, primero debe encuadrarlos en su tipo de caja correspondiente.

Java 5 en adelante tiene algo llamado auto-boxing y auto-unboxing que permite que el boxeo / unboxing se haga entre bastidores. Compara y contrasta: 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();
}

Se debe tener en cuenta 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 boxeo automático y el boxeo automático son muy convenientes porque usted escribe menos código, estas operaciones ocurren detrás de la escena, con los mismos costos de tiempo de ejecución, por lo que aún debe estar consciente de su existencia.

¡Espero que esto ayude!


Un int y un entero 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 se 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 envoltorio para un tipo de datos primitivo que tiene métodos estáticos. Se puede usar como un argumento para un método que requiere un objeto, mientras que int puede usarse como un argumento para 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);

Una cosa más que no veo en las respuestas anteriores: en Java, las primitivas envolturas de clases como Integer, Double, Float, Boolean ... y String se suponen invariantes, de modo que cuando se pasa una instancia de esas clases, se invoca El método no pudo alterar sus datos de ninguna manera, en opositió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 estas clases solo tienen 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 del montón, solo una instancia de literal, para ahorrar memoria reutilizando esas instancias


Voy a 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 .

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 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 el int se almacenará 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 i de 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 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 juntar métodos de iteradores en la mezcla, estas son bestias por completo)

Para obtener un objeto de pila, puede utilizar 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 en el objeto del montón directamente, pero en C # necesita 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. (Ugh, este párrafo no se lee tan fácilmente).


int es un tipo de datos primitivo, mientras que Integer es un objeto. La creación de un objeto con Integer le dará acceso a todos los métodos que están 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 el tipo de datos primitivo porque la creación de un objeto aumentará el consumo de memoria.


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


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

Integer value1 = null; //OK

int value2 = null      //Error

02. Solo pueden pasar valores de tipo de Clases de envoltorio a cualquier clase de colección.

(Clases de contenedor: 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, por lo tanto, autoboxing.

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

Entonces 5 convertir como valor entero por autoboxing.


Java:

int , double , long , byte , float , double , short , boolean , char - primitivos. Se utiliza para mantener los tipos de datos básicos soportados por el idioma. los tipos primitivos no forman parte de la jerarquía de objetos, y no heredan Objetos. No se puede pasar por referencia a un método.

Double , Float , Long , Integer , Short , Byte , Character y Boolean , son Wrappers de tipo, empaquetados en java.lang . Todos los envoltorios de tipo numérico definen constructores que permiten que un objeto se construya a partir de un valor dado, o una representación de cadena de ese valor. El uso de objetos puede agregar una sobrecarga incluso a los cálculos más simples.

A partir de JDK 5, Java ha incluido dos características muy útiles: autoboxing y autounboxing. Autoboxing / unboxing simplifica y simplifica enormemente 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 de PS Herbert Schildt fue tomado como referencia.


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





int