Qual è la differenza tra un int e un intero in Java e C #?

voti
222

Stavo leggendo Più Joel on Software quando mi sono imbattuto Joel Spolsky dire qualcosa su un particolare tipo di programmatore conoscere la differenza tra un inted una Integerin Java / C # (Object Oriented Programming Languages).

Quindi, qual è la differenza?

È pubblicato 02/08/2008 alle 22:47
fonte dall'utente
In altre lingue...                            


27 risposte

voti
216

In Java, del tipo 'int' è un primitivo, mentre il tipo la 'integer' è un oggetto.

In C #, del tipo 'int' è la stessa System.Int32ed è un tipo di valore (ossia più come il java 'int'). Un numero intero (come qualsiasi altro tipo di valore) può essere confezionato ( "avvolto") in un oggetto.


Le differenze tra oggetti e primitive sono un po 'oltre lo scopo di questa domanda, ma per riassumere:

Oggetti forniscono caratteristiche polimorfismo, sono passati per riferimento (o avere più accuratamente riferimenti passati per valore), e sono assegnati dal cumulo . Viceversa, le primitive sono tipi immutabili che vengono passati per valore e spesso sono allocati dalla pila .

Risposto il 02/08/2008 a 22:55
fonte dall'utente

voti
135

Ebbene, in Java un int è un primitivo, mentre un intero è un oggetto. Che significa, se hai fatto un nuovo Integer:

Integer i = new Integer(6);

Si potrebbe chiamare un metodo su i:

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

Mentre con un int:

int i = 6;

Non è possibile chiamare i metodi su di esso, perché è semplicemente un primitivo. Così:

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

produrrebbe un errore, perché int non è un oggetto.

int è una delle poche primitive in Java (insieme a char e alcuni altri). Sono sicuro al 100%, ma sto pensando che l'oggetto Integer più o meno ha appena una proprietà int e un insieme di metodi per interagire con la proprietà (come il metodo toString () per esempio). Così Integer è un modo elegante per lavorare con un int (Proprio come forse String è un modo elegante per lavorare con un gruppo di caratteri).

So che Java non è C, ma dal momento che non ho mai programmato in C questo è il più vicino ho potuto venire alla risposta. Spero che questo ti aiuti!

javadoc oggetto intero

Integer Ojbect vs int confronto primitiva

Risposto il 02/08/2008 a 23:05
fonte dall'utente

voti
32

Io aggiungo alle eccellenti risposte di cui sopra, e parlare di boxe e unboxing, e come questo vale per Java (anche se C # è troppo). Userò solo la terminologia Java, perché io sono più al corrente con quello.

Poiché le risposte menzionato, intè solo un numero (chiamato unboxed tipo), che Integerè un oggetto (che contiene il numero, quindi un scatolato tipo). In termini di Java, che significa (oltre a non essere in grado di chiamare metodi su int), Non è possibile memorizzare into di altro tipo non-oggetto in collezioni ( List, Map, ecc). Al fine di conservarli, è necessario prima box in alto nella sua corrispondente tipo scatolato.

Java 5 hanno poi qualcosa chiamato auto-boxing e auto-unboxing che permettono la boxe / unboxing da fare dietro le quinte. Confronto e contrasto: Java 5 Versione:

Deque<Integer> queue;

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

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

Java 1.4 o versioni precedenti (non generici o):

Deque queue;

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

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

Si deve notare che, nonostante la brevità nella versione Java 5, entrambe le versioni generano bytecode identici. Quindi, anche se l'auto-boxing e auto-unboxing è molto conveniente, perché si scrive meno codice, queste operazioni non accadere dietro le quinte, con gli stessi costi di runtime, in modo da avere ancora di essere a conoscenza della loro esistenza.

Spero che questo ti aiuti!

Risposto il 03/08/2008 a 03:32
fonte dall'utente

voti
26

Mi limiterò a postare qui dal momento che alcuni degli altri posti sono leggermente inesatte in relazione a C #.

Corretto: int è un alias per System.Int32.
Sbagliato: float non è un alias per System.Float, ma perSystem.Single

In sostanza, int è una parola chiave riservata nel linguaggio di programmazione C #, ed è un alias per il System.Int32tipo di valore.

galleggiante e galleggiante non è la stessa tuttavia, come il tipo giusto sistema per '' float'' è System.Single. Ci sono alcuni tipi come questo che ha riservato le parole chiave che non sembrano corrispondere direttamente i nomi dei tipi.

In C # non v'è alcuna differenza tra '' int'' e '' System.Int32'', o una qualsiasi delle altre coppie o le parole chiave / tipi di sistema, ad eccezione di quando si definiscono le enumerazioni. Con enumerazioni è possibile specificare la dimensione della memoria da utilizzare e in questo caso è possibile utilizzare solo la parola chiave riservata, e non il sistema di runtime nome del tipo.

Wether il valore nel int verrà memorizzato nello stack, in memoria, o come un oggetto mucchio di riferimento dipende dal contesto e come lo si utilizza.

Questa dichiarazione in un metodo:

int i;

definisce una variabile idi tipo System.Int32, che vivono in un registro o in pila, a seconda ottimizzazioni. La stessa dichiarazione in un tipo (o una classe struct) definisce un campo utente. La stessa dichiarazione in una lista metodo argomento definisce un parametro, con le stesse opzioni di archiviazione come una variabile locale. (si noti che questo paragrafo non è valida se si inizia a tirare i metodi iteratore nel mix, questi sono diversi bestie del tutto)

Per ottenere un oggetto heap, è possibile utilizzare la boxe:

object o = i;

questo creerà una copia inscatolata del contenuto del isul mucchio. In IL è possibile accedere a metodi sull'oggetto mucchio direttamente, ma in C # è necessario lanciare di nuovo a un int, che creerà un'altra copia. Così, l'oggetto sul mucchio non può essere facilmente modificato in C # senza creare una nuova copia in scatola di un nuovo valore int. (Ugh, questo paragrafo non legge tutto ciò che facilmente.)

Risposto il 04/08/2008 a 15:11
fonte dall'utente

voti
18

Per quanto riguarda Java 1.5 e autoboxing v'è un importante "vezzo" che viene a giocare quando si confrontano gli oggetti Integer.

In Java, interi oggetti con i valori -128 a 127 sono immutabili (cioè, per un particolare valore intero, dire 23, tutti gli oggetti Integer istanziati tramite il programma con il valore 23 punti al esatto stesso oggetto).

Esempio, questo ritorna vero:

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

Anche se questo restituisce false:

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

Il == confronta con riferimento (fa le variabili puntano allo stesso oggetto).

Questo risultato può o non può essere diverso a seconda di ciò che si sta utilizzando JVM. La specifica autoboxing per Java 1.5 richiede che i numeri interi (da -128 a 127) box sempre allo stesso oggetto wrapper.

Una soluzione? =) Si deve sempre utilizzare i Integer.equals () metodo quando si confrontano gli oggetti Integer.

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

Maggiori informazioni presso java.net Esempio a bexhuff.com

Risposto il 05/08/2008 a 21:49
fonte dall'utente

voti
17

In Java ci sono due tipi di base nella JVM . 1) I tipi primitivi e 2) tipi di riferimento. int è un tipo primitivo e Integer è un tipo di classe (che è una specie di tipo di riferimento).

valori primitivi non condividono stato con altri valori primitivi. Una variabile il cui tipo è un tipo primitivo contiene sempre un valore di base di tale tipo.

int aNumber = 4;
int anotherNum = aNumber;
aNumber += 6;
System.out.println(anotherNum); // Prints 4

Un oggetto è un'istanza classe creata dinamicamente o una matrice. I valori di riferimento (spesso solo riferimenti) sono puntatori a questi ed uno speciale riferimento null, che fa riferimento ad alcun oggetto. Ci possono essere molti riferimenti allo stesso oggetto.

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

Anche in Java tutto è passato per valore. Con oggetti il ​​valore passato è il riferimento all'oggetto. Quindi, un'altra differenza tra int e Integer in Java è il modo in cui vengono passati in chiamate di metodo. Ad esempio in

public int add(int a, int b) {
    return a + b;
}
final int two = 2;
int sum = add(1, two);

La variabile due viene passato come il primitivo tipo intero 2. considerando

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 variabile due viene passato come un riferimento a un oggetto che contiene il valore intero 2.


@WolfmanDragon: Passaggio per riferimento avrebbe funzionato in questo modo:

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

Quando incremento è chiamato passa un riferimento (puntatore) alla variabile una . E l' incremento funzione modifica direttamente variabile una .

E per i tipi di oggetto che avrebbe funzionato come segue:

public void increment(Integer x) {
  x = Integer.valueOf(x.intValue() + 1);
}
Integer a = Integer.valueOf(1);
increment(a);
// a is now 2

Vedete la differenza oggi?

Risposto il 06/08/2008 a 12:08
fonte dall'utente

voti
11

In C #, int è solo un alias per System.Int32, stringa per System.String, doppia System.Doubleetc ...

Personalmente preferisco int, string, doppia, ecc, perché non richiedono una using System;dichiarazione :) Un motivo stupido, lo so ...

Risposto il 03/08/2008 a 00:37
fonte dall'utente

voti
8

Ci sono molte ragioni per usare classi wrapper:

  1. Otteniamo comportamento extra (per esempio possiamo usare metodi)
  2. Siamo in grado di memorizzare i valori nulli mentre in primitive, non possiamo
  3. Collezioni supporta la memorizzazione oggetti e non primitive.
Risposto il 31/07/2014 a 11:07
fonte dall'utente

voti
8

In piattaforme come Java, ints sono primitive mentre Integerè un oggetto che contiene un campo intero. La distinzione importante è che le primitive sono sempre passati in giro per valore e per definizione sono immutabili.

Qualsiasi operazione che comporti una variabile primitiva restituisce sempre un nuovo valore. D'altra parte, gli oggetti vengono passati in giro per riferimento. Si potrebbe sostenere che il punto all'oggetto (noto come riferimento) viene anche passato in giro per valore, ma i contenuti non sono.

Risposto il 31/01/2009 a 03:49
fonte dall'utente

voti
7

Giava:

int, double, long, byte, float, double, short, boolean, char- primitive. Usato per tenere i tipi di dati di base supportati dal linguaggio. i tipi primitivi non fanno parte della gerarchia degli oggetti, e non si ereditano oggetto. Thet can'be passare riferimento a un metodo.

Double, Float, Long, Integer, Short, Byte, Character, E Boolean, sono di tipo Confezionatrici, confezionati in java.lang. Tutti gli involucri di tipo numerico definiscono costruttori che consentono a un oggetto per essere costruito da un dato valore, o una rappresentazione di stringa di tale valore. Uso di oggetti può aggiungere un overhead per uniformare il più semplice dei calcoli.

Cominciando con JDK 5, Java ha incluso due caratteristiche molto utili: autoboxing e autounboxing. Autoboxing / unboxing semplifica e razionalizza codice che deve convertire tipi primitivi in ​​oggetti, e viceversa.

Esempio di costruttori:

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

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

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

Il libro di PS Herbert Schildt è stato preso come riferimento.

Risposto il 13/06/2016 a 19:31
fonte dall'utente

voti
7

int consente di dichiarare variabile primitiva

e.g. int i=10;

Intero viene usato per creare variabile di riferimento di classe intero

Integer a = new Integer();
Risposto il 11/12/2011 a 08:19
fonte dall'utente

voti
7

Questo è già stato risposto per Java, ecco la C # risposta:

"Integer" non è un nome di tipo valido in C # e "int" è solo un alias per System.Int32. Inoltre, a differenza di Java (o C ++) non ci sono particolari tipi primitivi in ​​C #, ogni istanza di un tipo in C # (compresi int) è un oggetto. Ecco po 'di codice dimostrativo:

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;
}
Risposto il 04/08/2008 a 22:02
fonte dall'utente

voti
6

avete mai programmato prima di allora (int) è uno dei tipi primitivi è possibile impostare per le variabili (proprio come char, float, ...).

ma Integer è una classe wrapper che si può utilizzare per fare alcune funzioni in una variabile int (ad esempio, convertirlo in stringa o viceversa, ...), ma tenere nota che i metodi delle classi wrapper sono statici in modo da poterli utilizzare in qualsiasi momento senza creare un'istanza della classe Integer. come un riassunto:

int x;
Integer y; 

xey sono entrambe le variabili di tipo int ma y è avvolto da una classe Integer e ha diversi metodi che si utilizzano, ma caso sia necessario richiamare alcune funzioni di classe Integer avvolgitore si può fare semplicemente.

Integer.toString(x);

ma essere consapevoli che sia x ed y sono corect, ma se si desidera utilizzarli solo come un tipo primitivo, usa il modulo semplice (utilizzato per la definizione x).

Risposto il 17/05/2014 a 12:56
fonte dall'utente

voti
6

Una cosa che non vedo nelle risposte precedenti: In Java le primitive classi wrapper come Integer, Double, Float, booleano ... e String si suppone sia invariante, in modo che quando si passa un'istanza di queste classi l'invocata metodo non può modificare i dati in qualsiasi modo, in Oposition con la maggior parte delle altre classi, quali dati interni potrebbero essere alterati dai suoi metodi pubblici. In modo che questo classi ha solo metodi 'getter', non 'setters', inoltre il costruttore.

In un programma Java Le stringhe sono memorizzati in una parte separata della memoria heap, solo un'istanza per letterale, per risparmiare memoria riutilizzare quei casi

Risposto il 06/08/2008 a 15:33
fonte dall'utente

voti
4

In Java, il inttipo è un'operazione primitiva, in cui il Integertipo è un oggetto.

In C #, il inttipo è anche un tipo di dati stessa System.Int32. Un integer(proprio come qualsiasi altro tipo di valore) può essere inscatolato ( "avvolto") in un oggetto.

Risposto il 27/04/2017 a 07:25
fonte dall'utente

voti
4

Un int e Integer in Java e C # sono due diversi termini utilizzati per rappresentare cose diverse. È uno dei tipi di dati primitivi che possono essere assegnati ad una variabile che può memorizzare esattamente. Un valore del suo tipo dichiarato alla volta.

Per esempio:

int number = 7;

Dove intè il tipo di dati assegnato al numero variabile che contiene il valore di sette. Quindi, una intè solo un primitivo non un oggetto.

Mentre una Integerè una classe wrapper per un'operazione primitiva che ha metodi statici. Che può essere utilizzato come argomento di un procedimento che richiede un oggetto, dove come int può essere utilizzato come argomento di un metodo che richiede un valore intero, che può essere utilizzato per l'espressione aritmetica.

Per esempio:

Integer number = new Integer(5);
Risposto il 07/08/2014 a 11:50
fonte dall'utente

voti
4

In entrambe le lingue (Java e C #) intè di 4 byte intero con segno.

A differenza di Java, C # fornisce sia valori interi con e senza segno. Come Java e C # sono oggetto orientato agli oggetti, alcune operazioni in queste lingue non mappa direttamente su istruzioni fornite dal tempo di esecuzione e così deve essere definito come parte di un oggetto di un certo tipo.

C # fornisce System.Int32che è un tipo valore utilizzando una parte di memoria che appartiene al tipo di riferimento sul mucchio.

java fornisce java.lang.Integerche è un tipo di riferimento operante su int. I metodi Integernon possono essere compilati direttamente al tempo di esecuzione instructions.So abbiamo casella un valore int per convertirlo in un caso di numero intero ed utilizzare i metodi che auspica di esempio di un certo tipo (come toString(), parseInt(), valueOf()ecc).

In C # variabile int riferisce al System.Int32.Anyvalore a 4 byte di memoria può essere interpretato come un int primitivo, che può essere manipolato per esempio di System.Int32.So int è un alias per System.Int32.Whenutilizzando metodi interi relativi simili int.Parse(), int.ToString()ecc integer viene compilato in FCL System.Int32struct chiamando i rispettivi metodi come Int32.Parse(), Int32.ToString().

Risposto il 17/07/2014 a 07:02
fonte dall'utente

voti
3

int è un'operazione primitiva. Integer è una classe wrapper. E 'possibile memorizzare dati int come oggetti.

Risposto il 03/06/2019 a 10:01
fonte dall'utente

voti
3

In Java int è un tipo di dati di base, mentre Integer è una classe Helper, è utilizzare per la conversione di un tipo di dati ad altri.

Per esempio:

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

tipi di dati primitivi sono memorizzare il più veloce memoria disponibile dove la classe Helper è complessa e memorizzare Heep.

di riferimento da "David Gassner" Java Training essenziale.

Risposto il 28/02/2016 a 18:42
fonte dall'utente

voti
3

Una variabile int contiene un valore intero con segno a 32 bit. Un numero intero (a capitale I) contiene un riferimento a un oggetto di (classe) tipo intero, o null.

Java getta automaticamente tra i due; da integer int quando l'oggetto Integer avviene come argomento di un operatore int o viene assegnato ad una variabile int o un valore int viene assegnato ad una variabile intera. Questa fusione è chiamato boxing / unboxing.

Se un riferimento nullo variabile intera è unboxed, esplicitamente o implicitamente, un NullPointerException è gettato.

Risposto il 26/11/2015 a 10:54
fonte dall'utente

voti
1

"Int" è primitivo tipo di dati e "Integer" in classe wrapper in Java. "Integer" può essere utilizzato come argomento di un procedimento che richiede un oggetto, dove come "int" può essere utilizzato come argomento di un metodo che richiede un valore intero, che può essere utilizzato per l'espressione aritmetica.

Risposto il 04/08/2017 a 09:57
fonte dall'utente

voti
1

int è predefinito nella libreria di funzioni C #, ma in Java possiamo creare ogetto di Integer

Risposto il 06/03/2017 a 05:08
fonte dall'utente

voti
0

Dove si trova il tipo 'intero' in C #? Qualcuno può aiutarmi a trovare in C #?

Risposto il 20/08/2019 a 12:52
fonte dall'utente

voti
0

int è un tipo di dati primitivo che intero è un oggetto. Creazione di un oggetto con Integer vi darà l'accesso a tutti i metodi disponibili nella classe Integer. Ma, se si crea un tipo di dati primitivo con int, non sarà in grado di utilizzare gli stessi metodi inbuild e bisogna definirli da soli. Ma, se non si vuole altri metodi e vuole rendere il programma più efficiente della memoria, si può andare con il tipo di dati primitivi perché la creazione di un oggetto aumenterà il consumo di memoria.

Risposto il 03/07/2019 a 08:35
fonte dall'utente

voti
0

01. intero può essere nullo. Ma int non può essere NULL.

Integer value1 = null; //OK

int value2 = null      //Error

02. Solo può passare Wrapper valori classi di tipo a qualsiasi classe di raccolta.

(Classi wrapper - booleano, Carattere, Byte, Corto, Integer, Long, float, double)

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

Ma di solito aggiungiamo valori primitivi alla classe di raccolta? È il punto 02 è corretto?

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

Sì 02 è corretto, beacouse autoboxing.

Autoboxing è la conversione automatica che il compilatore java fa tra il tipo primitivo e loro corrispondenti classe wrapper.

Poi 5 convertito come valore intero autoboxing.

Risposto il 05/06/2018 a 11:35
fonte dall'utente

voti
0

(Java Version) In parole semplici int è primitivo e Integer è oggetto wrapper per int.

Un esempio in cui utilizzare Integer vs int, quando si desidera confrontare e variabile int nuovo valore nullo getterà errore.

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...}
Risposto il 15/02/2018 a 21:04
fonte dall'utente

voti
0

In Java come per la mia conoscenza se studente allora, quando si scrive int a; poi in java generico sarà compilato codice come numero intero a = new intero. Quindi, come per i generici intero non viene utilizzato, ma int viene utilizzato. quindi c'è così tale differenza lì.

Risposto il 22/09/2016 a 09:53
fonte dall'utente

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