Quelle est la différence entre un int et un entier en Java et C #?

Translate

je lisaisPlus de Joel sur le logicielquand je suis tombé surJoël Spolskydire quelque chose sur un type particulier de programmeur connaissant la différence entre unintEt unIntegeren Java / C # (Langages de programmation orientés objet).

Alors, quelle est la difference?

This question and all comments follow the "Attribution Required."

Toutes les réponses

Translate

En Java,le type 'int' est une primitive, tandis que le type 'Integer' est un objet.

En C #,le type 'int' est le même queSystem.Int32et estun type de valeur(c'est à dire plus comme le java 'int'). Un entier (comme tout autre type de valeur) peut êtreen boîte("enveloppé") dans un objet.


Les différences entre les objets et les primitives dépassent quelque peu la portée de cette question, mais pour résumer:

Objetsfournissent des facilités pour le polymorphisme, sont passés par référence (ou plus précisément ont des références passées par valeur), et sont alloués à partir dutas. Inversement,primitivessont des types immuables qui sont passés par valeur et sont souvent alloués à partir duempiler.

La source
Translate

Eh bien, en Java, un int est une primitive tandis qu'un entier est un objet. Signification, si vous avez créé un nouvel entier:

Integer i = new Integer(6);

Vous pouvez appeler une méthode sur i:

String s = i.toString();//sets s the string representation of i

Alors qu'avec un int:

int i = 6;

Vous ne pouvez appeler aucune méthode dessus, car il s'agit simplement d'une primitive. Alors:

String s = i.toString();//will not work!!!

produirait une erreur, car int n'est pas un objet.

int est l'une des rares primitives de Java (avec char et quelques autres). Je ne suis pas sûr à 100%, mais je pense que l'objet Integer a plus ou moins juste une propriété int et tout un tas de méthodes pour interagir avec cette propriété (comme la méthode toString () par exemple). Donc Integer est une façon sophistiquée de travailler avec un int (tout comme peut-être String est une façon sophistiquée de travailler avec un groupe de caractères).

Je sais que Java n'est pas C, mais comme je n'ai jamais programmé en C, c'est ce qui me rapproche le plus de la réponse. J'espère que cela t'aides!

Objet entier javadoc

Comparaison primitive Integer Ojbect vs int

La source
Translate

J'ajouterai aux excellentes réponses données ci-dessus, et parlerai de la boxe et du déballage, et comment cela s'applique à Java (bien que C # l'ait aussi). J'utiliserai juste la terminologie Java, car je suis plusau faitavec ça.

Comme les réponses l'ont mentionné,intest juste un nombre (appelé ledéballétype), alors queIntegerest un objet (qui contient le nombre, donc unen boîtetype). En termes Java, cela signifie (en plus de ne pas pouvoir appeler des méthodes surint), vous ne pouvez pas stockerintou d'autres types non-objet dans les collections (List, Map, etc.). Afin de les stocker, vous devez d'abord les emballer dans leur type de boîte correspondant.

Java 5 et les versions ultérieures ont quelque chose appeléboxe automatiqueetdéballage automatiquequi permettent de faire la boxe / unboxing dans les coulisses. Comparer et contraster: version Java 5:

Deque<Integer> queue;

void add(int n) {
    queue.add(n);
}

int remove() {
    return queue.remove();
}

Java 1.4 ou version antérieure (pas de génériques non plus):

Deque queue;

void add(int n) {
    queue.add(Integer.valueOf(n));
}

int remove() {
    return ((Integer) queue.remove()).intValue();
}

Il faut noter que malgré la brièveté de la version Java 5, les deux versions génèrent un bytecode identique. Ainsi, bien que l'auto-boxing et l'auto-unboxing soient très pratiques car vous écrivez moins de code, ces opérationsdose produisent dans les coulisses, avec les mêmes coûts d'exécution, vous devez donc toujours être conscient de leur existence.

J'espère que cela t'aides!

La source
Translate

Je vais juste poster ici car certains des autres messages sont légèrement inexacts par rapport à C #.

Correct: intest un alias pourSystem.Int32.
Faux: floatn'est pas un alias pourSystem.Float, mais pourSystem.Single

Fondamentalement, int est un mot-clé réservé dans le langage de programmation C # et est un alias pour leSystem.Int32type de valeur.

float et Float ne sont pas les mêmes cependant, comme le bon type de système pour ''float'' est System.Single. Certains types comme celui-ci ont des mots-clés réservés qui ne semblent pas correspondre directement aux noms de type.

En C #, il n'y a pas de différence entre ''int'' et ''System.Int32'', ou l'une des autres paires ou mots-clés / types de système, sauf lors de la définition des énumérations. Avec les énumérations, vous pouvez spécifier la taille de stockage à utiliser et dans ce cas, vous ne pouvez utiliser que le mot-clé réservé et non le nom du type d'exécution du système.

Le fait que la valeur de int soit stockée sur la pile, en mémoire ou en tant qu'objet de tas référencé dépend du contexte et de la manière dont vous l'utilisez.

Cette déclaration dans une méthode:

int i;

définit une variableide typeSystem.Int32, vivant dans un registre ou sur la pile, selon les optimisations. La même déclaration dans un type (struct ou class) définit un champ membre. La même déclaration dans une liste d'arguments de méthode définit un paramètre, avec les mêmes options de stockage que pour une variable locale. (notez que ce paragraphe n'est pas valide si vous commencez à tirer des méthodes d'itération dans le mélange, ce sont des bêtes complètement différentes)

Pour obtenir un objet de tas, vous pouvez utiliser la boxe:

object o = i;

cela créera une copie encadrée du contenu deisur le tas. En IL, vous pouvez accéder directement aux méthodes sur l'objet de tas, mais en C # vous devez le renvoyer en un int, ce qui créera une autre copie. Ainsi, l'objet sur le tas ne peut pas être facilement modifié en C # sans créer une nouvelle copie encadrée d'une nouvelle valeur int. (Ugh, ce paragraphe ne se lit pas si facilement.)

La source
Translate

Concernant Java 1.5 etboîte automatiqueil y a une "bizarrerie" importante qui vient à jouer lors de la comparaison d'objets Integer.

En Java, les objets Integer avec les valeurs -128 à 127 sont immuables (c'est-à-dire que pour une valeur entière particulière, disons 23, tous les objets Integer instanciés via votre programme avec la valeur 23 pointent vers leexactmême objet).

Exemple, cela renvoie vrai:

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

Bien que cela retourne faux:

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

Le == compare par référence (les variables pointent-elles vers le même objet).

Ce résultat peut différer ou non en fonction de la JVM que vous utilisez. La spécification autoboxing pour Java 1.5 nécessite que les entiers (-128 à 127) encadrent toujours le même objet wrapper.

Une solution? =) Il faut toujours utiliser la méthode Integer.equals () lors de la comparaison d'objets Integer.

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

Plus d'infos surjava.netExemple àbexhuff.com

La source
Translate

En Java, il existe deux types de base dans leJVM. 1) types primitifs et 2) types de référence. int est un type primitif et Integer est un type de classe (qui est une sorte de type référence).

Les valeurs primitives ne partagent pas l'état avec d'autres valeurs primitives. Une variable dont le type est un type primitif contient toujours une valeur primitive de ce type.

int aNumber = 4;
int anotherNum = aNumber;
aNumber += 6;
System.out.println(anotherNum); // Prints 4

Un objet est une instance de classe créée dynamiquement ou un tableau. Les valeurs de référence (souvent juste des références) sont des pointeurs vers ces objets et une référence nulle spéciale, qui ne fait référence à aucun objet. Il peut y avoir de nombreuses références au même objet.

Integer aNumber = Integer.valueOf(4);
Integer anotherNumber = aNumber; // anotherNumber references the 
                                 // same object as aNumber

De plus, en Java, tout est passé par valeur. Avec les objets, la valeur transmise est la référence à l'objet. Une autre différence entre int et Integer en java est la façon dont ils sont passés dans les appels de méthode. Par exemple dans

public int add(int a, int b) {
    return a + b;
}
final int two = 2;
int sum = add(1, two);

La variabledeuxest passé comme le type entier primitif 2. Alors que dans

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 variabledeuxest passé comme référence à un objet contenant la valeur entière 2.


@WolfmanDragon: Passer par référence fonctionnerait comme ceci:

public void increment(int x) {
  x = x + 1;
}
int a = 1;
increment(a);
// a is now 2

Lorsque l'incrément est appelé, il passe une référence (pointeur) à la variablea. Et leincrémentla fonction modifie directement la variablea.

Et pour les types d'objets, cela fonctionnerait comme suit:

public void increment(Integer x) {
  x = Integer.valueOf(x.intValue() + 1);
}
Integer a = Integer.valueOf(1);
increment(a);
// a is now 2

Voyez-vous la différence maintenant?

La source
Translate

En C #, int est juste unaliaspourSystem.Int32, chaîne pourSystem.String, double pourSystem.Doubleetc...

Personnellement, je préfère int, string, double, etc. car ils ne nécessitent pas deusing System;déclaration :) Une raison idiote, je sais ...

La source
Translate

Il existe de nombreuses raisons d'utiliser des classes wrapper:

  1. Nous obtenons un comportement supplémentaire (par exemple, nous pouvons utiliser des méthodes)
  2. Nous pouvons stocker des valeurs nulles alors que dans les primitives, nous ne pouvons pas
  3. Les collections prennent en charge le stockage d'objets et non de primitives.
La source
Translate

Cela a déjà été répondu pour Java, voici la réponse C #:

"Integer" n'est pas un nom de type valide en C # et "int" est juste un alias pour System.Int32. De plus, contrairement à Java (ou C ++), il n'y a pas de types primitifs spéciaux en C #, chaque instance d'un type en C # (y compris int) est un objet. Voici un code démonstratif:

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;
}
La source
Translate

int est utilisé pour déclarer une variable primitive

e.g. int i=10;

Integer est utilisé pour créer une variable de référence de classe Integer

Integer a = new Integer();
La source
mP.
Translate

Sur des plates-formes comme Java,intLes s sont des primitifs tandis queIntegerest un objet contenant un champ entier. La distinction importante est que les primitives sont toujours transmises par valeur et par définition sont immuables.

Toute opération impliquant une variable primitive renvoie toujours une nouvelle valeur. En revanche, les objets sont transmis par référence. On pourrait argumenter que le point vers l'objet (AKA la référence) est également transmis par valeur, mais le contenu ne le est pas.

La source
Translate

Une autre chose que je ne vois pas dans les réponses précédentes: en Java, les classes primitives de wrappers comme Integer, Double, Float, Boolean ... et String sont supposées être invariantes, de sorte que lorsque vous passez une instance de ces classes, l'appel method ne pouvait en aucun cas modifier vos données, contrairement à la plupart des autres classes, dont les données internes pourraient être modifiées par ses méthodes publiques. Pour que cette classe n'ait que des méthodes «getter», pas de «setters», en plus du constructeur.

Dans un programme java, les littéraux de chaîne sont stockés dans une partie distincte de la mémoire du tas, uniquement une instance pour littéral, pour économiser la mémoire en réutilisant ces instances

La source
Translate

avez-vous déjà programmé avant alors (int) est l'un des types primitifs que vous pouvez définir pour vos variables (tout comme char, float, ...).

mais Integer est une classe wrapper que vous pouvez utiliser pour faire certaines fonctions sur une variable int (par exemple la convertir en chaîne ou vice versa, ...), mais notez que les méthodes des classes wrapper sont statiques afin que vous puissiez les utiliser à tout moment sans créer une instance de la classe Integer. en récapitulation:

int x;
Integer y; 

x et y sont tous les deux des variables de type int mais y est encapsulé par une classe Integer et a plusieurs méthodes que vous utilisez, mais si vous devez appeler certaines fonctions de la classe wrapper Integer, vous pouvez le faire simplement.

Integer.toString(x);

mais sachez que x et y sont corect, mais si vous voulez les utiliser uniquement comme type primitif, utilisez la forme simple (utilisée pour définir x).

La source
Translate

Java:

int, double, long, byte, float, double, short, boolean, char- les primitives. Utilisé pour contenir les types de données de base pris en charge par la langue. les types primitifs ne font pas partie de la hiérarchie d'objets et n'héritent pas d'Object. Cela peut être passé par référence à une méthode.

Double, Float, Long, Integer, Short, Byte, Character, etBoolean, sont des emballages de type, emballés dansjava.lang. Tous les wrappers de type numérique définissent des constructeurs qui permettent à un objet d'être construit à partir d'une valeur donnée ou d'une représentation sous forme de chaîne de cette valeur. L'utilisation d'objets peut ajouter une surcharge même aux calculs les plus simples.

À partir de JDK 5, Java a inclus deux fonctionnalités très utiles: l'autoboxing et l'autounboxing. L'autoboxing / unboxing simplifie et rationalise considérablement le code qui doit convertir les types primitifs en objets, et vice versa.

Exemple de constructeurs:

Integer(int num)
Integer(String str) throws NumberFormatException
Double(double num)
Double(String str) throws NumberFormatException

Exemple de boxe / déballage:

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

Exemple d'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
    }
}

Le livre de PS Herbert Schildt a été pris comme référence.

La source
Ernest Lee
Translate

Une variable int contient une valeur entière signée de 32 bits. Un entier (avec I majuscule) contient une référence à un objet de type (classe) Integer ou à null.

Java effectue automatiquement une conversion entre les deux; de Integer à int chaque fois que l'objet Integer apparaît en tant qu'argument d'un opérateur int ou est affecté à une variable int, ou qu'une valeur int est affectée à une variable Integer. Ce casting est appelé boxe / déballage.

Si une variable Integer référençant null est unboxed, explicitement ou implicitement, une NullPointerException est levée.

La source
Translate

Un int et Integer en Java et C # sont deux termes différents utilisés pour représenter des choses différentes. C'est l'un des types de données primitifs qui peuvent être affectés à une variable qui peut stocker exactement. Une valeur de son type déclaré à la fois.

Par exemple:

int number = 7;

intest le type de données attribué au numéro de variable qui contient la valeur sept. Donc unintest juste un primitif pas un objet.

Alors qu'unIntegerest une classe wrapper pour un type de données primitif qui a des méthodes statiques. Cela peut être utilisé comme argument d'une méthode qui nécessite un objet, où as int peut être utilisé comme argument d'une méthode qui nécessite une valeur entière, qui peut être utilisée pour l'expression arithmétique.

Par exemple:

Integer number = new Integer(5);
La source
Translate

Dans les deux langages (Java et C #)intest un entier signé de 4 octets.

Contrairement à Java, C # fournit des valeurs entières signées et non signées. Comme Java et C # sont orientés objet, certaines opérations dans ces langages ne correspondent pas directement aux instructions fournies par l'exécution et doivent donc être définies comme faisant partie d'un objet d'un certain type.

C # fournitSystem.Int32qui est un type valeur utilisant une partie de la mémoire qui appartient au type de référence sur le tas.

java fournitjava.lang.Integerqui est un type de référence fonctionnant surint. Les méthodes enIntegerne peut pas être compilé directement aux instructions d'exécution, nous encadrons donc une valeur int pour la convertir en une instance de Integer et utilisons les méthodes qui attendent une instance d'un certain type (commetoString(), parseInt(), valueOf()etc).

En C #, la variable int fait référence àSystem.Int32.AnyLa valeur de 4 octets en mémoire peut être interprétée comme un int primitif, qui peut être manipulé par une instance de System.Int32.So int est un alias pourSystem.Int32.Whenen utilisant des méthodes liées aux nombres entiers commeint.Parse(), int.ToString()etc. Un entier est compilé dans le FCLSystem.Int32struct appelant les méthodes respectives commeInt32.Parse(), Int32.ToString().

La source
Translate

En Java, leinttype est un type de données primitif, où en tant queIntegerle type est un objet.

En C #, leinttype est également un type de données identique àSystem.Int32. Uninteger(comme tout autre type de valeur) peut être encadré ("enveloppé") dans un objet.

La source
Translate

En Java, int est un type de données primitif tandis que Integer est une classe Helper, il est utilisé pour convertir un type de données en un autre.

Par exemple:

double doubleValue = 156.5d;
Double doubleObject  = new Double(doubleValue);
Byte myByteValue = doubleObject.byteValue ();
String myStringValue = doubleObject.toString();

Les types de données primitifs stockent la mémoire disponible la plus rapide là où la classe Helper est complexe et stockent dans la mémoire heep.

référence de la formation Java Essential "David Gassner".

La source
Translate

"int" est un type de données primitif et "Integer" dans Wrapper Class en Java. "Integer" peut être utilisé comme argument pour une méthode qui nécessite un objet, où comme "int" peut être utilisé comme argument pour une méthode qui nécessite une valeur entière, qui peut être utilisée pour l'expression arithmétique.

La source
Translate

01. Un entier peut être nul. Mais int ne peut pas être nul.

Integer value1 = null; //OK

int value2 = null      //Error

02. Seule peut transmettre des valeurs de type Wrapper Classes à n'importe quelle classe de collection.

(Classes wrapper - Boolean, Character, Byte, Short, Integer, Long, Float, Double)

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

Mais normalement, nous ajoutons des valeurs primitives à la classe de collection? Le point 02 est-il correct?

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

Oui 02 est correct, beacouseautoboxing.

L'autoboxing est la conversion automatique que le compilateur java effectue entre le type primitif et leur classe wrapper correspondante.

Puis 5 convertir en valeur Integer par autoboxing.

La source
Translate

intest prédéfini dans la fonction de bibliothèque c # mais en java, nous pouvons créer un objet deInteger

La source
Translate

(Version Java) En mots simples, int est primitif et Integer est un objet wrapper pour int.

Un exemple où utiliser Integer vs int, lorsque vous voulez comparer et int variable à nouveau null, cela générera une erreur.

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...}
La source
Translate

En java selon mes connaissances si vous apprenez alors, lorsque vous écrivez int a; puis en java générique, il compilera du code commeInteger a = new Integer(). Donc, selon les génériquesIntegern'est pas utilisé maisintest utilisé. donc il y a tellement de différence là-bas.

La source
Translate

intest un type de données primitif.Entierest une classe wrapper. Il peut stocker des données int en tant qu'objets.

La source
Translate

int est un type de données primitif alors que Integer est un objet. La création d'un objet avec Integer vous donnera accès à toutes les méthodes disponibles dans la classe Integer. Mais, si vous créez un type de données primitif avec int, vous ne pourrez pas utiliser ces méthodes inbuild et vous devrez les définir vous-même. Mais, si vous ne voulez pas d'autres méthodes et que vous voulez rendre le programme plus efficace en mémoire, vous pouvez utiliser un type de données primitif car la création d'un objet augmentera la consommation de mémoire.

La source