Qual è la differenza tra un int e un numero intero in Java e C#?
https://stackoverflow.com/questions/564
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
stavo leggendo Altro Joel sul software quando mi sono imbattuto Joel Spolsky dire qualcosa su un particolare tipo di programmatore che conosce la differenza tra an int e un Integer in Java/C# (linguaggi di programmazione orientati agli oggetti).
Allora, qual è la differenza?
Soluzione
A Giava, il tipo 'int' è una primitiva, mentre il tipo 'Integer' è un oggetto.
In C#, il tipo 'int' è lo stesso di System.Int32 ed è un tipo di valore (cioè più simile a Java 'int').Un numero intero (proprio come qualsiasi altro tipo di valore) può esserlo Incorniciato ("avvolto") in un oggetto.
Le differenze tra oggetti e primitive vanno in qualche modo oltre lo scopo di questa domanda, ma per riassumere:
Oggetti forniscono funzionalità per il polimorfismo, vengono passati per riferimento (o più precisamente i riferimenti vengono passati per valore) e vengono allocati da mucchio.Al contrario, primitivi sono tipi immutabili che vengono passati per valore e spesso vengono allocati da pila.
Altri suggerimenti
Bene, in Java un int è una primitiva mentre un intero è un oggetto.Significato, se hai creato un nuovo numero intero:
Integer i = new Integer(6);
Potresti chiamare qualche metodo su i:
String s = i.toString();//sets s the string representation of i
Mentre con un int:
int i = 6;
Non puoi chiamare alcun metodo su di esso, perché è semplicemente una primitiva.COSÌ:
String s = i.toString();//will not work!!!
produrrebbe un errore, perché int non è un oggetto.
int è uno dei pochi primitivi in Java (insieme a char e alcuni altri).Non ne sono sicuro al 100%, ma penso che l'oggetto Integer abbia più o meno solo una proprietà int e tutta una serie di metodi per interagire con quella proprietà (come ad esempio il metodo toString()).Quindi Integer è un modo elegante di lavorare con un int (proprio come forse String è un modo elegante di lavorare con un gruppo di caratteri).
So che Java non è C, ma poiché non ho mai programmato in C questa è la risposta più vicina a cui potrei arrivare.Spero che questo ti aiuti!
Aggiungerò alle eccellenti risposte fornite sopra e parlerò di boxing e unboxing e di come questo si applica a Java (sebbene ce l'abbia anche C#).Utilizzerò solo la terminologia Java, perché sono di più al fatto con quello.
Come menzionato nelle risposte, int è solo un numero (chiamato the senza scatola tipo), mentre Integer è un oggetto (che contiene il numero, quindi a Incorniciato tipo).In termini Java, ciò significa (a parte non essere in grado di chiamare metodi on int), non è possibile memorizzarlo int o altri tipi non di oggetti nelle raccolte (List, Map, eccetera.).Per conservarli, è necessario prima imballarli nel tipo di scatola corrispondente.
Java 5 in poi ha qualcosa chiamato boxe automatico E unboxing automatico che consentono di eseguire il boxing/unboxing dietro le quinte.Confrontare e contrapporre:Versione Java 5:
Deque<Integer> queue;
void add(int n) {
queue.add(n);
}
int remove() {
return queue.remove();
}
Java 1.4 o precedente (nessun generico neanche):
Deque queue;
void add(int n) {
queue.add(Integer.valueOf(n));
}
int remove() {
return ((Integer) queue.remove()).intValue();
}
Va notato che nonostante la brevità della versione Java 5, entrambe le versioni generano bytecode identico.Pertanto, sebbene l'auto-boxing e l'auto-unboxing siano molto convenienti perché si scrive meno codice, queste operazioni Fare accadono dietro le quinte, con gli stessi costi di esecuzione, quindi devi ancora essere consapevole della loro esistenza.
Spero che questo ti aiuti!
Pubblicherò semplicemente qui poiché alcuni degli altri post sono leggermente imprecisi in relazione a C#.
Corretto: int è un alias per System.Int32.
Sbagliato: float non è un alias per System.Float, ma per System.Single
Fondamentalmente, int è una parola chiave riservata nel linguaggio di programmazione C# ed è un alias per System.Int32 tipo di valore.
float e Float non sono tuttavia la stessa cosa del tipo di sistema giusto per ''float'' è System.Single.Esistono alcuni tipi come questo che hanno parole chiave riservate che non sembrano corrispondere direttamente ai nomi dei tipi.
In C# non c'è differenza tra ''int'' E ''System.Int32'' o qualsiasi altra coppia o parola chiave/tipo di sistema, ad eccezione della definizione delle enumerazioni.Con le enumerazioni è possibile specificare la dimensione di archiviazione da utilizzare e in questo caso è possibile utilizzare solo la parola chiave riservata e non il nome del tipo di runtime del sistema.
Il fatto che il valore nell'int venga archiviato nello stack, in memoria o come oggetto heap di riferimento dipende dal contesto e da come lo si utilizza.
Questa dichiarazione in un metodo:
int i;
definisce una variabile i di tipo System.Int32, che vivono in un registro o in pila, a seconda delle ottimizzazioni.La stessa dichiarazione in un tipo (struttura o classe) definisce un campo membro.La stessa dichiarazione nell'elenco di argomenti di un metodo definisce un parametro, con le stesse opzioni di archiviazione di una variabile locale.(nota che questo paragrafo non è valido se inizi a inserire i metodi iteratori nel mix, queste sono bestie completamente diverse)
Per ottenere un oggetto heap, puoi utilizzare il boxing:
object o = i;
questo creerà una copia in scatola del contenuto di i sul mucchio.In IL puoi accedere direttamente ai metodi sull'oggetto heap, ma in C# devi restituirlo a un int, che creerà un'altra copia.Pertanto, l'oggetto nell'heap non può essere modificato facilmente in C# senza creare una nuova copia in scatola di un nuovo valore int.(Uffa, questo paragrafo non si legge così facilmente.)
Per quanto riguarda Java 1.5 e autoboxing c'è un'importante "stranezza" che entra in gioco quando si confrontano oggetti Integer.
In Java, gli oggetti interi con i valori da -128 a 127 sono immutabili (vale a dire, per un particolare valore intero, diciamo 23, tutti gli oggetti interi istanziati tramite il programma con il valore 23 puntano al esatto stesso oggetto).
Esempio, questo restituisce true:
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2); // true
Mentre questo restituisce false:
Integer i1 = new Integer(128);
Integer i2 = new Integer(128);
System.out.println(i1 == i2); // false
Il == confronta per riferimento (le variabili puntano allo stesso oggetto).
Questo risultato può differire o meno a seconda della JVM in uso.La specifica autoboxing per Java 1.5 richiede che gli interi (da -128 a 127) rientrino sempre nello stesso oggetto wrapper.
Una soluzione?=) Si dovrebbe sempre usare il metodo Integer.equals() quando si confrontano oggetti Integer.
System.out.println(i1.equals(i2)); // true
Maggiori informazioni su java.net Esempio a bexhuff.com
In Java ci sono due tipi base nel file JVM.1) Tipi primitivi e 2) Tipi di riferimento.int è un tipo primitivo e Integer è un tipo di classe (che è una specie di tipo di riferimento).
I valori primitivi non condividono lo stato con altri valori primitivi.Una variabile il cui tipo è un tipo primitivo contiene sempre un valore primitivo di quel tipo.
int aNumber = 4;
int anotherNum = aNumber;
aNumber += 6;
System.out.println(anotherNum); // Prints 4
Un oggetto è un'istanza di classe creata dinamicamente o un array.I valori di riferimento (spesso solo riferimenti) sono puntatori a questi oggetti e uno speciale riferimento null, che non si riferisce a nessun oggetto.Potrebbero esserci molti riferimenti allo stesso oggetto.
Integer aNumber = Integer.valueOf(4);
Integer anotherNumber = aNumber; // anotherNumber references the
// same object as aNumber
Anche in Java tutto viene passato per valore.Con gli oggetti il valore che viene passato è il riferimento all'oggetto.Quindi un'altra differenza tra int e Integer in Java è il modo in cui vengono passati nelle chiamate ai metodi.Ad esempio dentro
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 intero primitivo di tipo 2.Mentre dentro
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 riferimento a un oggetto che contiene il valore intero 2.
@WolfmanDragon:Passa per riferimento funzionerebbe in questo modo:
public void increment(int x) {
x = x + 1;
}
int a = 1;
increment(a);
// a is now 2
Quando viene chiamato incremento, passa un riferimento (puntatore) alla variabile UN.E il incremento la funzione modifica direttamente la variabile UN.
E per i tipi di oggetto funzionerebbe come segue:
public void increment(Integer x) {
x = Integer.valueOf(x.intValue() + 1);
}
Integer a = Integer.valueOf(1);
increment(a);
// a is now 2
Vedi la differenza adesso?
In C#, int è solo un alias per System.Int32, stringa per System.String, raddoppia per System.Double eccetera...
Personalmente preferisco int, string, double, ecc.perché non richiedono a using System; dichiarazione :) Un motivo stupido, lo so...
Esistono molti motivi per utilizzare le classi wrapper:
- Otteniamo comportamenti extra (ad esempio possiamo usare metodi)
- Possiamo memorizzare valori nulli mentre nelle primitive non possiamo
- Le raccolte supportano la memorizzazione di oggetti e non di primitive.
A questo è già stata data una risposta per Java, ecco la risposta in C#:
"Integer" non è un nome di tipo valido in C# e "int" è solo un alias per System.Int32.Inoltre, a differenza di Java (o C++), in C# non esistono tipi primitivi speciali, ogni istanza di un tipo in C# (incluso int) è un oggetto.Ecco del 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;
}
int viene utilizzato per dichiarare la variabile primitiva
e.g. int i=10;
Integer viene utilizzato per creare una variabile di riferimento della classe Integer
Integer a = new Integer();
In piattaforme come Java, ints sono primitive while Integer è un oggetto che contiene un campo intero.La distinzione importante è che le primitive vengono sempre passate in base al valore e per definizione sono immutabili.
Qualsiasi operazione che coinvolge una variabile primitiva restituisce sempre un nuovo valore.D'altra parte, gli oggetti vengono passati per riferimento.Si potrebbe sostenere che anche il punto dell'oggetto (AKA il riferimento) viene passato in base al valore, ma il contenuto no.
Un'altra cosa che non vedo nelle risposte precedenti:In Java le classi wrapper primitive come Integer, Double, Float, Boolean...e String dovrebbero essere invarianti, in modo che quando passi un'istanza di quelle classi il metodo invocato non può alterare i tuoi dati in alcun modo, al contrario della maggior parte delle altre classi, i cui dati interni potrebbero essere alterati dai suoi metodi pubblici.In modo che questa classe abbia solo metodi "getter", nessun "setter", oltre al costruttore.
In un programma Java i valori letterali delle stringhe vengono archiviati in una porzione separata della memoria heap, solo un'istanza per i valori letterali, per risparmiare memoria riutilizzando tali istanze
hai mai programmato prima di allora (int) è uno dei tipi primitivi che puoi impostare per le tue variabili (proprio come char, float, ...).
ma Integer è una classe wrapper che puoi usare per eseguire alcune funzioni su una variabile int (ad esempio convertirla in stringa o viceversa,...), ma tieni presente che i metodi nelle classi wrapper sono statici, quindi puoi usarli in qualsiasi momento senza creare un'istanza della classe Integer.in sintesi:
int x;
Integer y;
xey sono entrambe variabili di tipo int ma y è racchiusa in una classe Integer e ha diversi metodi che usi, ma nel caso in cui devi chiamare alcune funzioni della classe wrapper Integer puoi farlo semplicemente.
Integer.toString(x);
ma tieni presente che sia x che y sono corretti ma se vuoi usarli solo come tipo primitivo, usa la forma semplice (usata per definire x).
Giava:
int, double, long, byte, float, double, short, boolean, char - primitivi.Utilizzato per tenere i tipi di dati di base supportati dalla lingua.I tipi primitivi non fanno parte della gerarchia degli oggetti e non ereditano oggetti.Non può essere passato facendo riferimento a un metodo.
Double, Float, Long, Integer, Short, Byte, Character, E Boolean, sono di tipo Wrapper, confezionati in java.lang.Tutti i wrapper di tipo numerico definiscono costruttori che consentono di costruire un oggetto da un dato valore o da una rappresentazione di stringa di quel valore.L'uso degli oggetti può aggiungere un sovraccarico anche al più semplice dei calcoli.
A partire da JDK 5, Java ha incluso due funzionalità molto utili:autoboxing e autounboxing.L'autoboxing/unboxing semplifica e ottimizza notevolmente il codice che deve convertire i 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 di 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
}
}
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
}
}
PSCome riferimento è stato preso il libro di Herbert Schildt.
int è un tipo di dati primitivo.Numero intero è una classe wrapper.Può memorizzare dati int come oggetti.
Una variabile int contiene un valore intero con segno a 32 bit.Un intero (con la I maiuscola) contiene un riferimento a un oggetto di tipo (classe) Integer o null.
Java esegue automaticamente il cast tra i due;da Integer a int ogni volta che l'oggetto Integer si presenta come argomento per un operatore int o viene assegnato a una variabile int oppure un valore int viene assegnato a una variabile Integer.Questo casting si chiama boxe/unboxing.
Se una variabile intera che fa riferimento a null è unboxed, esplicitamente o implicitamente, viene lanciata un'eccezione NullPointerException.
Un int e un intero in Java e C# sono due termini diversi usati per rappresentare cose diverse.È uno dei tipi di dati primitivi che possono essere assegnati a una variabile che può essere memorizzata esattamente.Un valore del tipo dichiarato alla volta.
Per esempio:
int number = 7;
Dove int è il tipo di dati assegnato alla variabile numero che contiene il valore sette.Quindi un int è solo una primitiva, non un oggetto.
Mentre un Integer è una classe wrapper per un tipo di dati primitivo che ha metodi statici.Questo può essere utilizzato come argomento per un metodo che richiede un oggetto, mentre as int può essere utilizzato come argomento per un metodo che richiede un valore intero, che può essere utilizzato per un'espressione aritmetica.
Per esempio:
Integer number = new Integer(5);
In entrambi i linguaggi (Java e C#) int è un intero con segno di 4 byte.
A differenza di Java, C# fornisce valori interi sia con segno che senza segno.Poiché Java e C# sono orientati agli oggetti, alcune operazioni in questi linguaggi non si associano direttamente alle istruzioni fornite dal runtime e quindi devono essere definite come parte di un oggetto di qualche tipo.
C# fornisce System.Int32 che è un tipo di valore che utilizza una parte di memoria che appartiene al tipo di riferimento nell'heap.
Java fornisce java.lang.Integer che è un tipo di riferimento su cui opera int.I metodi in Integer non può essere compilato direttamente per le istruzioni di runtime. Quindi inseriamo un valore int per convertirlo in un'istanza di Integer e utilizziamo i metodi che prevedono un'istanza di qualche tipo (come toString(), parseInt(), valueOf() eccetera).
In C# la variabile int si riferisce a System.Int32.Any Il valore di 4 byte in memoria può essere interpretato come un int primitivo, che può essere manipolato dall'istanza di System.Int32. Quindi int è un alias per System.Int32.When utilizzando metodi relativi ai numeri interi come int.Parse(), int.ToString() eccetera.Il numero intero viene compilato nell'FCL System.Int32 struct chiamando i rispettivi metodi come Int32.Parse(), Int32.ToString().
In Giava, il int type è un tipo di dati primitivo, dove come Integer tipo è un oggetto.
In C#, il int type è anche un tipo di dati uguale a System.Int32.UN integer (proprio come qualsiasi altro tipo di valore) può essere racchiuso ("racchiuso") in un oggetto.
In Java int è un tipo di dati primitivo mentre Integer è una classe Helper, viene utilizzata per convertire un tipo di dati in un altro.
Per esempio:
double doubleValue = 156.5d;
Double doubleObject = new Double(doubleValue);
Byte myByteValue = doubleObject.byteValue ();
String myStringValue = doubleObject.toString();
I tipi di dati primitivi memorizzano la memoria disponibile più veloce in cui la classe Helper è complessa e vengono archiviati nella memoria heep.
riferimento da "David Gassner" Java Essential Training.
"int" è il tipo di dati primitivo e "Integer" nella classe Wrapper in Java."Intero" può essere utilizzato come argomento per un metodo che richiede un oggetto, mentre "int" può essere utilizzato come argomento per un metodo che richiede un valore intero, che può essere utilizzato per un'espressione aritmetica.
01.Il numero intero può essere nullo.Ma int non può essere nullo.
Integer value1 = null; //OK
int value2 = null //Error
02.È possibile passare solo valori di tipo classi wrapper a qualsiasi classe di raccolta.
(Classi wrapper: booleano, carattere, byte, corto, intero, lungo, mobile, doppio)
List<Integer> element = new ArrayList<>();
int valueInt = 10;
Integer valueInteger = new Integer(value);
element.add(valueInteger);
Ma normalmente aggiungiamo valori primitivi alla classe di raccolta?Il punto 02 è corretto?
List<Integer> element = new ArrayList<>();
element.add(5);
Sì, 02 è corretto, perché autoboxing.
L'autoboxing è la conversione automatica che il compilatore Java fa tra il tipo primitivo e la loro corrispondente classe wrapper.
Quindi 5 convertirli come valore intero mediante autoboxing.
int è predefinito nella funzione di libreria c# ma in Java possiamo creare l'oggetto di Integer
(Versione Java) in parole semplici int è primitivo e intero è un oggetto wrapper per int.
Un esempio in cui utilizzare Integer vs int, quando si desidera confrontare nuovamente la variabile int null, verrà generato un 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...}
In Java, secondo le mie conoscenze, se sei uno studente, allora, quando scrivi int a;quindi in Java generic compilerà il codice come Integer a = new Integer().Quindi, come per i generici Integer non è usato ma int si usa.quindi c'è così tanta differenza lì.
