DISABILITARE ADBLOCK

ADBlock sta bloccando alcuni contenuti del sito

ADBlock errore
risultati trovati: 

DOMANDA

Stavo leggendo Altro Joel on Software quando mi sono imbattuto Joel Spolsky dicendo qualcosa su un particolare tipo di programmatore conoscendo la differenza tra un int e un intero in Java / C # (linguaggi di programmazione orientati agli oggetti).

Quindi, qual è la differenza?

SOLUZIONE

In Java, il tipo 'int' è una primitiva, mentre il tipo 'Integer' è un oggetto.

In C #, il tipo 'int' è uguale a System.Int32 ed è un tipo di valore (ovvero più simile a java 'int'). Un numero intero (proprio come qualsiasi altro tipo di valore) può essere boxed (" ; avvolto ") in un oggetto.


Le differenze tra oggetti e primitivi vanno oltre lo scopo di questa domanda, ma per riassumere:

Gli oggetti forniscono strutture per il polimorfismo, sono passati per riferimento (o più accuratamente hanno riferimenti passati per valore) e sono allocati da heap . Al contrario, i primitivi sono tipi immutabili che vengono passati per valore e spesso allocati da pila .

Se ti va lasciaci una tua opinione

L'articolo ti è stato utile ed è tradotto correttamente?

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 un metodo su i:

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

Considerando che con un int:

int i = 6;

Non puoi chiamare alcun metodo su di esso, perché è semplicemente una primitiva. Quindi:

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 sono sicuro al 100%, ma sto pensando che l'oggetto Integer ha più o meno solo una proprietà int e un sacco 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 dal momento che non ho mai programmato in C questo è il più vicino possibile per arrivare alla risposta. Spero che questo aiuti!

Oggetto intero javadoc

Integer Ojbect vs. int confronto primitivo

Aggiungerò le risposte eccellenti fornite sopra e parlerò di boxe e unboxing e di come questo si applica a Java (anche se ce n'è anche C #). Userò solo la terminologia Java, perché sono più au fait con quello.

Come indicato nelle risposte, int è solo un numero (chiamato unboxed ), mentre Integer è un oggetto (che contiene il numero, quindi un tipo inscatolato ). In termini Java, ciò significa (oltre a non essere in grado di chiamare metodi su int ), non è possibile memorizzare int o altri tipi di non oggetti nelle raccolte (Elenco , Mappa , ecc.). Per poterli archiviare, devi prima imballarli nel tipo di scatola corrispondente.

Java 5 in poi ha qualcosa chiamato auto-boxing e auto-unboxing che consente di eseguire boxe / unboxing dietro le quinte. Confronto e contrasto: versione Java 5:

Deque<Integer> queue;

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

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

Java 1.4 o precedente (neanche generici):

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 un bytecode identico. Pertanto, sebbene l'auto-boxing e l'auto-unboxing siano molto utili perché si scrive meno codice, queste operazioni fanno avvengono dietro le quinte, con gli stessi costi di runtime, quindi è necessario essere consapevoli della loro esistenza .

Spero che questo aiuti!

Pubblicherò qui solo perché alcuni degli altri post sono leggermente imprecisi rispetto 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 il tipo di valore System.Int32 .

float e Float non sono uguali, poiché il giusto tipo di sistema 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 una qualsiasi delle altre coppie o parole chiave / tipi di sistema, eccetto quando si definiscono gli enum. Con enum puoi specificare le dimensioni di archiviazione da utilizzare e in questo caso puoi usare solo la parola chiave riservata e non il nome del tipo di runtime del sistema.

Se il valore in int verrà 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 vive in un registro o nello stack, a seconda delle ottimizzazioni. La stessa dichiarazione in un tipo (struct o class) definisce un campo membro. La stessa dichiarazione in un elenco di argomenti del metodo definisce un parametro, con le stesse opzioni di archiviazione di una variabile locale. (nota che questo paragrafo non è valido se inizi a inserire metodi iteratori nel mix, queste sono bestie del tutto diverse)

Per ottenere un oggetto heap, puoi usare la boxe:

object o = i;

questo creerà una copia in scatola del contenuto di i sull'heap. In IL è possibile accedere direttamente ai metodi sull'oggetto heap, ma in C # è necessario eseguirne il cast su un int, che creerà un'altra copia. Pertanto, l'oggetto sull'heap non può essere facilmente modificato in C # senza creare una nuova copia in scatola di un nuovo valore int. (Ugh, questo paragrafo non legge così facilmente.)

Per quanto riguarda Java 1.5 e autoboxing c'è un importante "quirk " che si gioca quando si confrontano oggetti Integer.

In Java, gli oggetti Integer con i valori da -128 a 127 sono immutabili (vale a dire, per un particolare valore intero, diciamo 23, tutti gli oggetti Integer istanziati attraverso il tuo programma con il valore 23 punti 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 in base alla JVM in uso. L'autoboxing delle specifiche per Java 1.5 richiede che gli interi (da -128 a 127) vengano sempre inseriti nello stesso oggetto wrapper.

Una soluzione? =) Bisogna sempre usare il metodo Integer.equals () quando si confrontano oggetti Integer.

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

Maggiori informazioni su java.net Esempio su bexhuff.com

In Java ci sono due tipi di base in JVM . 1) Tipi primitivi e 2) Tipi di riferimento. int è un tipo primitivo e Integer è un tipo di classe (che è un tipo 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 fa riferimento 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 è come vengono passati nelle chiamate al 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 passata come tipo intero primitivo 2. Considerando che in

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


@WolfmanDragon: Il passaggio 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 increment, passa un riferimento (puntatore) alla variabile a . E la funzione incremento modifica direttamente la variabile a .

E per i tipi di oggetti 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 , doppia per System.Double ecc ...

Personalmente preferisco int, string, double, ecc. perché non richiedono un'istruzione utilizzando System; :) Un motivo sciocco, lo so ...

Esistono molti motivi per utilizzare le classi wrapper:

  1. Abbiamo un comportamento extra (ad esempio possiamo usare metodi)
  2. Possiamo memorizzare valori null mentre nelle primitive non possiamo
  3. Le raccolte supportano la memorizzazione di oggetti e non di primitivi.

Questa è già una risposta per Java, ecco la risposta C #:

" integer " non è un nome di tipo valido in C # e " int " è solo un alias per System.Int32. Inoltre, diversamente da Java (o C ++) non ci sono tipi primitivi speciali in C #, ogni istanza di un tipo in C # (incluso int) è un oggetto. Ecco un 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;
}

int è usato 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, int s sono primitivi mentre Integer è un oggetto che contiene un campo intero. La distinzione importante è che i primitivi sono sempre passati per 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 sull'oggetto (AKA il riferimento) viene passato per valore, ma i contenuti non lo sono.

Un'altra cosa che non vedo nelle risposte precedenti: In Java le classi di wrapper primitive come Integer, Double, Float, Boolean ... e String sono considerate invarianti, cosicché quando si passa un'istanza di quelle classi il metodo invocato non può modificare i dati in alcun modo, in opositi & # 243; n con la maggior parte delle altre classi, i cui dati interni potrebbero essere modificati con i suoi metodi pubblici. In modo che questa classe abbia solo metodi "getter", non "setter", oltre al costruttore.

In un programma java I letterali stringa sono archiviati in una porzione separata della memoria heap, solo un'istanza letterale, 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 fare alcune funzioni su una variabile int (ad es. convertirla in stringa o viceversa, ...), ma tieni presente che i metodi nelle classi wrapper sono statici quindi possono usarli in qualsiasi momento senza creare un'istanza della classe Integer. come riassunto:

int x;
Integer y; 

xey sono entrambe variabili di tipo int ma y è racchiuso da una classe Integer e ha diversi metodi che usi, ma nel caso tu abbia bisogno di 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 il modulo semplice (usato per definire x).

Java:

int , double , long , byte , float , double , short , booleano , char - primitive. Utilizzato per contenere i tipi di dati di base supportato dalla lingua. i tipi primitivi non fanno parte di gerarchia di oggetti e non ereditano Object. Non si può passare facendo riferimento a un metodo.

Double , Float , Long , Integer , Short , Byte , Character e Boolean , sono wrapper di tipo, confezionati in java.lang . Tutti i wrapper di tipo numerico definiscono costruttori che consentono la costruzione di un oggetto da un determinato valore o 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 funzioni molto utili: autoboxing e autounboxing. L'autoboxing / unboxing semplifica e semplifica 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 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
    }
}

P.S. Il libro di Herbert Schildt è stato preso come riferimento.

int è un tipo di dati primitivo. Numero intero è una classe wrapper. Può memorizzare i 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) Intero o null.

Java esegue automaticamente il cast tra i due; da Integer a int ogni volta che l'oggetto Integer si presenta come argomento a 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 Integer che fa riferimento a null è unbox, esplicitamente o implicitamente, viene generata una 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ò archiviare esattamente. Un valore del tipo dichiarato alla volta.

Ad esempio:

int number = 7;

Dove int è il tipo di dati assegnato al numero variabile 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 usato come argomento per un metodo che richiede un oggetto, mentre come int può essere usato come argomento per un metodo che richiede un valore intero, che può essere usato per l'espressione aritmetica.

Ad esempio:

Integer number = new Integer(5);

In entrambe le lingue (Java e C #) int è un intero con segno a 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 tempo di esecuzione e pertanto devono essere definite come parte di un oggetto di qualche tipo.

C # fornisce System.Int32 che è un tipo di valore che utilizza una parte della memoria che appartiene al tipo di riferimento sull'heap.

java fornisce java.lang.Integer che è un tipo di riferimento che opera su int . I metodi in Integer non possono essere compilati direttamente per eseguire 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 un tipo (come toString () , parseInt () , valueOf () ecc.)

Nella variabile C # int si riferisce a System.Int32.Any il valore a 4 byte in memoria può essere interpretato come un int primitivo, che può essere manipolato dall'istanza di System.Int32. alias per System.Int32.When utilizzando metodi relativi a numeri interi come int.Parse () , int.ToString () ecc. L'intero viene compilato nella struttura FCL System.Int32 chiamando i rispettivi metodi come Int32.Parse () , Int32.ToString () .

In Java, il tipo int è un tipo di dati primitivo, in cui il tipo Integer è un oggetto.

In C #, il tipo int è anche un tipo di dati uguale a System.Int32 . Un intero (proprio come qualsiasi altro tipo di valore) può essere inscatolato ("racchiuso") in un oggetto.

In Java int è un tipo di dati primitivo mentre Integer è una classe Helper, viene utilizzato per convertire un tipo di dati in un altro.

Ad 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 " è di tipo di dati primitivo e "Intero" nella classe Wrapper in Java. & Quot; integer " può essere usato come argomento per un metodo che richiede un oggetto, dove come "int" può essere usato come argomento per un metodo che richiede un valore intero, che può essere usato per l'espressione aritmetica.

01. L'intero può essere nullo. Ma int non può essere nullo.

Integer value1 = null; //OK

int value2 = null      //Error

02. Solo i valori dei tipi di classi wrapper possono passare a qualsiasi classe di raccolta.

(Classi wrapper - Booleane, Personaggio, Byte, Corto, Intero, Lungo, Float, 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.

  

Autoboxing è la conversione automatica effettuata dal compilatore java   tra il tipo primitivo e la corrispondente classe wrapper.

Quindi 5 converti come valore intero mediante box automatico.

int è predefinito nella funzione di libreria c # ma in java possiamo creare l'oggetto di Integer

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

Un esempio in cui utilizzare Integer vs int, quando si desidera confrontare nuovamente la variabile int e 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 impari allora, quando scrivi int a; quindi in java generico compilerà il codice come Integer a = new Integer () . Quindi, come per generics Integer non viene utilizzato ma int viene utilizzato. quindi c'è così tanta differenza lì.

Licensed under: CC-BY-SA with attribution
Not affiliated with StackOverflow