studio - tipos de variables numericas en c#

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

Question

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?

Answer 1

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

Answer 2

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

Answer 3

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

Un ejemplo donde se usa Integer vs int, cuando se quiere comparar y la variable int nuevamente nula, se generará 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...}

Answer 4

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

Answer 5

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

Answer 6

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 un tipo de tipo de referencia).

Los valores primitivos no comparten el 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 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. Así que otra diferencia entre int y 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 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 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 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?

Answer 7

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.

Answer 8

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.

Answer 9

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

A diferencia de Java, C # proporciona valores enteros firmados y no firmados. 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 para ejecutar instrucciones de tiempo. Por lo tanto, recuadramos un valor int para convertirlo en una instancia de Integer y usamos los métodos que esperan instancias de algún tipo (como toString() , parseInt() , valueOf() etc).

En C # la variable int se refiere a System.Int32.Any . Cualquier valor de 4 bytes en la memoria se puede interpretar como un int primitivo, que puede ser manipulado por la instancia de System.Int32.Así que int es un alias para System.Int32.When Cuando se usa un entero métodos relacionados 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() .

Answer 10

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

Answer 11

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.

Answer 12

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 # (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;
}

Answer 13

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.

Answer 14

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!

Answer 15

Según lo que yo sepa, en java, cuando aprendas, cuando escribes int a; luego en Java genérico compilará código como Integer a = new Integer() . Por lo tanto, según los genéricos no se usa Integer pero se usa int . así que hay tanta diferencia allí.

Answer 16

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);

Answer 17

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

Answer 18

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

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

Si una variable Integer que hace referencia a null no está en el cuadro, explícita o implícitamente, se lanza una NullPointerException.

Answer 19

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

Answer 20

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.

Answer 21

int se utiliza para declarar variable primitiva

e.g. int i=10;

Integer se usa para crear la variable de referencia de la clase Integer

Integer a = new Integer();

Answer 22

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

Answer 23

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.

Answer 24

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

En C #, el tipo ''int'' es el mismo que System.Int32 y es un tipo de valor (es decir, más como java ''int''). Un entero (como cualquier otro tipo de valor) se puede boxed ("envolver") en un objeto.

Las diferencias entre los objetos y las primitivas están algo 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 precisamente, se pasan las referencias por valor), y se asignan desde el heap . A la inversa, las primitivas son tipos inmutables que se pasan por valor y a menudo se asignan desde la stack .

Answer 25

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.

Answer 26

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