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

Je lisais « Plus Joel on Software» quand je suis tombé sur Joel Spolsky en train de dire quelque chose sur un type particulier de programmeur connaissant la différence entre un Integer et un Integer en Java / C # (langages de programmation orientés object).

Alors, quelle est la difference?

En Java, le type ‘int’ est une primitive, alors que le type ‘Integer’ est un object.

En C #, le type ‘int’ est le même que System.Int32 et est un type de valeur (c’est-à-dire plus comme le java ‘int’). Un entier (comme tout autre type de valeur) peut être encadré (“enveloppé”) dans un object.


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

Les objects fournissent des facilités pour le polymorphism, sont transmis par référence (ou ont plus précisément des références passées par valeur), et sont alloués à partir du tas . Inversement, les primitives sont des types immuables qui sont passés par valeur et sont souvent atsortingbués à partir de la stack .

Eh bien, en Java, un int est une primitive alors qu’un entier est un object. Signification, si vous avez créé un nouvel entier:

 Integer i = new Integer(6); 

Vous pouvez appeler une méthode sur i:

 Ssortingng s = i.toSsortingng();//sets s the ssortingng representation of i 

Considérant qu’avec un int:

 int i = 6; 

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

 Ssortingng s = i.toSsortingng();//will not work!!! 

produirait une erreur, car int n’est pas un object.

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’object Integer a plus ou moins simplement une propriété int et tout un tas de méthodes pour interagir avec cette propriété (comme la méthode toSsortingng () par exemple). Donc, Integer est une manière élégante de travailler avec un int (tout comme peut-être que Ssortingng est une façon élégante 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 le plus proche que je puisse trouver. J’espère que cela t’aides!

Objet entier javadoc

Integer Ojbect vs comparaison primitive int

Je vais append aux excellentes réponses données ci-dessus, et parler de la boxe et du unboxing, et de la manière dont cela s’applique à Java (même si C # l’a aussi). Je vais utiliser uniquement la terminologie Java, car je suis plus au fait de cela.

Comme le mentionnent les réponses, int est juste un nombre (appelé type unboxed ), alors Integer est un object (qui contient le nombre, donc un type encadré ). En termes de Java, cela signifie (en plus de ne pas pouvoir appeler des méthodes sur int ), vous ne pouvez pas stocker des types int ou autres types non-objects dans des collections ( List , Map , etc.). Pour les stocker, vous devez d’abord les ranger dans le type de boîte correspondant.

Java 5 et les versions ultérieures ont quelque chose appelé l’ auto-boxing et l’ auto-unboxing qui permettent à la boxing / unboxing de se dérouler dans les coulisses. Comparaison et contraste: version Java 5:

 Deque queue; void add(int n) { queue.add(n); } int remove() { return queue.remove(); } 

Java 1.4 ou antérieur (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érations se produisent en arrière-plan, avec les mêmes coûts d’exécution, vous devez donc toujours connaître leur existence.

J’espère que cela t’aides!

Je vais simplement poster ici puisque certains des autres articles sont légèrement inexacts par rapport à C #.

Correct: int est un alias pour System.Int32 .
Wrong: float n’est pas un alias pour System.Float , mais pour System.Single

Fondamentalement, int est un mot clé réservé dans le langage de programmation C # et est un alias pour le type de valeur System.Int32 .

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

En C #, il n’y a pas de différence entre ” int ” et ” System.Int32 ”, ou toute autre paire ou mot-clé / type de système, sauf lors de la définition des énumérations. Avec enums, vous pouvez spécifier la taille de stockage à utiliser. 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.

Si la valeur de l’int sera stockée dans la stack, en mémoire ou en tant qu’object de stack 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 variable de type System.Int32 , vivant dans un registre ou sur la stack, en fonction des 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 à utiliser des méthodes d’itération dans le mixage, ce sont des bêtes différentes)

Pour obtenir un object tas, vous pouvez utiliser la boxe:

 object o = i; 

Cela créera une copie en boîte du contenu de i sur le tas. En IL, vous pouvez accéder directement aux méthodes sur l’object heap, mais en C #, vous devez le replacer dans un int, ce qui créera une autre copie. Ainsi, l’object sur le tas ne peut pas être facilement modifié en C # sans créer une nouvelle copie en boîte d’une nouvelle valeur int. (Ugh, ce paragraphe ne lit pas tout cela facilement.)

En ce qui concerne Java 1.5 et l’ autoboxing, il existe une “bizarrerie” importante lors de la comparaison d’objects Integer.

En Java, les objects Integer avec les valeurs -128 à 127 sont immuables (c’est-à-dire que pour une valeur entière particulière, disons 23, tous les objects Integer instanciés dans votre programme avec la valeur 23 pointent exactement au même object).

Exemple, ceci renvoie true:

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

Alors que cela retourne false:

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

Le == se compare par référence (les variables désignent-elles le même object)?

Ce résultat peut ou non différer selon la JVM que vous utilisez. La spécification autoboxing pour Java 1.5 requirejs que les entiers (-128 à 127) soient toujours encadrés au même object wrapper.

Une solution? =) On devrait toujours utiliser la méthode Integer.equals () pour comparer des objects Entier.

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

Plus d’infos sur java.net Exemple sur bexhuff.com

En Java, il existe deux types de base dans la JVM . 1) Types primitifs et 2) Types de référence. int est un type primitif et Integer est un type de classe (qui est un type de type de 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 object est une instance de classe créée dynamicment ou un tableau. Les valeurs de référence (souvent de simples références) sont des pointeurs vers ces objects et une référence null spéciale, qui ne fait référence à aucun object. Il peut y avoir beaucoup de références au même object.

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

Toujours en Java, tout est passé par valeur. Avec les objects, la valeur transmise est la référence à l’object. Donc, une autre différence entre int et Integer dans 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 variable deux est passée en tant que 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 variable two est transmise en tant que référence à un object contenant la valeur entière 2.


@WolfmanDragon: Passer par référence fonctionnerait comme ça:

 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 variable a . Et la fonction d’ incrémentation modifie directement la variable a .

Et pour les types d’objects, 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?

En C #, int est juste un alias pour System.Int32 , chaîne pour System.Ssortingng , double pour System.Double etc …

Personnellement, je préfère int, ssortingng, double, etc. déclaration 🙂 Une raison idiote, je sais …

Dans les plates-formes comme Java, int s sont des primitives, tandis que Integer est un object qui contient un champ entier. La distinction importante est que les primitives sont toujours transmises par valeur et sont par définition immuables.

Toute opération impliquant une variable primitive renvoie toujours une nouvelle valeur. Par contre, les objects sont contournés par référence. On pourrait faire valoir que le point à l’object (AKA la référence) est également transmis par valeur, mais le contenu ne l’est pas.

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. On peut stocker des valeurs nulles alors que dans les primitives on ne peut pas
  3. Les collections prennent en charge le stockage des objects et non des primitives.

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

“Entier” 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 object. Voici un code démonstratif:

 void DoStuff() { System.Console.WriteLine( SomeMethod((int)5) ); System.Console.WriteLine( GetTypeName() ); } ssortingng SomeMethod(object someParameter) { return ssortingng.Format("Some text {0}", someParameter.ToSsortingng()); } ssortingng GetTypeName() { return (typeof (T)).FullName; } 

int est utilisé pour déclarer une variable primitive

 eg int i=10; 

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

 Integer a = new Integer(); 

Java:

int , double , long , byte , float , double , short , boolean , char -primitives. Utilisé pour contenir les types de données de base pris en charge par le langage. les types primitifs ne font pas partie de la hiérarchie des objects et n’héritent pas des objects. Vous pouvez passer par référence à une méthode.

Double , Float , Long , Integer , Short , Byte , Character et Boolean sont des wrappers de type ” java.lang . Tous les wrappers de type numérique définissent des constructeurs permettant de construire un object à partir d’une valeur donnée ou une représentation sous forme de chaîne de cette valeur. L’utilisation d’objects peut append une surcharge, même aux calculs les plus simples.

À partir de JDK 5, Java comprend deux fonctions très utiles: la mise en boîte automatique et la mise en boîte automatique. Autoboxing / unboxing simplifie et simplifie considérablement le code qui doit convertir les types primitifs en objects, et vice versa.

Exemple de constructeurs:

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

Exemple de boxing / unboxing:

 class ManualBoxing { public static void main(Ssortingng 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(Ssortingng args[]) { Integer objInt = 40; // autobox an int int i = objInt ; // auto-unbox System.out.println(i + " " + iOb); // displays 40 40 } } 

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

Une autre chose que je ne vois pas dans les réponses précédentes: en Java, les classes des enveloppes primitives comme Integer, Double, Float, Boolean … et Ssortingng sont supposées être invariantes, de sorte que lorsque vous passez une instance de ces classes, elles sont invoquées. method ne pouvait en aucune façon altérer vos données, en opositión avec la plupart des autres classes, dont les données internes pouvaient être modifiées par ses méthodes publiques. Ainsi, cette classe ne dispose que de méthodes “getter”, pas de “setters”, à part le constructeur.

Dans un programme Java, les littéraux de chaîne sont stockés dans une partie distincte de la mémoire de segment de mémoire, uniquement une instance pour un littéral, afin d’économiser la mémoire en réutilisant ces instances.

Avez-vous déjà programmé avant (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 ssortingng ou inversement, …), mais notez que les méthodes des classes wrapper sont statiques et que vous pouvez les utiliser. à tout moment sans créer d’instance de classe Integer. en résumé:

 int x; Integer y; 

x et y sont tous deux des variables de type int mais y est enveloppé 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.toSsortingng(x); 

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

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

Java se lance automatiquement entre les deux; de Integer à int chaque fois que l’object Integer apparaît en tant qu’argument d’un opérateur int ou est assigné à une variable int, ou une valeur int est affectée à une variable Integer. Ce casting est appelé boxing / unboxing.

Si une variable Integer faisant référence à null est unbox, explicitement ou implicitement, une exception NullPointerException est lancée.

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

Par exemple:

 int number = 7; 

int est le type de données affecté au numéro de variable qui contient la valeur sept. Donc, un int n’est qu’une primitive et non un object.

Alors qu’un Integer est une classe wrapper pour un type de données primitif qui a des méthodes statiques. Cela peut être utilisé comme argument pour une méthode qui requirejs un object, où 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.

Par exemple:

 Integer number = new Integer(5); 

Dans les deux langues (Java et C #), int est 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 object, 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 object quelconque.

C # fournit System.Int32 qui est un type de valeur utilisant une partie de la mémoire appartenant au type de référence sur le tas.

java fournit java.lang.Integer qui est un type de référence fonctionnant sur int . Les méthodes dans Integer ne peuvent pas être compilées directement dans les instructions d’exécution. Nous encadrons donc une valeur int pour la convertir en instance d’Integer et utilisons les méthodes qui attendent une instance de type quelconque (comme toSsortingng() , parseInt() , valueOf() etc).

Dans C #, la variable int se réfère à System.Int32.Any valeur de 4 octets en mémoire peut être interprétée comme une primitive int, qui peut être manipulée par une instance de System.Int32.So int est un alias pour System.Int32.When utilisez integer- méthodes connexes comme int.Parse() , int.ToSsortingng() etc. Integer est compilé dans la structure FCL System.Int32 appelant les méthodes respectives comme Int32.Parse() , Int32.ToSsortingng() .

En Java, le type int est un type de données primitif, où le type Integer est un object.

En C #, le type int est également un type de données identique à System.Int32 . Un integer (comme tout autre type de valeur) peut être encadré (“enveloppé”) dans un object.

En Java int est un type de données primitif alors 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 (); Ssortingng mySsortingngValue = doubleObject.toSsortingng(); 

Les types de données primitifs stockent la mémoire disponible la plus rapide où la classe Helper est complexe et stockée dans la mémoire de suivi.

référence de “David Gassner” Java Essential Training.

“int” est un type de données primitif et “Integer” dans Wrapper Class en Java. “Entier” peut être utilisé comme argument pour une méthode qui nécessite un object, où “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.

int est prédéfini dans la fonction de bibliothèque c # mais en java, nous pouvons créer un object de type Integer

(Version Java) En mots simples int est primitif et Integer est object wrapper pour int.

Un exemple où utiliser Integer vs int, lorsque vous voulez comparer et int variable à nouveau, cela jettera 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...} 

01. Entier peut être nul. Mais int ne peut pas être nul.

 Integer value1 = null; //OK int value2 = null //Error 

02. Seules les valeurs de type Wrapper Classes peuvent être transmises à toute classe de collection.

(Classes d’encapsulation – Booléen, Caractère, Octet, Court, Entier, Long, Flottant, Double)

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

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

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

Oui 02 est correct, beacouse autoboxing.

Autoboxing est la conversion automatique effectuée par le compilateur java entre le type primitif et leur classe wrapper correspondante.

Ensuite, convertissez-la en valeur Integer par la sélection automatique.

En java selon mes connaissances si vous apprenez alors, quand vous écrivez int; alors en java generic, il comstackra le code comme Integer a = new Integer() . Donc, comme pour les génériques, Integer n’est pas utilisé, mais int est utilisé. donc il y a tellement de différence là-bas.