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

Eh bien, en Java un int est une primitive alors qu'un entier est un objet. Ce qui signifie, Si vous avez fait un nouveau nombre entier:

Integer i = new Integer(6);

vous pourriez appeler une méthode sur i:

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

attendu qu'avec un int:

int i = 6;

vous ne pouvez pas appeler n'importe quelles méthodes sur elle, parce qu'elle est simplement une primitive. So:

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

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

int est l'un des rares primitifs en 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 un tas de méthodes pour interagir avec cette propriété (comme la méthode toString() par exemple). Ainsi, Integer est une façon fantaisiste de travailler avec un int (tout comme peut-être String est une façon fantaisiste 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 Je pourrais venir à la réponse. Espérons que cette aide!

objet Integer javadoc

Integer Ojbect vs. int primitive comparison

j'ajouterai aux excellentes réponses données ci-dessus, et je parlerai de la boxe et de la non-boxe, et comment cela s'applique à Java (bien que C# l'ait aussi). Je vais utiliser juste la terminologie Java, parce que je suis plus au fait avec cela.

comme les réponses mentionnées, int est juste un nombre (appelé le unboxed type), tandis que Integer est un objet (qui contient le nombre, donc un boxed type). En langage Java, cela signifie (en plus de ne pas pouvoir appeler les méthodes sur int ), vous ne pouvez pas stocker int ou d'autres types de 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 à partir ont quelque chose appelé auto-boxe et auto-unboxing qui permettent la boxe/unboxing à faire dans les coulisses. Comparez et contrastez: version Java 5:

Deque<Integer> queue;

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

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

Java 1.4 ou une 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 est très pratique parce que vous écrivez moins de code, ces opérations do se produisent en coulisse, avec les mêmes coûts de fonctionnement, de sorte que vous devez encore être conscient de leur existence.

Espérons que cette aide!

je vais juste poster ici puisque certains des autres messages sont légèrement imprécis par rapport à C#.

Correct: int est un alias pour System.Int32 .

Mauvais: 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 la valeur System.Int32 type.

float et le Flotteur n'est pas le même, toutefois, que le droit type de système pour " float " le Système de.Seul. Il y a des types comme celui-ci qui ont des mots-clés réservés qui ne semblent pas correspondre aux noms de type directement.

dans 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 enums. 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 pas le nom de type d'exécution du système.

si la valeur dans l'int sera stockée sur la pile, en mémoire, ou comme un objet 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 i de type System.Int32 , vivant dans un registre ou sur la pile, en fonction des optimisations. Le même déclaration d'un type (struct ou class) définit un champ de 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 les méthodes iterator dans le mélange, ce sont des bêtes tout à fait différentes)

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

object o = i;

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

en ce qui concerne Java 1.5 et autoboxing il y a une "bizarrerie" importante qui vient à jouer lors de la comparaison D'objets entiers.

en Java, les objets entiers avec les valeurs -128 à 127 sont immuables (c'est-à-dire, pour une valeur entière particulière, disons 23, tous les objets entiers instanciés à travers votre programme avec la valeur 23 points à la exacte même objet).

, ceci renvoie true:

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

Tout ceci renvoie false:

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

L' == compare par référence (les variables pointent vers le même objet).

Ce résultat peut différer selon JVM vous utilisez. La spécification autoboxing pour Java 1.5 exige que les entiers (-128 à 127) boxent toujours vers le même objet d'enrubannage.

une solution? = ) On devrait toujours utiliser le nombre entier.méthode equals() en comparant des objets entiers.

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

plus d'informations à java.net exemple à 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 Entier est un type de classe (qui est une sorte de type de référence).

les valeurs primitives ne partagent pas l'état avec les autres valeurs primitives. Une variable dont le type est un type primitif détient 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 de simples références) sont des pointeurs vers ces objets et une référence nulle spéciale, qui se réfère à 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

aussi en Java tout est passé par la valeur. Avec les objets de la valeur qui est transmise est la référence à l'objet. Donc une autre différence entre int et Integer en java est 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);

le la variable deux est passée comme l'entier primitif de type 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 transmise comme référence à un objet qui détient la valeur entière 2.

@WolfmanDragon: Pass by reference fonctionnerait ainsi:

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

quand l'incrément est appelé il passe une référence (pointeur) à la variable a . Et la fonction increment modifie directement la variable a .

Et pour les types d'objets, il 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 , de chaîne de System.String , le double pour les System.Double etc...

personnellement je préfère int, string, double,etc. parce qu'ils n'exigent pas une déclaration using System; :) une raison stupide, je sais...

dans les plates-formes comme Java, int s sont des primitives tandis que Integer est un objet qui détient un champ entier. La distinction importante est que les primitifs sont toujours transmis par la valeur et par définition sont immuables.

Toute opération impliquant une variable primitive renvoie toujours une nouvelle valeur. D'autre part, les objets sont passés par référence. On pourrait faire valoir que le point de l'objet (AKA la référence) est également distribué par de la valeur, mais le contenu ne le sont pas.

il y a de nombreuses raisons d'utiliser les classes d'emballage:

1. nous obtenons un comportement supplémentaire (par exemple, nous pouvons utiliser des méthodes)
2. nous pouvons stocker des valeurs nulles alors qu'en primitives nous ne pouvons pas
3. Collections prennent en charge le stockage des objets et non primitives.

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

"Integer" n'est pas un type valide nom en C# et "int" n'est qu'un alias pour le Système.Int32. Aussi, contrairement à Java (ou C++) il n'y a pas toute spéciale types primitifs en C#, chaque instance d'un type en C# (y compris de type int) est un objet. Voici un code de démonstration:

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

Java:

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

Double , Float , Long , Integer , Short , Byte , Character , et Boolean , sont des emballages de type, emballés dans java.lang . Tous les enveloppements de type numérique définissent des constructeurs qui permettent à un objet d'être construit à partir d'une valeur donnée, ou une représentation de chaîne de cette valeur. L'utilisation d'objets peut ajouter un overhead à même le plus simple des calculs.

commençant par JDK 5, Java a inclus deux fonctionnalités très utiles: l'autoboxing et l'autounboxing. Autoboxing / unboxing simplifie et simplifie considérablement le code qui doit convertir les types primitifs en objets, et vice versa.

exemple de constructeur:

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

Example of autoboxing / autounbox:

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. Le Livre de M. Herbert Schildt a été pris comme référence.

encore Une chose que je ne vois pas dans les réponses précédentes: En Java les classes de wrappers primitives comme Entier, Double, Float, booléen... et String sont supposés être invariants, de sorte que lorsque vous passez une instance de ces classes, la méthode invoquée ne pourrait pas modifier vos données de quelque manière que ce soit, en opositión avec 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', à part le constructeur.

dans une chaîne de caractères java, les littérales sont stockées dans une partie séparée de la mémoire tas, seulement une instance pour littérale, pour sauver la mémoire réutilisant ces instances

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

mais Integer est une classe wrapper que vous pouvez utiliser pour faire certaines fonctions sur une variable int (E. g convertissez-le en chaîne ou en étau...), mais notez que les méthodes dans les classes wrapper sont statiques de sorte que vous pouvez les utiliser à tout moment sans créer une instance de classe entière. en résumé:

int x;
Integer y; 

x et y sont deux variables de type int mais y est enveloppé par une classe entière et a plusieurs méthodes que vous utilisez,mais je cas vous devez appeler certaines fonctions de la classe entière wrapper vous pouvez le faire simplement.

Integer.toString(x);

mais sachez que x et y sont tous les deux corects mais si vous voulez les utiliser comme un 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 capital I) contient une référence à un objet de type (class) entier, ou à null.

Java émet automatiquement entre les deux; de entier à int lorsque L'objet entier apparaît comme un argument à un opérateur int ou est assigné à une variable int, ou une valeur int est assignée à une variable entière. Ce casting est appelé boxe / unboxing.

si une variable entière le référencement null n'est pas encadré, explicitement ou implicitement, une NullPointerException est lancée.

un int et un entier 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 primitives qui peuvent être affectées à une variable qui peut stocker exactement. Une valeur de son type déclaré à la fois.

par exemple:

int number = 7;

où int est le type de données assigné au numéro variable qui détient la valeur sept. Donc un int est juste un primitif pas un objet.

alors qu'un Integer est une classe de wrapper pour un type de données primitif qui a des méthodes statiques. Cela peut être utilisé comme argument à une méthode qui nécessite un objet, où as int peut être utilisé comme argument à une méthode qui nécessite une valeur entière, qui peut être utilisé 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 objet, certaines opérations dans ces langages ne sont pas directement reliées aux instructions fournies par le temps d'exécution et doivent donc être définies comme faisant partie d'un objet d'un type quelconque.

C# fournit System.Int32 , qui est un type de la valeur à l'aide d'une partie de la mémoire qui appartient au type de référence sur le tas.

java fournit un java.lang.Integer qui est une référence de type d'exploitation sur int . Les méthodes de Integer ne peuvent pas être compilées directement pour exécuter des instructions de temps.Donc nous boxons une valeur int pour la convertir en une instance D'entier et utilisons les méthodes qui attendent l'instance d'un certain type (comme toString() , parseInt() , valueOf() etc).

En C# variable de type int renvoie à System.Int32.Any valeur de 4 octets dans la mémoire peut être interprétée comme un int primitif, qui peut être manipulé par l'instance du système.Int32.So int est un alias pour System.Int32.When utilisant des méthodes liées à un nombre entier comme int.Parse() , int.ToString() etc. Entier est compilé dans le FCL System.Int32 struct appelant les méthodes respectives comme Int32.Parse() , Int32.ToString() .

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

En C#, la "151900920 de type" est également un type de données de même que System.Int32 . Un integer (comme tous les autres types de valeurs) 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 pour un type de données à 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 primitives stockent la mémoire disponible la plus rapide où la classe Helper est complexe et stockent dans la mémoire heep.

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

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

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

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

un exemple où utiliser Integer vs int, quand vous voulez comparer et int variable à nouveau null, il lancera l'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. Integer peut être null. Mais l'int ne peut pas être null.

Integer value1 = null; //OK

int value2 = null      //Error

02. Seules les Classes Wrapper peuvent passer des valeurs de type à n'importe quelle classe collection.

(Wrapper Classes - Booléen,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 is correct, beacouse autoboxing.

Autoboxing est la conversion automatique que le compilateur java fait entre le type primitif et la classe d'emballage correspondante.

puis 5 convertir en valeur entière par autoboxing.

en java à ma connaissance si vous apprenez alors, lorsque vous écrivez en a; puis en java generic il compilera du code comme Integer a = new Integer() . Ainsi, comme générique Integer n'est pas utilisé mais int est utilisé. donc, il y a une telle différence.