Jaka jest różnica między int i Integer w Javie i C#?

Cóż, w Javie int jest prymitywem, podczas gdy liczba całkowita jest obiektem. Oznacza to, że jeśli tworzysz nową liczbę całkowitą:

Integer i = new Integer(6);

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

Natomiast z int:

int i = 6;

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

Spowoduje błąd, ponieważ int nie jest obiektem.

Int jest jednym z niewielu prymitywów w Javie (wraz z char i kilkoma innymi). Nie jestem w 100% pewien, ale myślę, że Obiekt Integer mniej więcej posiada właściwość int i całą masę metod do interakcji z tą właściwością (jak na przykład metoda toString ()). Tak więc Integer jest fantazyjnym sposobem pracy z int (tak jak być może String jest fantazyjnym sposobem pracy z grupą znaków).

Wiem, że Java nie jest C, ale ponieważ nigdy nie zaprogramowałem w C, jest to najbliższa odpowiedź, jaką mogłem znaleźć. Mam nadzieję, że to pomoże!

Integer object javadoc

Integer Ojbect vs. int prymitywne porównanie

Dodam do doskonałych odpowiedzi podanych powyżej i opowiem o boksie i unboxingu oraz o tym, jak to się odnosi do Javy (choć C# też tak ma). Użyję tylko terminologii Javy, ponieważ jestem bardziej au fait z tym.

Jak wspomniano, int jest tylko liczbą (zwaną typem unboxed), podczas gdy Integer jest obiektem (który zawiera liczbę, stąd typ boxed). W języku Java oznacza to (poza tym, że nie można wywoływać metod na int), nie można przechowywać int lub innych typów nieobiektowych w kolekcjach (List, Map, itd.). Aby je przechowywać, musisz najpierw umieścić je w odpowiednim pudełku.

Java 5 ma coś, co nazywa się auto-boxing i auto-unboxing , które umożliwiają Boks/unboxing za kulisami. Compare and contrast: Java 5 version:

Deque<Integer> queue;

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

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

Java 1.4 lub wcześniejsza (również bez generyków):

Deque queue;

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

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

Należy zauważyć, że pomimo zwięzłości w Wersja Java 5, obie wersje generują identyczny bajt. Tak więc, chociaż auto-boks i auto-unboxing jest bardzo wygodne, ponieważ piszesz mniej kodu, te operacje robią Za kulisami, z tymi samymi kosztami wykonania, więc nadal musisz być świadomy ich istnienia.

Mam nadzieję, że to pomoże!

Po prostu post tutaj, ponieważ niektóre z innych postów są nieco niedokładne w stosunku do C#.

Poprawne: int jest aliasem dla System.Int32.
źle: float nie jest aliasem dla System.Float, ale dla System.Single

Int jest zarezerwowanym słowem kluczowym w języku programowania C# i jest aliasem dla typu wartości System.Int32.

Float i Float nie są jednak takie same, ponieważ właściwym typem systemu dla "float " jest System.Singiel. Są takie typy jak ten, który ma zarezerwowane słowa kluczowe, które nie wydają się pasować bezpośrednio do nazw typu.

W C# nie ma różnicy między" int "i" System.Int32", lub którąkolwiek z pozostałych par lub słów kluczowych / typów systemowych, z wyjątkiem definicji enum. Za pomocą enums można określić rozmiar pamięci, który ma być używany i w tym przypadku można używać tylko słowa kluczowego zarezerwowanego, a nie nazwy typu runtime systemu.

Jeśli wartość int będzie przechowywana na stosie, w pamięci lub jako sterta odniesienia obiekt zależy od kontekstu i sposobu jego użycia.

Ta deklaracja w metodzie:

int i;

Definiuje zmienną i typu System.Int32, żyjącą w rejestrze lub na stosie, w zależności od optymalizacji. Ta sama deklaracja w typie (struct lub class) definiuje pole elementu. Ta sama deklaracja na liście argumentów metody definiuje parametr, z tymi samymi opcjami przechowywania, co dla zmiennej lokalnej. (zauważ, że ten akapit nie jest poprawny, jeśli zaczniesz ciągnąć metody iteratora do mieszanka, to zupełnie inne bestie)

Aby uzyskać obiekt sterty, możesz użyć boksu:

object o = i;

Spowoduje to utworzenie pudełkowej kopii zawartości i na stercie. W IL możesz uzyskać dostęp do metod bezpośrednio do obiektu heap, ale w C# musisz oddać je z powrotem do int, który utworzy kolejną kopię. Tak więc obiekt na stercie nie może być łatwo zmieniony w C# bez tworzenia nowej kopii pudełkowej nowej wartości int. (Ugh, ten akapit nie czyta wszystkiego, co łatwo.)

Jeśli chodzi o Javę 1.5 iautoboxing istnieje ważny "dziwak", który przychodzi do gry podczas porównywania obiektów Integer.

W Javie obiekty Integer o wartościach od -128 do 127 są niezmienne (tzn. dla jednej konkretnej wartości całkowitej, powiedzmy 23, wszystkie obiekty Integer utworzone przez twój program z wartością 23 wskazują na dokładny ten sam obiekt).

Przykład, zwraca true:

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

Podczas gdy zwraca false:

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

The = = reference (czy zmienne wskazują na ten sam obiekt).

Ten wynik może się różnić w zależności od tego, jakiego JVM używasz. Specyfikacja autoboxing dla Javy 1.5 wymaga, aby liczby całkowite (od -128 do 127) zawsze były ustawione w tym samym obiekcie wrappera.

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

Więcej informacji na java.net przykład na bexhuff.com

W Javie istnieją dwa podstawowe typy w JVM . 1) typy prymitywne i 2) typy referencyjne. int jest typem prymitywnym, a Integer jest typem klasy (który jest rodzajem typu odniesienia).

Wartości prymitywne nie współdzielą stanu z innymi wartościami prymitywnymi. Zmienna, której typ jest typem prymitywnym, zawsze posiada wartość prymitywną tego typu.

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

Obiekt jest dynamicznie tworzoną instancją klasy lub tablicą. Wartości odniesienia (często tylko odniesienia) są wskaźnikami do te obiekty i specjalne odniesienie null, które odnosi się do żadnego obiektu. Może być wiele odniesień do tego samego obiektu.

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

Również w Javie wszystko jest przekazywane przez wartość. W przypadku obiektów przekazywana wartość jest odniesieniem do obiektu. Więc inną różnicą między int i Integer w Javie jest sposób, w jaki są one przekazywane w wywołaniach metod. Na przykład w

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

Zmienna two jest przekazywana jako prymitywna liczba całkowita typu 2. W

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

Zmienna two {[18] } jest przekazywane jako odniesienie do obiektu, który posiada wartość całkowitą 2.

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

Po wywołaniu przyrostu przekazuje referencję (wskaźnik) do zmiennej a . A funkcja przyrost bezpośrednio modyfikuje zmienną a .

I dla typów obiektów działałoby to następująco:

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

W C# int jest tylko pseudonim for System.Int32, string for System.String, double for System.Double itd...

Osobiście wolę int, string, double itp. bo nie wymagają using System; Oświadczenia :) głupi powód, wiem...

Na platformach takich jak Java, int S są prymitywami, podczas gdy Integer jest obiektem posiadającym pole całkowite. Ważną różnicą jest to, że prymitywy są zawsze przekazywane przez wartość i z definicji są niezmienne.

Każda operacja z prymitywną zmienną zawsze zwraca nową wartość. Z drugiej strony, obiekty są przekazywane przez odniesienie. Można argumentować, że punkt do obiektu (AKA odniesienie) jest również przekazywany przez wartość, ale zawartość nie jest.

Jest wiele powodów, dla których warto używać klas wrapper:

1. otrzymujemy dodatkowe zachowanie (na przykład możemy użyć metod)
2. możemy przechowywać wartości null, podczas gdy w prymitywach nie możemy
3. Kolekcje wspierają przechowywanie obiektów, a nie prymitywów.

To już zostało odebrane dla Javy, oto odpowiedź C#:

"Integer" nie jest poprawną nazwą typu W C#, A " int " jest tylko aliasem dla System. Int32. ponadto, w przeciwieństwie do Javy (lub C++) nie ma żadnych specjalnych prymitywnych typów w C#, każda instancja typu W C# (w tym int) jest obiektem. Oto przykładowy kod:

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 służy do deklarowania zmiennej

e.g. int i=10;

Integer jest używany do tworzenia zmiennej referencyjnej klasy Integer

Integer a = new Integer();

Java:

int, double, long, byte, float, double, short, boolean, char - prymitywy. Używany do przechowywania podstawowych typów danych obsługiwane przez język. prymitywne typy nie są częścią hierarchii obiektów i nie dziedziczą One obiektu. To może być przekazywane przez odniesienie do metody.

Double, Float, Long, Integer, Short, Byte, Character, i Boolean, są opakowaniami typu, pakowanymi w java.lang. Wszystkie wrappery typu numerycznego definiują konstruktory, które pozwalają obiekt, który ma być zbudowany z podanej wartości lub reprezentację łańcuchową tej wartości. Korzystanie z obiektów może dodać narzut do nawet najprostszych obliczeń.

Przykład konstruktorów:

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

Przykład Boks/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
    }
}

Przykład autoboxingu/autounboxingu:

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

Jeszcze jedna rzecz, której nie widzę w poprzednich odpowiedziach: W Javie prymitywne klasy owijarek takie jak Integer, Double, Float, Boolean... i String są przypisane do niezmiennych, tak, że gdy przekazujesz instancję tych klas, wywołana metoda nie może zmienić Twoich danych w żaden sposób, w opositión z większością innych klas, które wewnętrzne dane mogą być zmieniane przez jej publiczne metody. Tak, że ta klasa ma tylko metody 'getter', nie ma 'setterów', poza konstruktorem.

W Javie literały ciągu programu są przechowywane w oddzielnej części pamięci sterty, tylko instancja dla literałów, aby zapisać pamięć ponownego użycia tych instancji

Czy kiedykolwiek wcześniej programowałeś (int) jest jednym z prymitywnych typów, które możesz ustawić dla swoich zmiennych (tak jak char, float,...).

Ale Integer jest klasą wrappera, której można użyć do wykonywania pewnych funkcji na zmiennej int (np... należy jednak pamiętać, że metody w klasach opakowujących są statyczne, więc można ich używać w każdej chwili bez tworzenia instancji klasy Integer. jako podsumowanie:

int x;
Integer y; 

X I y są zmiennymi typu int ale y jest owinięte przez klasę Integer i ma kilka metod, których używasz, ale i case musisz wywołać niektóre funkcje klasy Integer wrapper, możesz to zrobić po prostu.

Integer.toString(x);

Ale pamiętaj, że zarówno X, jak i y są rdzeniami, ale jeśli chcesz używać ich tylko jako prymitywnego typu, użyj prostej formy (używanej do definiowania x).

Zmienna int zawiera 32-bitową, podpisaną wartość całkowitą. Liczba całkowita (z wielką literą I) zawiera odniesienie do obiektu typu (class) Integer, lub do null.

Java automatycznie rzuca między nimi; od Integer do int, gdy obiekt Integer występuje jako argument operatora int lub jest przypisany do zmiennej Int, lub wartość int jest przypisana do zmiennej Integer. Ten casting nazywa się boks / unboxing.

Jeśli zmienna całkowita odwołująca się do null jest nieobsługiwana, jawnie lub w domyśle, rzucane jest odwołanie NullPointerException.

Int i Integer w Javie i C# to dwa różne terminy używane do reprezentowania różnych rzeczy. Jest to jeden z prymitywnych typów danych, które można przypisać do zmiennej, która może dokładnie przechowywać. Jedna wartość deklarowanego typu na raz.

Na przykład:

int number = 7;

Gdzie int jest typem danych przypisanym do zmiennej number, która posiada wartość siedem. Więc {[2] } jest tylko prymitywem, a nie obiektem.

Podczas gdy Integer jest klasą wrappera dla prymitywnych danych typ, który ma metody statyczne. Które mogą być użyte jako argument do metody wymagającej obiektu, gdzie jako int mogą być użyte jako argument do metody wymagającej wartości całkowitej, która może być użyta do wyrażenia arytmetycznego.

Na przykład:

Integer number = new Integer(5);

W obu językach (Java i C#) int jest 4-bajtową liczbą całkowitą.

W Przeciwieństwie Do Javy, C# dostarcza zarówno podpisane, jak i niepodpisane wartości całkowite. Ponieważ Java i C# są obiektowo zorientowane obiektowo, niektóre operacje w tych językach Nie mapują bezpośrednio na instrukcjach dostarczonych przez czas wykonania i dlatego muszą być zdefiniowane jako część obiektu pewnego typu.

C # dostarcza System.Int32, który jest typem wartości używającym części pamięci, która należy do typu odniesienia na stercie.

Java dostarcza java.lang.Integer, który jest typem odniesienia działającym na int. Metody w Integer nie mogą być skompilowane bezpośrednio do czasu uruchomienia instructions.So ustawiamy wartość int, aby przekonwertować ją na instancję Integer i używamy metod, które oczekują instancji jakiegoś typu (jak toString(), parseInt(), valueOf() itp.).

W C# zmienna int odnosi się do System.Int32.Any 4-bajtowej wartości w pamięci może być interpretowana jako prymitywna int, która może być manipulowana przez instancję System.Int32.So int jest aliasem dla System.Int32.When za pomocą metody związane z liczbami całkowitymi, takie jak int.Parse(), int.ToString() itd. Integer jest kompilowany do struktury FCL System.Int32 wywołującej odpowiednie metody, takie jak Int32.Parse(), Int32.ToString().

W Javie typ int jest prymitywnym typem danych, gdzie jako typ Integer jest obiektem.

W C# typ int jest również typem danych takim samym jak System.Int32. integer (podobnie jak inne typy wartości) może być opakowany ("zawinięty") do obiektu.

W Javie int jest prymitywnym typem danych, podczas gdy Integer jest klasą pomocniczą, służy do konwersji jednego typu danych na inny.

Na przykład:

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

Prymitywne typy danych przechowują najszybszą dostępną pamięć, gdzie Klasa pomocnicza jest złożona i przechowują ją w pamięci heep.

Odniesienie z" David Gassner " Java Essential Training.

" int "jest prymitywnym typem danych i" Integer " w klasie Wrapper w Javie. "Integer" może być użyty jako argument do metody wymagającej obiektu, gdzie jako " int " może być użyty jako argument do metody wymagającej wartości całkowitej, która może być użyta do wyrażenia arytmetycznego.

int jest predefiniowana w funkcji bibliotecznej c#, ale w Javie możemy utworzyć obiekt Integer

(Wersja Java) W prostych słowach int jest prymitywny, a Integer jest obiektem wrappera dla int.

Jeden przykład, gdzie użyć Integer vs int, gdy chcesz porównać i int zmienna ponownie null rzuci błąd.

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

01. Liczba całkowita może być null. Ale int nie może być null.

Integer value1 = null; //OK

int value2 = null      //Error

02. Tylko można przekazać wartości typu klasy Wrapper do dowolnej klasy collection.

(Klasy Wrapper-Boolean, Character,Byte,Short,Integer,Long,Float, Double)

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

Ale normalnie dodajemy prymitywne wartości do klasy kolekcji? Czy punkt 02 jest prawidłowy?

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

Yes 02 is correct, beacouse autoboxing.

Autoboxing jest automatyczną konwersją wykonywaną przez kompilator Javy między prymitywny typ i odpowiadająca im Klasa owijania.

Then 5 convert as Integer value by autoboxing.

W Javie zgodnie z moją wiedzą, jeśli się uczysz wtedy, gdy piszesz int a; następnie w Javie generic skompiluje Kod jak Integer a = new Integer(). Tak więc, jak na generyki {[1] } nie jest używany, ale int jest używany. więc jest tam taka różnica.