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

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

    > In C # ist der Typ 'int' derselbe wie System.Int32 und ist ein Wertetyp (dh eher java 'int'). Eine Ganzzahl (wie bei allen anderen Werttypen) kann boxed sein (" in ein Objekt eingeschlossen.


    Die Unterschiede zwischen Objekten und Grundelementen liegen etwas außerhalb des Rahmens dieser Frage, aber zusammenfassend:

    Objekte bieten Möglichkeiten für Polymorphismus, werden als Referenz übergeben (oder genauer gesagt, Referenzwerte werden als Wert übergeben) und werden vom Heap . Umgekehrt sind Primitive unveränderliche Typen, die als Wert übergeben werden und häufig vom Stapel .

    24 September 2013
    Isak Savo
  • In Java ist ein int ein Primitiv, während eine Integer ein Objekt ist. Das heißt, wenn Sie eine neue Ganzzahl erstellt haben:

     Integer i = new Integer(6);
     

    Sie könnten eine Methode unter i:

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

    Dabei mit einem int:

     int i = 6;
     

    Sie können keine Methoden dafür aufrufen, da es sich einfach um ein Grundelement handelt. Also:

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

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

    int ist eine der wenigen Grundformen in Java (zusammen mit char und einigen anderen). Ich bin nicht zu 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). Integer ist also eine fantastische Art, mit einem int zu arbeiten (so wie String vielleicht eine phantastische Art ist, mit einer Gruppe von Zeichen zu arbeiten).

    Ich weiß, dass Java kein C ist Aber da ich noch nie in C programmiert habe, ist dies die nächste Antwort. Hoffe, das hilft!

    Integer-Objekt javadoc

    Integer Vergleich zwischen primitivem Vergleich und primitivem Vergleich

    26 November 2013
    Afshin MoazamiKarthik Kumar Viswanathan
  • Ich füge die oben angegebenen hervorragenden Antworten hinzu und spreche über Boxen und Unboxing und wie dies auf Java zutrifft (obwohl C # dies auch hat). Ich verwende nur Java-Terminologie, da ich mehr au fait bin.

    Wie bereits erwähnt, ist int nur eine Zahl ( wird als unboxed bezeichnet), während Integer ein Objekt ist (das die Nummer enthält, daher ein boxed -Typ). In Java bedeutet das (außer, dass Sie keine Methoden unter int aufrufen können), Sie können int oder andere Nicht-Objekttypen nicht in Sammlungen speichern (List, Map usw.). Um sie speichern zu können, müssen Sie sie zuerst in den entsprechenden Boxed-Box einrahmen.

    Java 5 hat etwas, das als Auto-Boxing und Auto-Unboxing ermöglicht das Boxen / Unboxing im Hintergrund. 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 (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 in der Java 5-Version identischen Bytecode erzeugen. Obwohl Auto-Boxing und Auto-Unboxing sehr bequem sind, weil Sie weniger Code schreiben, werden diese Vorgänge im Hintergrund mit den gleichen Laufzeitkosten ausgeführt, sodass Sie deren Existenz immer noch beachten müssen

    Ich hoffe, das hilft!

    03 August 2008
    Chris Jester-Young
  • 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

    Grundsätzlich ist int ein reserviertes Schlüsselwort in der Programmiersprache C # und ein Alias ​​für den Werttyp System.Int32.

    float und float sind nicht gleich Der richtige Systemtyp für '' float '' ist jedoch System.Single. Es gibt einige Typen wie diese mit reservierten Schlüsselwörtern, die scheinbar nicht direkt mit den Typnamen übereinstimmen.

    In C # gibt es keinen Unterschied zwischen '' int '' und '' System.Int32 '' oder eines der anderen Paare oder Schlüsselwörter / Systemtypen, außer bei der Definition von Enummen. 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 ist auf dem Stack, im Arbeitsspeicher oder als referenziertes Heap-Objekt gespeichert werden, hängt vom Kontext und von der Verwendung ab.

    Diese Deklaration in einer Methode:

     int i;
     

    definiert eine Variable i vom Typ System.Int32, die je nach Optimierung in einem Register oder auf dem Stack lebt. Dieselbe Deklaration in einem Typ (Struktur oder Klasse) definiert ein Mitgliedsfeld. Dieselbe 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 einbeziehen. Dies sind verschiedene Biester.)

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

     object o = i;
     

    Dadurch wird eine Kopie des Inhalts von i auf dem Heap erstellt. In IL können Sie direkt auf Methoden für das Heap-Objekt zugreifen, aber in C # müssen Sie es wieder in ein int umwandeln, wodurch eine weitere Kopie erstellt wird. Das Objekt auf dem Heap kann daher nicht ohne weiteres in C # geändert werden

    30 November 2015
    H. PauwelynAmokrane Chentir
  • In Java gibt es zwei grundlegende Typen in JVM . 1) Grundtypen und 2) Referenztypen. int ist ein Primitivtyp und Integer ist ein Klassentyp (der eine Art Referenztyp ist).

    Primitivwerte teilen sich den Status nicht mit anderen Primitivwerten. 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 ein dynamisch erstellte Klasseninstanz oder ein Array. Die Referenzwerte (oft nur Verweise) sind Zeiger auf diese Objekte und eine spezielle Nullreferenz, die auf kein Objekt verweist. Es kann viele Verweise auf dasselbe Objekt geben.

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

    Auch in Java wird alles per Wert übergeben. Bei Objekten ist der übergebene Wert die Referenz auf das Objekt. Ein weiterer Unterschied zwischen int und Integer in Java ist die Art und Weise, 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 two wird als primitive Ganzzahl vom Typ 2 übergeben Während 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);
     

    Die Variable two wird als Referenz auf ein Objekt übergeben das enthält den ganzzahligen Wert 2.


    @WolfmanDragon: Durch Referenz übergeben würde folgendermaßen funktionieren:

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

    Wenn increment aufgerufen wird, übergibt es einen Verweis (Zeiger) auf die Variable a . Und die Funktion increment ändert direkt die Variable a .

    Und für Objekttypen würde dies 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
     

    Sehen Sie den Unterschied jetzt?

    05 February 2009
    grom
  • In C # ist int nur ein Alias ​​ für System.Int32, Zeichenfolge für System.String, doppelt für System.Double etc ...

    Persönlich bevorzuge ich int, string, double usw., weil sie keine using System; -Anweisung benötigen :) Ein dummer Grund, ich weiß ...

    05 June 2014
    Ahmad
  • Auf Plattformen wie Java sind int Grundelemente, während Integer ein Objekt ist, das ein ganzzahliges Feld enthält. Der wichtige Unterschied ist, dass Primitive immer nach Wert weitergegeben werden und per Definition unveränderlich sind.

    Jede Operation, die eine primitive Variable beinhaltet, gibt immer einen neuen Wert zurück. Objekte werden dagegen als Referenz übergeben. Man könnte argumentieren, dass der Punkt auf das Objekt (AKA die Referenz) ebenfalls von value weitergegeben wird, der Inhalt jedoch nicht.

    10 June 2013
    Peter Mortensen
  • Es gibt viele Gründe, Wrapper-Klassen zu verwenden:

    1. Wir erhalten zusätzliches Verhalten (zum Beispiel können wir Methoden verwenden)
    2. Wir können Nullwerte speichern, wohingegen in Primitiven keine
    3. Sammlungen das Speichern von Objekten und keine Primitive unterstützen.
    31 July 2014
    Matthew Haugenuser1516381
  • 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. Im Gegensatz zu 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 beispielhafter Code:

     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;
    }
     
    05 August 2008
    Wedge
  • Java:

    int, double, long, byte, float, double, short, boolean, char - Primitive. Wird für die von der Sprache unterstützten Basisdatentypen verwendet. Die primitiven Typen sind nicht Teil der Objekthierarchie und erben kein Object. Das kann durch Verweis auf eine Methode übergeben werden.

    Double, Float, Long, Integer, Short, Byte, Character und Boolean, sind Typ Wrappers, verpackt in java.lang. Alle Wrapper für numerische Typen definieren Konstruktoren, mit denen ein Objekt aus einem bestimmten Wert oder einer Zeichenfolgendarstellung dieses Werts erstellt werden kann. Die Verwendung von Objekten kann selbst bei den einfachsten Berechnungen einen Overhead hinzufügen.

    Seit JDK 5 hat Java zwei sehr hilfreiche Funktionen hinzugefügt: Autoboxing und Autounboxing. Autoboxing / Unboxing vereinfacht und vereinfacht 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.

    21 April 2018
    J-AlexTirtha Chetry