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

Je lisais Plus Joel sur le logiciel quand je suis tombé sur Joel Spolsky disant quelque chose sur un type particulier de programmeur connaissant la différence entre un intet un Integeren Java / C # (Object-Oriented Programming Language).

Alors, quelle est la difference?

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 que System.Int32et est un type valeur (c'est-à-dire plus comme le java 'int'). Un entier (comme tout autre type de valeur) peut être encadré ("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:

Les objets fournissent des fonctionnalités pour le polymorphisme, sont passés par référence (ou plus précisément, les références sont passées par valeur) et sont alloués à partir du tas . Inversement, les primitives sont des types immuables passés par valeur et souvent allouées à partir de la pile .

Eh bien, en Java, un int est une primitive tandis qu'un entier est un objet. Signification, si vous avez fait un nouveau nombre 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 pas appeler de 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 élégante de travailler avec un int (tout comme peut-être String 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 la réponse la plus proche. J'espère que cela t'aides!

Objet entier javadoc

Comparaison primitive entre Ojbect entier et int primitif

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). Je vais utiliser uniquement la terminologie Java parce que je suis plus au fait de cela.

Comme les réponses mentionnées, intest juste un nombre (appelé le type sans boîte ), tandis Integerqu'un objet (qui contient le nombre, donc un type en boîte ). En ce qui concerne Java, que des moyens ( à l' exception de ne pas être en mesure d'appeler des méthodes sur int), vous ne pouvez pas stocker intou d' autres types non-objet dans les collections ( List, Map, etc.). Pour les stocker, vous devez d'abord les emballer dans le type de boîte correspondant.

Java 5 et versions ultérieures ont quelque chose appelé l' auto-boxing et l' auto-unboxing qui permettent de faire de la boxe / unboxing dans les coulisses. Comparaison et contraste: 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-boxe et auto-unboxing sont très pratiques parce que vous écrivez moins de code, ces opérations ne se passe dans les coulisses, avec les mêmes coûts d'exécution, de sorte que vous devez toujours être au courant de leur existence.

J'espère que cela t'aides!

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

Correct: int est un alias pour System.Int32.
Faux: float n'est pas un alias pour System.Float, mais pourSystem.Single

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

float et Float ne sont pas les mêmes cependant, car le bon type de système pour '' float'' est System.Single. Il existe des types comme celui-ci qui ont réservé des mots clé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 l'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 façon dont vous l'utilisez.

Cette déclaration dans une méthode:

int i;

définit une variable ide type System.Int32, vivant dans un registre ou sur la pile, selon les optimisations. La même déclaration dans un type (struct ou classe) 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érateur dans le mélange, ce sont des bêtes différentes)

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

object o = i;

cela va créer une copie encadrée du contenu de isur le tas. En IL, vous pouvez accéder directement aux méthodes sur l'objet tas, mais en C #, vous devez le convertir 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 lit pas tout cela facilement.)

En ce qui concerne Java 1.5 et la mise en boîte automatique, il existe une importante "bizarrerie" qui vient à jouer lors de la comparaison des 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 exactement vers le mê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 renvoie 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 ou non différer selon la machine virtuelle Java que vous utilisez. La spécification d'autoboxing pour Java 1.5 nécessite que les entiers (-128 à 127) soient toujours placés dans 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 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 une sorte de type de référence).

Les valeurs primitives ne partagent pas d'é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 null 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

Toujours en Java, tout est transmis par valeur. Avec les objets, la valeur transmise est la référence à l'objet. Donc, une autre différence entre int et Integer en java est de savoir comment 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 qu'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 deux est passée comme référence à un objet qui contient la valeur entière 2.

@WolfmanDragon: passer par référence fonctionnerait comme suit:

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

Lorsque l'incrément est appelé, il transmet une référence (pointeur) à la variable a . Et la fonction d' incrémentation modifie directement la variable a .

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?

En C #, int est juste un alias pour System.Int32, une chaîne pour System.String, un double pour System.Doubleetc ...

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

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.

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" n'est qu'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;
}

int est utilisé pour déclarer la variable primitive

e.g. int i=10;

Entier est utilisé pour créer la variable de référence de la classe Entier

Integer a = new Integer();

Dans des plates-formes comme Java, ints sont des primitives tandis Integerqu'un objet contient 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 faire valoir que le point vers l'objet (AKA la référence) est également transmis par valeur, mais le contenu ne l'est pas.

Une dernière chose que je ne vois pas dans les réponses précédentes: En Java, les classes d'encapsuleurs primitifs comme Integer, Double, Float, Boolean ... et String sont supposées être invariantes, de sorte que lorsque vous passez une instance de ces classes, l'invoqué La méthode ne pouvait en aucun cas modifier vos données, en opposition avec la plupart des autres classes, lesquelles données internes pouvaient être modifiées par ses méthodes publiques. Pour que 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 tas, uniquement une instance de littéral, pour économiser de 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 effectuer 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 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 encapsulé par une classe Integer et possède plusieurs méthodes que vous utilisez, mais si vous avez besoin d'appeler certaines fonctions de la classe wrapper Integer, vous pouvez le faire simplement.

Integer.toString(x);

mais sachez que x et y sont corrects mais si vous souhaitez les utiliser uniquement comme type primitif, utilisez le formulaire simple (utilisé pour définir x).

Java:

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

Double, Float, Long, Integer, Short, Byte, Character, Et Boolean, sont de type wrappers, emballés dans java.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 des frais généraux aux calculs les plus simples.

À partir de JDK 5, Java a inclus deux fonctionnalités très utiles: l'autoboxing et l'autounboxing. 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.

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

Java jette automatiquement entre les deux; de Integer à int chaque fois que l'objet Integer apparaît comme 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 / unboxing.

Si une variable Integer faisant référence à null n'est pas mise en boîte, explicitement ou implicitement, une NullPointerException est levée.

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

Par exemple:

int number = 7;

Où intest le type de données affecté au numéro de variable qui contient la valeur sept. Un intn'est donc qu'un primitif et non un objet.

Alors que an Integerest 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 nécessite un objet, où as 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 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 objet, certaines opérations dans ces langages ne sont pas mappées directement sur les instructions fournies par l'exécution et doivent donc être définies comme faisant partie d'un objet d'un certain type.

C # fournit System.Int32un type de valeur utilisant une partie de la mémoire qui appartient au type de référence sur le tas.

java fournit java.lang.Integerlequel est un type de référence fonctionnant int. Les méthodes Integerne peuvent pas être compilées directement pour exécuter le temps instructions.So nous boîte une valeur int pour le convertir en une instance de nombre entier et d' utiliser les méthodes qui s'attend par exemple d' un certain type (comme toString(), parseInt(), valueOf()etc.).

En C #, la variable int fait référence à une System.Int32.Anyvaleur de 4 octets en mémoire qui peut être interprétée comme un int primitif, qui peut être manipulé par une instance de System.Int32.So int est un alias pour System.Int32.Whenutiliser des méthodes liées aux entiers comme int.Parse(), int.ToString()etc. L'entier est compilé en la LCM System.Int32struct appelant les méthodes respectives comme Int32.Parse(), Int32.ToString().

En Java, le inttype est un type de données primitif, alors que le Integertype est un objet.

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

En Java, int est un type de données primitif tandis que Integer est une classe d'assistance, 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 où la classe Helper est complexe et sont stockés dans la mémoire heep.

référence de "David Gassner" Java Essential Training.

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

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

Integer value1 = null; //OK

int value2 = null      //Error

02. Seul peut transmettre des valeurs de type Classes Wrapper à 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, beacouse autoboxing.

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

Ensuite, 5 convertissez en valeur entière par autoboxing.

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

(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 souhaitez comparer et int variable à nouveau null, il 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...}

En java selon mes connaissances si vous apprenez alors, lorsque vous écrivez int a; puis en java generique il compilera du code comme Integer a = new Integer(). Ainsi, selon les génériques Integern'est pas utilisé mais intest utilisé. donc il y a tellement de différence là-bas.

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

int est un type de données primitif tandis 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 de construction et vous devrez les définir vous-même. Mais, si vous ne voulez pas d'autres méthodes et que vous souhaitez rendre le programme plus efficace en mémoire, vous pouvez utiliser le type de données primitif car la création d'un objet augmentera la consommation de mémoire.