visual - Was ist der Unterschied zwischen einem int und einem Integer in Java und C#?




volatile c++ (16)

Ich las mehr Joel on Software, als ich auf Joel Spolsky stieß , der etwas über einen bestimmten Typ von Programmierer sagte, der den Unterschied zwischen einem int und einem Integer in Java / C # (objektorientierte Programmiersprachen) kannte .

Also, was ist der Unterschied?


"int" ist primitiver Datentyp und "Integer" in der Wrapper-Klasse in Java. "Integer" kann als Argument für eine Methode verwendet werden, die ein Objekt benötigt, wobei "int" als Argument für eine Methode verwendet werden kann, die einen ganzzahligen Wert benötigt, der für den arithmetischen Ausdruck verwendet werden kann.


(Java Version) In einfachen Worten ist int primitiv und Integer ist Wrapper-Objekt für int.

Ein Beispiel, in dem Integer vs int verwendet wird, wenn Sie die Variable und int wieder mit null vergleichen möchten, wird ein Fehler ausgegeben.

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

Dies wurde bereits für Java beantwortet, hier ist die C # -Antwort:

"Integer" ist kein gültiger Typname in C # und "int" ist nur ein Alias ​​für System.Int32. Anders als in Java (oder C ++) gibt es in C # keine speziellen primitiven Typen, jede Instanz eines Typs in C # (einschließlich int) ist ein Objekt. Hier ist ein Demonstrationscode:

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

Ein int und Integer in Java und C # sind zwei verschiedene Begriffe, die verschiedene Dinge repräsentieren. Es ist einer der primitiven Datentypen, die einer Variablen zugewiesen werden können, die genau gespeichert werden kann. Ein Wert des jeweils angegebenen Typs.

Beispielsweise:

int number = 7;

Wobei int der Datentyp ist, der der Variablennummer zugeordnet ist, die den Wert sieben enthält. Ein int ist also nur ein Primitives, kein Objekt.

Ein Integer ist eine Wrapper-Klasse für einen primitiven Datentyp mit statischen Methoden. Dies kann als Argument für eine Methode verwendet werden, die ein Objekt benötigt, wobei int als Argument für eine Methode verwendet werden kann, die einen ganzzahligen Wert benötigt, der für arithmetische Ausdrücke verwendet werden kann.

Beispielsweise:

Integer number = new Integer(5);

Eine weitere Sache, die ich in früheren Antworten nicht sehe: In Java sind die primitiven Wrapperklassen wie Integer, Double, Float, Boolean ... und String invariant, so dass, wenn Sie eine Instanz dieser Klassen übergeben, die aufgerufen wird Die Methode konnte Ihre Daten in keiner Weise verändern, in Übereinstimmung mit den meisten anderen Klassen, deren interne Daten durch ihre öffentlichen Methoden geändert werden könnten. Damit diese Klasse nur "Getter" -Methoden hat, gibt es außer dem Konstruktor keine 'Setter'.

In einem Java-Programm werden String-Literale in einem separaten Teil des Heap-Speichers gespeichert, nur eine Instanz für das Literal, um Speicher zu sparen, der diese Instanzen wiederverwendet


Es gibt viele Gründe, Wrapper-Klassen zu verwenden:

  1. Wir bekommen zusätzliches Verhalten (zum Beispiel können wir Methoden verwenden)
  2. Wir können Nullwerte speichern, während dies bei Primitiven nicht möglich ist
  3. Sammlungen unterstützen das Speichern von Objekten und nicht von Primitiven.

Ich füge die ausgezeichneten Antworten hinzu, die oben gegeben wurden, und spreche über Boxen und Unboxing, und wie dies für Java gilt (obwohl C # es auch hat). Ich werde nur Java-Terminologie verwenden, weil ich damit mehr vertraut bin.

Wie die Antworten erwähnt haben, ist int nur eine Zahl ( Unboxed- Typ), während Integer ein Objekt ist (das die Zahl enthält, also einen Boxed- Typ). In Java bedeutet das, dass (abgesehen davon, dass Methoden nicht auf int aufgerufen werden können), int oder andere Nicht-Objekttypen in Auflistungen ( List , Map usw.) nicht gespeichert werden können. Um sie zu speichern, müssen Sie sie zuerst in ihrem entsprechenden eingerahmten Typ einpacken.

Ab Java 5 gibt es ein sogenanntes Auto-Boxing und Auto-Unboxing, mit dem das Boxing / Unboxing hinter den Kulissen durchgeführt werden kann. Vergleichen und kontrastieren: Java 5 Version:

Deque<Integer> queue;

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

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

Java 1.4 oder früher (auch keine Generika):

Deque queue;

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

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

Es ist zu beachten, dass beide Versionen trotz der Kürze der Java 5-Version einen identischen Bytecode generieren. Obwohl Auto-Boxing und Auto-Unboxing sehr praktisch sind, weil Sie weniger Code schreiben, werden diese Vorgänge im Hintergrund ausgeführt, mit den gleichen Laufzeitkosten. Sie müssen sich also ihrer Existenz bewusst sein.

Hoffe das hilft!


Ich werde hier nur posten, da einige der anderen Beiträge in Bezug auf C # etwas ungenau sind.

Richtig: int ist ein Alias ​​für System.Int32 .
Falsch: float ist kein Alias ​​für System.Float , sondern für System.Single

Im Wesentlichen ist int ein reserviertes Schlüsselwort in der Programmiersprache C # und ein Alias ​​für den System.Int32 .

Float und Float sind jedoch nicht identisch, da System.Single der richtige Systemtyp für float ist. Es gibt einige Typen wie diese, die Schlüsselwörter reserviert haben, die nicht direkt mit den Typnamen übereinstimmen.

In C # gibt es keinen Unterschied zwischen '' int '' und '' System.Int32 '' oder einem der anderen Paare oder Schlüsselwörter / Systemtypen, außer beim Definieren von Enums. Mit enums können Sie die zu verwendende Speichergröße angeben. In diesem Fall können Sie nur das reservierte Schlüsselwort und nicht den Namen des Systemlaufzeittyps verwenden.

Ob der Wert im int auf dem Stack, im Speicher oder als referenziertes Heap-Objekt gespeichert wird, hängt vom Kontext und von der Art der Verwendung ab.

Diese Deklaration in einer Methode:

int i;

definiert eine Variable i vom Typ System.Int32 , die abhängig von Optimierungen in einem Register oder auf dem Stack lebt. Die gleiche Deklaration in einem Typ (struct oder class) definiert ein Member-Feld. Die gleiche Deklaration in einer Methodenargumentliste definiert einen Parameter mit denselben Speicheroptionen wie für eine lokale Variable. (Beachten Sie, dass dieser Absatz nicht gültig ist, wenn Sie Iterator-Methoden in den Mix ziehen, dies sind verschiedene Biester insgesamt)

Um ein Heap-Objekt zu erhalten, können Sie Boxen verwenden:

object o = i;

Dadurch wird eine umrahmte Kopie des Inhalts von i auf dem Heap erstellt. In IL können Sie direkt auf Methoden auf dem Heap-Objekt zugreifen, aber in C # müssen Sie es auf einen int zurückwerfen, der eine weitere Kopie erstellt. Daher kann das Objekt auf dem Heap nicht einfach in C # geändert werden, ohne eine neue Kopie eines neuen int-Werts zu erstellen. (Ugh, dieser Absatz liest sich nicht so leicht.)


In Java gibt es zwei Grundtypen in der JVM . 1) Primitive Typen und 2) Referenztypen. int ist ein primitiver Typ und Integer ist ein Klassentyp (der eine Art Referenztyp ist).

Primitive Werte teilen den Zustand nicht mit anderen primitiven Werten. Eine Variable, deren Typ ein primitiver Typ ist, enthält immer einen primitiven Wert dieses Typs.

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

Ein Objekt ist eine dynamisch erstellte Klasseninstanz oder ein Array. Die Referenzwerte (häufig nur Referenzen) sind Zeiger auf diese Objekte und eine spezielle Nullreferenz, die auf kein Objekt verweist. Es kann viele Referenzen auf das gleiche Objekt geben.

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

Auch in Java wird alles nach Wert weitergegeben. Bei Objekten ist der übergebene Wert die Referenz auf das Objekt. Also ein weiterer Unterschied zwischen int und Integer in Java ist, wie sie in Methodenaufrufen übergeben werden. Zum Beispiel in

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

Die Variable Zwei wird als primitiver ganzzahliger Typ 2 übergeben

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

Die Variable Zwei wird als Referenz an ein Objekt übergeben, das den Ganzzahlwert 2 enthält.

@WolfmanDragon: Pass by reference würde so funktionieren:

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

Wenn increment aufgerufen wird, übergibt es eine Referenz (Zeiger) an die Variable a . Und die Inkrementierungsfunktion modifiziert direkt die Variable a .

Und für Objekttypen würde es wie folgt funktionieren:

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

Siehst du den Unterschied jetzt?


In Java ist der Typ int ein primitiver Datentyp, wobei der Integer ein Objekt ist.

In C # ist der Datentyp int ebenfalls ein Datentyp wie System.Int32 . Eine integer (genau wie alle anderen Werttypen) kann in ein Objekt eingerahmt ("umgebrochen") werden.


In Java nach meinem Wissen, wenn Sie dann lernen, wenn Sie Int ein schreiben; dann wird in Java generic Code wie integer a = new integer kompiliert. Also, wie Generics Integer wird nicht verwendet, aber Int wird verwendet. also gibt es dort so einen Unterschied.


In Plattformen wie Java sind int s Primitive, während Integer ein Objekt ist, das ein ganzzahliges Feld enthält. Der wichtige Unterschied ist, dass Primitive immer wertmäßig weitergegeben werden und per Definition unveränderlich sind.

Jede Operation, die eine primitive Variable betrifft, gibt immer einen neuen Wert zurück. Auf der anderen Seite werden Objekte als Referenz weitergegeben. Man könnte argumentieren, dass der Punkt auf das Objekt (die Referenz) auch wertmäßig weitergegeben wird, der Inhalt aber nicht.


Nun, in Java ist ein Int ein Primitiv, während ein Integer ein Objekt ist. Bedeutung, wenn Sie eine neue Ganzzahl erstellt haben:

Integer i = new Integer(6);

Sie könnten eine Methode auf i aufrufen:

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

Während mit einem int:

int i = 6;

Sie können keine Methoden darauf aufrufen, weil es einfach ein Primitiv ist. Damit:

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

würde einen Fehler erzeugen, da int kein Objekt ist.

int ist eines der wenigen Primitive in Java (zusammen mit char und einigen anderen). Ich bin nicht 100% sicher, aber ich denke, dass das Integer-Objekt mehr oder weniger nur eine int-Eigenschaft und eine ganze Reihe von Methoden hat, um mit dieser Eigenschaft zu interagieren (wie zum Beispiel die toString () -Methode). So ist Integer eine schicke Art, mit einem int zu arbeiten (Genauso wie vielleicht String eine raffinierte Art ist, mit einer Gruppe von Zeichen zu arbeiten).

Ich weiß, dass Java nicht C ist, aber da ich nie in C programmiert habe, ist dies der nächste, dem ich zu der Antwort kommen könnte. Hoffe das hilft!

Ganzzahliges Objekt javadoc

Integer Ojcect vs. Int primitive Vergleich


int ist in der Bibliotheksfunktion c # vordefiniert, aber in Java können wir oject von Integer erstellen


In Java ist der Typ 'int' ein Primitiv, während der Typ 'Integer' ein Objekt ist.

In C # ist der Typ 'int' der gleiche wie System.Int32 und ist ein System.Int32 (dh mehr wie das Java 'int'). Eine Ganzzahl (genau wie alle anderen Werttypen) kann in ein Objekt boxed ("umgebrochen") werden.

Die Unterschiede zwischen Objekten und Primitiven sind etwas über den Rahmen dieser Frage hinaus, aber zusammenzufassen:

Objekte bieten Möglichkeiten für Polymorphie, werden als Referenz übergeben (oder genauer gesagt, Referenzen werden als Wert übergeben) und werden vom heap zugewiesen. Umgekehrt sind Grundelemente unveränderliche Typen, die als Wert übergeben werden und oft vom stack zugewiesen werden.


Java:

int , double , long , byte , float , double , short , boolean , char - primitives. Verwendet für die Grunddatentypen, die von der Sprache unterstützt werden. Die primitiven Typen sind nicht Teil der Objekthierarchie und sie erben nicht Objekt. Thet kann mit Bezug auf eine Methode übergeben werden.

Double , Float , Long , Integer , Short , Byte , Character und Boolean sind Wrappertypen, verpackt in java.lang . Alle Wrapper des numerischen Typs definieren Konstruktoren, die es ermöglichen, ein Objekt aus einem gegebenen Wert oder einer Zeichenfolgendarstellung dieses Werts zu konstruieren. Die Verwendung von Objekten kann selbst einfachsten Berechnungen einen zusätzlichen Aufwand hinzufügen.

Ab JDK 5 enthält Java zwei sehr hilfreiche Funktionen: Autoboxing und Auto-Boxing. Autoboxing / Unboxing vereinfacht und vereinfacht den Code, der primitive Typen in Objekte konvertieren muss, und umgekehrt.

Beispiel für Konstruktoren:

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

Beispiel für Boxen / 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
    }
}

Beispiel für 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
    }
}

PS Herbert Schildts Buch wurde als Referenz genommen.





int