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

voix
222

Je lisais plus Joel on Software quand je suis tombé sur Joel Spolsky dire quelque chose au sujet d' un type particulier de programmeur connaissant la différence entre un intet un Integeren Java / C # (langages de programmation orientée objet).

Alors, quelle est la difference?

Créé 02/08/2008 à 22:47
source utilisateur
Dans d'autres langues...                            


27 réponses

voix
216

En Java, le type « int » est un primitif, tandis que le type du « Integer » est un objet.

En C #, le type « int » est le même que System.Int32et est un type de valeur (plus comme le java « int »). Un entier (comme tous les autres types de valeur) peut être emballé ( « enveloppé ») dans un objet.


Les différences entre les objets et primitives sont un peu au-delà de la portée de cette question, mais pour résumer:

Les objets fournissent des installations pour le polymorphisme, sont passés par référence (ou plus ont des références avec précision passés par valeur), et sont attribués à partir du tas . A l' inverse, les primitives sont des types immuables qui sont passés par valeur et sont souvent attribués à partir de la pile .

Créé 02/08/2008 à 22:55
source utilisateur

voix
135

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 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 entier:

int i = 6;

Vous ne pouvez pas appeler des méthodes sur elle, parce qu'il est tout simplement une primitive. Alors:

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

produirait une erreur, car int est pas un objet.

int est l'une des rares primitives Java (ainsi que l'omble chevalier et quelques autres). Je ne suis pas sûr à 100%, mais je pense que l'objet entier plus ou moins a 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). Alors entier est une façon élégante de travailler avec un int (Tout comme peut-être cordes est une façon élégante de travailler avec un groupe de caractères).

Je sais que Java est pas C, mais comme je ne l'ai jamais programmé en C c'est le plus proche que je pouvais venir à la réponse. J'espère que cela t'aides!

objet entier javadoc

Entier Ojbect vs. int comparaison primitive

Créé 02/08/2008 à 23:05
source utilisateur

voix
32

Je vais ajouter aux excellentes réponses données ci - dessus, et parle de la boxe et unboxing, et comment cela s'applique à Java (bien que C # a aussi). Je viens d' utiliser la terminologie Java, parce que je suis plus au fait avec cela.

Comme les réponses mentionnées, intest juste un numéro (appelé le Unboxed type), alors Integerest un objet (qui contient le numéro, donc une boîte de type). En ce qui concerne Java, cela signifie que ( à 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 boîte dans son type correspondant en boîte.

Java 5 partir ont quelque chose appelé auto-boxing et auto-unboxing qui permettent de se faire de la boxe / unboxing dans les coulisses. Comparer et contraste: 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 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 bytecode identiques. Ainsi, bien que l' auto-boxe et auto-unboxing est très pratique car vous écrivez moins de code, ces opérations ne se 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!

Créé 03/08/2008 à 03:32
source utilisateur

voix
26

Je vais poster ici car certains des autres postes 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 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.

flotteur et flotteur est pas le même cependant que le type de système pour « » float« » est System.Single. Il y a certains types de ce genre qui a réservé des mots - clés qui ne semble pas correspondre directement les 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 énumérations. Avec énumérations , vous pouvez spécifier la taille de stockage à utiliser et dans ce cas , vous ne pouvez utiliser le mot - clé réservé, et non le nom du type d'exécution du système.

Wether la valeur dans l'int sera stocké sur la pile, en mémoire, ou comme un 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, en fonction des optimisations. La même déclaration dans un type (struct ou classe) 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 valable si vous commencez à tirer des méthodes iterator dans le mélange, ceux - ci sont différentes bêtes tout à fait)

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

object o = i;

cela va créer une copie boxed du contenu isur le tas. Dans IL vous pouvez accéder à des méthodes sur l'objet tas directement, mais en C # vous devez jeter revenir à un int, qui va créer une autre copie. Ainsi, l'objet sur le tas ne peut pas être facilement changé en C # sans créer une nouvelle copie en boîte d'une nouvelle valeur int. (Ugh, ce paragraphe ne lit pas du tout facilement.)

Créé 04/08/2008 à 15:11
source utilisateur

voix
18

En ce qui concerne Java 1.5 et autoboxing il y a une « bizarrerie » importante qui vient de jouer lorsque l'on compare des objets entiers.

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

Exemple, cela retourne vrai:

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

Bien que cela retourne false:

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

Le == compare à titre de référence (t les variables pointent vers le même objet).

Ce résultat peut ou non varier en fonction de ce que JVM que vous utilisez. La spécification autoboxing pour Java 1.5 exige que les entiers (-128 à 127) boîte toujours le même objet d'emballage.

Une solution? =) Il faut toujours utiliser la méthode Integer.equals () lorsque l'on compare des objets entiers.

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

Plus d' infos sur java.net Exemple à bexhuff.com

Créé 05/08/2008 à 21:49
source utilisateur

voix
17

En Java , il existe deux types de base de la machine virtuelle Java . 1) Les types primitifs et 2) Types de référence. int est un type primitif et Integer est un type de classe ( ce qui est une sorte 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 possède 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 de manière dynamique ou un tableau. Les valeurs de référence (souvent de références) sont des pointeurs vers ces objets et une référence spéciale nulle, qui 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 de la valeur qui est transmise est la référence à l'objet. Donc, une autre différence entre int et entier 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 variable deux est transmis comme le type entier primitive 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 une référence à un objet qui contient la valeur de nombre entier 2.


@WolfmanDragon: 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 incrément est appelé il passe une référence (pointeur) à la variable a . Et l' incrément fonction modifie directement la variable a .

Et pour les types d'objet, 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 maintenant la différence?

Créé 06/08/2008 à 12:08
source utilisateur

voix
11

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

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

Créé 03/08/2008 à 00:37
source utilisateur

voix
8

Il y a beaucoup de raisons d'utiliser les 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. Collections d'objets et de stockage prennent en charge non primitives.
Créé 31/07/2014 à 11:07
source utilisateur

voix
8

Dans les plates - formes comme Java, ints sont des primitives tout Integerest un objet qui contient un champ entier. La distinction importante est que les primitifs sont toujours passés autour de 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 autour par référence. On pourrait faire valoir que le point à l'objet (AKA la référence) est également passé autour de la valeur, mais le contenu ne sont pas.

Créé 31/01/2009 à 03:49
source utilisateur

voix
7

Java:

int, double, long, byte, float, double, short, boolean, char- primitives. Utilisé pour tenir 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 ne héritent pas l' objet. Thet can'be passer par référence à un procédé.

Double, Float, Long, Integer, Short, Byte, CharacterEt Boolean, sont de type wrappers, emballés dans java.lang. Tous les emballages de type numérique définie constructeurs qui permettent à un objet devant être construit à partir d' une valeur donnée, ou une représentation de chaîne de cette valeur. L' utilisation d' objets peuvent ajouter des frais généraux à même le plus simple des calculs.

À partir de 5 JDK, Java a inclus deux fonctionnalités très utiles: autoboxing et autounboxing. Autoboxing / unboxing simplifie et rationalise 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 / 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 de 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é prise comme référence.

Créé 13/06/2016 à 19:31
source utilisateur

voix
7

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 entière

Integer a = new Integer();
Créé 11/12/2011 à 08:19
source utilisateur

voix
7

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

« Entier » est pas un nom de type valide en C # et « int » est juste un alias pour System.Int32. En outre, 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;
}
Créé 04/08/2008 à 22:02
source utilisateur

voix
6

avez-vous déjà programmé avant cette date (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 l'utiliser pour faire des fonctions sur une variable int (par exemple, convertir en versa string ou étau, ...), mais gardez note que les méthodes dans les classes d'emballage sont statiques afin que vous puissiez les utiliser à tout moment, sans créer une instance de la classe entière. comme récapituler:

int x;
Integer y; 

x et y sont les deux variables de type int, mais y est enveloppé par une classe entière et a plusieurs méthodes que vous utilisez, mais je le cas où vous avez besoin d'appeler des fonctions de classe wrapper entier vous pouvez le faire simplement.

Integer.toString(x);

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

Créé 17/05/2014 à 12:56
source utilisateur

voix
6

Une chose que je ne vois pas dans les réponses précédentes: En Java les wrappers primitives des classes comme Integer, Double, Float, Boolean ... et String sont suposed invariante, de sorte que lorsque vous passez une instance de ces classes le invoquée méthode ne pouvait pas modifier vos données de quelque façon, en oposition avec la plupart des autres classes, données internes pourraient être modifiées par ses méthodes publiques. Alors que ce cours a que des méthodes « getter », pas « setters », en plus du constructeur.

Dans un programme java littéraux de chaîne sont stockés dans une partie séparée de la mémoire de tas, une seule instance pour littéral, pour sauver la mémoire réutiliser ces instances

Créé 06/08/2008 à 15:33
source utilisateur

voix
4

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

En C #, le inttype est également un type de données identique System.Int32. Un integer(comme tous les autres types de valeur) peut être acculé ( « enveloppé ») dans un objet.

Créé 27/04/2017 à 07:25
source utilisateur

voix
4

Un int et entier en Java et C # sont deux termes différents pour représenter des choses différentes. Il est l'un des types de données primitifs 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;

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

Même si un Integerest une classe wrapper pour un type de données primitive qui a des méthodes statiques. Qui peut être utilisé comme argument un procédé qui nécessite un objet, alors que int peut être utilisé comme argument un procédé qui nécessite une valeur entière, qui peut être utilisé pour l' expression arithmétique.

Par exemple:

Integer number = new Integer(5);
Créé 07/08/2014 à 11:50
source utilisateur

voix
4

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

Contrairement à Java, C # Fournit les deux valeurs entières signées et non signées. Comme Java et C # sont orienté objet objet, certaines opérations dans ces langues ne correspondent pas directement sur les instructions fournies par le temps d'exécution et doit donc être définie dans le cadre d'un objet d'un certain type.

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

Java fournit ce java.lang.Integerqui est un type de référence agissant sur int. Les méthodes Integerne peuvent pas être compilé 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.).

Dans la variable C # int se réfère à la System.Int32.Anyvaleur de 4 octets dans la mémoire peut être interprété comme un int primitif, qui peut être manipulée par exemple de System.Int32.So int est un alias en System.Int32.Whenutilisant des procédés liés entiers en forme int.Parse(), int.ToString()etc. entier est compilé dans la LCM System.Int32struct appelant les méthodes respectives comme Int32.Parse(), Int32.ToString().

Créé 17/07/2014 à 07:02
source utilisateur

voix
3

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

Créé 03/06/2019 à 10:01
source utilisateur

voix
3

En Java int est un type de données primitif en entier est une classe d'aide, il est d'utiliser pour convertir pour un type de données à l'autre.

Par exemple:

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

types de données primitives sont stocker la mémoire la plus rapide disponible là où la classe Helper est complexe et stocker dans la mémoire Heep.

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

Créé 28/02/2016 à 18:42
source utilisateur

voix
3

Une variable d'int contient une valeur de nombre entier signé 32 bits. Un entier (avec I majuscule) contient une référence à un objet de (classe) de type entier, ou une valeur nulle.

Java lance automatiquement entre les deux; de Integer int chaque fois que l'objet entier se produit comme un argument à un opérateur d'int ou est affectée à une variable d'int, ou une valeur d'int est affectée à une variable entière. Cette coulée est appelée la boxe / unboxing.

Si un null référence variable entière est unboxed, explicitement ou implicitement, une NullPointerException est levée.

Créé 26/11/2015 à 10:54
source utilisateur

voix
1

« Int » est primitive des données de type et « Entier » dans classe wrapper en Java. « Integer » peut être utilisé comme argument un procédé qui nécessite un objet, alors que « int » peut être utilisé comme argument un procédé qui nécessite une valeur entière, qui peut être utilisé pour l'expression arithmétique.

Créé 04/08/2017 à 09:57
source utilisateur

voix
1

int est prédéfini en fonction de la bibliothèque c #, mais en Java, nous pouvons créer ojet de Integer

Créé 06/03/2017 à 05:08
source utilisateur

voix
0

Où est le type « entier » en C #? Quelqu'un peut-il me aider à trouver en C #?

Créé 20/08/2019 à 12:52
source utilisateur

voix
0

int est un type primitif tandis que Integer est un objet. Création d'un objet avec Integer vous donnera accès à toutes les méthodes disponibles dans la classe entière. Mais, si vous créez un type de données primitive avec int, vous ne serez pas en mesure d'utiliser ces méthodes inbuild et vous devez les définir par vous-même. Mais, si vous ne voulez pas d'autres méthodes et que vous voulez rendre plus efficace la mémoire du programme, vous pouvez aller avec un type de données primitif car la création d'un objet augmentera la consommation de mémoire.

Créé 03/07/2019 à 08:35
source utilisateur

voix
0

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

Integer value1 = null; //OK

int value2 = null      //Error

02. Ne peut transmettre des valeurs Wrapper de type Classes à une classe de collection.

(Classes Wrapper - Boolean, caractère, 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? Est-ce le point 02 correct?

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

Oui 02 est exact, beacouse autoboxing.

Autoboxing est la conversion automatique que le compilateur Java fait entre le type primitif et leur classe enveloppe correspondante.

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

Créé 05/06/2018 à 11:35
source utilisateur

voix
0

(Version Java) en termes simples int est primitive et entier est un objet wrapper pour int.

Un exemple où utiliser des entiers vs int, Lorsque vous voulez comparer et int variable nulle à nouveau, il lancera 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...}
Créé 15/02/2018 à 21:04
source utilisateur

voix
0

En java selon ma connaissance si vous apprenant alors, lorsque vous écrivez un int; puis en Java générique, il va compiler le code comme entier a = new entier. Ainsi, selon nombre entier de génériques n'est pas utilisé, mais int est utilisé. donc il y a tellement de différence comme il.

Créé 22/09/2016 à 09:53
source utilisateur

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more