Question

je lisais En savoir plus sur les logiciels Joel quand je suis tombé sur Joël Spolsky dire quelque chose sur un type particulier de programmeur connaissant la différence entre un int Et un Integer en Java/C# (Langages de Programmation Orientés Objet).

Alors, quelle est la difference?

Était-ce utile?

La solution

En Java, le type 'int' est un primitif, alors que le type 'Integer' est un objet.

En C#, le type 'int' est le même que System.Int32 et est un type valeur (c'est-à-dire plus comme le java 'int').Un entier (comme tout autre type de valeur) peut être en 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 :

Objets fournissent des fonctionnalités de polymorphisme, sont transmis par référence (ou plus précisément, les références sont transmises par valeur) et sont allouées à partir du tas.Inversement, primitives sont des types immuables qui sont transmis par valeur et sont souvent alloués à partir du empiler.

Autres conseils

Eh bien, en Java, un int est une primitive tandis qu'un Integer est un objet.Autrement dit, si vous créez 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 appeler aucune méthode dessus, car il s’agit simplement d’une primitive.Donc:

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 simplement 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 que 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 la réponse la plus proche que je puisse trouver.J'espère que cela t'aides!

Objet entier javadoc

Ojbect entier vs.comparaison primitive int

J'ajouterai aux excellentes réponses données ci-dessus et parlerai de la boxe et du déballage, et de la façon dont cela s'applique à Java (bien que C# l'ait aussi).J'utiliserai uniquement la terminologie Java, car je suis plus au fait avec ça.

Comme les réponses l'ont mentionné, int n'est qu'un nombre (appelé le déballé type), alors que Integer est un objet (qui contient le nombre, donc un en boîte taper).En termes Java, cela signifie (mis à part le fait de ne pas pouvoir appeler des méthodes sur int), vous ne pouvez pas stocker int ou d'autres types de non-objets dans les collections (List, Map, etc.).Afin de les stocker, vous devez d'abord les emballer dans le type de boîte correspondant.

À partir de Java 5, il y a quelque chose qui s'appelle auto-boxe et déballage automatique qui permettent de faire le boxing/unboxing en coulisses.Compare et nuance: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érations faire se produisent en 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!

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

Correct: int est un pseudonyme pour System.Int32.
Faux: 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 System.Int32 type de valeur.

float et Float ne sont cependant pas les mêmes, car 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 types.

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 d'é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 variable i de 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 à intégrer des méthodes d'itération dans le mix, ce sont des bêtes complètement différentes)

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

object o = i;

cela créera une copie encadrée du contenu de i sur le tas.En IL, vous pouvez accéder directement aux méthodes sur l'objet tas, mais en C#, vous devez le reconvertir en 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.)

Concernant Java 1.5 et boxe automatique il y a une « bizarrerie » importante qui entre en jeu 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 le exact même objet).

Exemple, ceci renvoie vrai :

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

Alors que cela renvoie false :

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 selon la JVM que vous utilisez.La spécification autoboxing pour Java 1.5 exige 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'informations sur java.net Exemple à bexhuff.com

En Java, il existe deux types de base dans le 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 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 simplement 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 plusieurs références au même objet.

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

En Java également, tout est transmis par valeur.Avec les objets, la valeur transmise est la référence à l'objet.Ainsi, une autre différence entre int et Integer en Java réside dans la façon dont ils sont transmis 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é comme 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 deux est passé comme référence à un objet qui contient la valeur entière 2.


@WolfmanDragon :Le passage 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 transmet une référence (pointeur) à la variable un.Et le incrément la fonction modifie directement la variable un.

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, chaîne pour System.String, double pour System.Double etc...

Personnellement, je préfère int, string, double, etc.parce qu'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# :

"Integer" 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 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();

Sur des plateformes comme Java, ints sont des primitifs tandis que Integer est un objet 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.D'un autre côté, les objets sont transmis par référence.On pourrait affirmer que le point vers l’objet (AKA la référence) est également transmis par valeur, mais pas le contenu.

Encore une chose que je ne vois pas dans les réponses précédentes :En Java, les classes wrappers primitives comme Integer, Double, Float, Boolean...et String sont censés être invariants, de sorte que lorsque vous transmettez une instance de ces classes, la méthode invoquée ne peut 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.De sorte que cette classe n'a 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 tas, uniquement une instance pour le littéral, afin d'économiser de la mémoire en réutilisant ces instances.

avez-vous déjà programmé auparavant, 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 exécuter 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, vous pouvez donc les utiliser à tout moment sans créer d’instance de classe Integer.en guise de récapitulation :

int x;
Integer y; 

x et y sont tous deux des variables de type int mais y est enveloppé par une classe Integer et possède 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 corrects, mais si vous souhaitez les utiliser uniquement comme type primitif, utilisez la forme simple (utilisée pour définir x).

Java:

int, double, long, byte, float, double, short, boolean, char - les primitifs.Utilisé pour maintenir 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 n'héritent pas d'objet.Ils peuvent être transmis par référence à une méthode.

Double, Float, Long, Integer, Short, Byte, Character, et Boolean, sont de type Wrappers, conditionnés dans java.lang.Tous les wrappers de type numérique définissent des constructeurs qui permettent de construire un objet à 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.

Depuis le JDK 5, Java inclut deux fonctionnalités très utiles :autoboxing et 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 boxing/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
    }
}

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

P.S.Le livre d'Herbert Schildt a été pris comme référence.

int est un type de données primitif.Entier est une classe wrapper.Il peut stocker des données int sous forme d'objets.

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

Java effectue automatiquement un cast entre les deux ;d'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 s’appelle boxing/unboxing.

Si une variable entière référençant null est déballée, explicitement ou implicitement, une NullPointerException est levée.

Un int et un 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 pouvant être attribués à une variable pouvant être stockée avec précision.Une valeur de son type déclaré à la fois.

Par exemple:

int number = 7;

int est le type de données attribué au numéro de variable qui contient la valeur sept.Donc un int n'est qu'un primitif, pas un objet.

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

Par exemple:

Integer number = new Integer(5);

Dans les deux langages (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 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# fournit System.Int32 qui est un type valeur utilisant une partie de la mémoire qui appartient au type référence sur le tas.

Java fournit java.lang.Integer qui est un type de référence opérant sur int.Les méthodes dans Integer ne peut pas être compilé directement pour exécuter des instructions d'exécution. Nous encadrons donc une valeur int pour la convertir en une instance d'Integer et utilisons les méthodes qui attendent une instance d'un certain type (comme toString(), parseInt(), valueOf() etc).

En C#, la variable int fait référence à System.Int32.Any La 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. Donc int est un alias pour System.Int32.When en utilisant des méthodes liées aux entiers comme int.Parse(), int.ToString() etc.L'entier est compilé dans le FCL System.Int32 struct appelant les méthodes respectives comme Int32.Parse(), Int32.ToString().

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

En C#, le int type 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 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 sont stockés dans la mémoire vive.

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

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

01.L'entier peut être nul.Mais int ne peut pas être nul.

Integer value1 = null; //OK

int value2 = null      //Error

02.Seul peut transmettre les valeurs de type Wrapper Classes à n’importe quelle classe de collection.

(Classes Wrapper - Booléen, Caractère, Octet, Court, Entier, Long, Flottant, 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, parce que autoboxing.

L'autoboxing est la conversion automatique que le compilateur Java fait entre le type primitif et leur classe de wrapper correspondante.

Puis 5 convertissez en valeur entière par autoboxing.

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

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

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

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

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top