Java ve C # int ve Integer arasındaki fark nedir?

Ben okuyordum Yazılım hakkında daha fazla Joel'i Ben karşıdan karşıya geldi Joel Spolsky bir arasındaki farkı bilmek programcı belirli bir türü hakkında bir şey söylüyor intve bir IntegerJava / C # (Nesne Tabanlı Programlama Dilleri).

Peki, fark nedir?

Java'da 'int' tipi bir ilkelken 'Integer' tipi bir nesnedir.

C # 'da,' int 'tipi bir değer tipiyle aynıdır System.Int32ve bir değer tipidir (yani daha çok java' int 'gibi). Bir tamsayı (diğer tüm değer türlerinde olduğu gibi ) bir nesneye kutulanabilir ("sarılabilir").

Nesneler ve ilkel öğeler arasındaki farklar bu sorunun kapsamı dışındadır, ancak özetlemek gerekirse:

Nesneler , polimorfizm için olanaklar sağlar, referansla geçirilir (veya değere göre referansları daha doğru bir şekilde aktarılır) ve öbekten ayrılır . Tersine, ilkeller , değere göre geçirilen ve genellikle yığından ayrılan değişmez tiplerdir .

Java'da bir int bir ilkelken, bir Tamsayı Nesnedir. Yeni bir Tamsayı oluşturduysanız:

Integer i = new Integer(6);

İ üzerinde bazı yöntem çağırabilirsiniz:

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

Oysa bir int ile:

int i = 6;

Üzerinde herhangi bir yöntem çağıramazsınız, çünkü bu sadece bir ilkeldir. Yani:

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

int bir nesne olmadığı için hata üretir.

int, Java'daki birkaç temel öğeden biridir (char ve diğerleriyle birlikte). % 100 emin değilim, ama Integer nesnesinin az ya da çok sadece bir int özelliği ve (örneğin toString () yöntemi gibi) bu özellik ile etkileşim yöntemleri bir sürü olduğunu düşünüyorum. Yani Integer bir int ile çalışmanın süslü bir yoludur (Tıpkı String gibi bir grup karakterle çalışmanın süslü bir yoludur).

Java'nın C olmadığını biliyorum, ama C'de hiç programlamadığımdan bu cevaba gelebileceğim en yakın şey. Bu yardımcı olur umarım!

Tam sayı nesnesi javadoc

Tamsayı Ojbect ve int ilkel karşılaştırması

Yukarıda verilen mükemmel cevaplara ekleyeceğim ve boks ve kutudan çıkarma ve bunun Java için nasıl geçerli olduğu hakkında konuşacağım (C # de olsa). Ben sadece Java terminolojisini kullanacağım çünkü bununla daha çok ilgileniyorum .

Yanıt belirtildiği gibi, int(denilen bir sayı, sadece bir kutulamasının ise tipi), Integer(numara, dolayısıyla içeren bir nesnedir kutu tipi). Java açısından, bu araçlar (ayrı yöntemlerini çağırmak mümkün olmayan itibaren int), saklamak edemez intya da olmayan diğer nesne türleri koleksiyonları (içinde List, Mapvs.). Bunları saklamak için önce onları karşılık gelen kutulu tipte kutuya koymalısınız.

Java 5 ve sonrasında otomatik boks ve otomatik boks denen bir şey vardır . Karşılaştırma ve kontrast: Java 5 sürümü:

Deque<Integer> queue;

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

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

Java 1.4 veya öncesi (jenerik yok):

Deque queue;

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

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

Java 5 sürümündeki kısalığa rağmen, her iki sürümün de aynı bayt kodu oluşturduğuna dikkat edilmelidir. Daha az kod yazmak çünkü otomatik boks ve otomatik unboxing çok uygun olmasına rağmen Böylece, bu işlemler yapmak yine kendi varlığından haberdar olmak zorunda, aynı çalışma zamanı maliyetlerle, perde arkasında olur.

Bu yardımcı olur umarım!

Diğer yazıların bazıları C # ile ilgili olarak biraz yanlış olduğundan buraya yazacağım.

Doğru: int için bir takma addır System.Int32.
Yanlış: float için bir takma ad System.Floatdeğil,System.Single

Temel olarak int, C # programlama dilinde ayrılmış bir anahtar kelimedir ve System.Int32değer türü için bir takma addır .

ancak float ve Float aynı değildir, çünkü '' float'' için doğru sistem türü System.Single'dir. Doğrudan tür adlarıyla eşleşmeyen anahtar kelimeler içeren bazı türler vardır.

C # 'da,' ' int' 've' ' System.Int32' 'veya diğer çiftler veya anahtar kelimeler / sistem türleri arasında, numaralandırmaların tanımlanması haricinde hiçbir fark yoktur . Numaralandırmalarda kullanılacak depolama boyutunu belirtebilirsiniz ve bu durumda sistem çalışma zamanı türü adını değil, yalnızca ayrılmış anahtar sözcüğü kullanabilirsiniz.

İnt içindeki değerin yığın üzerinde, bellekte veya başvurulan bir yığın nesnesi olarak depolanıp depolanmayacağı bağlama ve onu nasıl kullandığınıza bağlıdır.

Bir yöntemde bu bildirim:

int i;

optimizasyona bağlı olarak bir kayıtta veya yığın üzerinde yaşayan bir itür değişken tanımlar System.Int32. Bir türdeki (yapı veya sınıf) aynı bildirim üye alanını tanımlar. Yöntem bağımsız değişken listesindeki aynı bildirim, yerel bir değişkenle aynı depolama seçeneklerine sahip bir parametreyi tanımlar. (yineleyici yöntemlerini karışıma çekmeye başlarsanız bu paragrafın geçerli olmadığını unutmayın, bunlar tamamen farklı hayvanlardır)

Bir yığın nesnesi almak için boksu kullanabilirsiniz:

object o = i;

bu i, öbek üzerindeki içeriğin kutulu bir kopyasını oluşturur . IL'de yığın nesnesindeki yöntemlere doğrudan erişebilirsiniz, ancak C # 'da başka bir kopya oluşturacak şekilde int'e geri döndürmeniz gerekir. Bu nedenle, öbek üzerindeki nesne, yeni bir int değerinin yeni bir kutulu kopyası oluşturulmadan C # 'da kolayca değiştirilemez. (Ugh, bu paragraf her şeyi kolayca okumuyor.)

Java 1.5 ve otomatik boks ile ilgili olarak , Tamsayı nesneleri karşılaştırılırken önemli bir " tuhaflık " vardır.

Java'da, -128 ila 127 değerlerine sahip Integer nesneleri değiştirilemez (diğer bir deyişle, 23 gibi belirli bir tamsayı değeri için, programınız aracılığıyla 23 değeri ile başlatılan tüm Integer nesneleri tam olarak aynı nesneyi gösterir).

Örnek, bu doğru döndürür:

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

Bu yanlış döndürürken:

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

== referansla karşılaştırır (değişkenler aynı nesneyi gösteriyor mu).

Bu sonuç, kullandığınız JVM'ye bağlı olarak değişebilir veya değişmeyebilir. Java 1.5 için özellik otomatik kutusu, tamsayıların (-128 ila 127) her zaman aynı sarmalayıcı nesnesine kutu vermesini gerektirir.

Bir çözüm? =) Integer nesneleri karşılaştırılırken her zaman Integer.equals () yöntemi kullanılmalıdır.

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

More info at java.net at Örnek bexhuff.com

Java'da JVM'de iki temel tür vardır . 1) İlkel türler ve 2) Referans Türleri. int ilkel bir tiptir ve Integer bir sınıf tipidir (bu bir tür referans tipidir).

İlkel değerler durumu diğer ilkel değerlerle paylaşmaz. Türü ilkel tür olan bir değişken her zaman bu türün ilkel değerini tutar.

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

Nesne, dinamik olarak oluşturulmuş bir sınıf örneği veya dizisidir. Referans değerleri (genellikle sadece referanslar) bu nesnelere işaret eder ve hiçbir nesneyi ifade etmeyen özel bir boş referanstır. Aynı nesneye birçok referans olabilir.

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

Ayrıca Java'da her şey değerden geçer. Nesnelerde iletilen değer nesneye yapılan başvurudur. Java'da int ve Integer arasındaki bir diğer fark, yöntem çağrılarına nasıl geçildikleri. Örneğin,

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

Değişken iki Oysa ilkel tamsayı tip 2 olarak geçirilir

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

Değişken iki tamsayı değeri 2 tutan bir nesne için bir referans olarak geçirilir.

@WolfmanDragon: Referansla geçmek şöyle çalışır:

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

Arttırma çağrıldığında değişken bir referans (pointer) geçer a . Ve arttırma işlevi doğrudan değişken değiştirir a .

Ve nesne türleri için aşağıdaki gibi çalışır:

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

Şimdi farkı görüyor musunuz?

C # int sadece bir takma ad için System.Int32, dize System.Stringiçin çift, System.Doublevb ...

Şahsen int, string, double, vb. Tercih ederim. Çünkü using System;açıklama gerektirmezler .

Sarıcı sınıflarını kullanmanın birçok nedeni vardır:

1. Ekstra davranışlar elde ederiz (örneğin yöntemleri kullanabiliriz)
2. Null değerleri saklayabiliriz, ancak ilkellerde saklayamayız
3. Koleksiyonlar, ilkel öğeleri değil nesneleri depolamayı destekler.

Bu Java için zaten cevaplandı, işte C # cevabı:

"Tamsayı", C # için geçerli bir tür adı değil ve "int", System.Int32 için yalnızca bir diğer addır. Ayrıca, Java'nın (veya C ++) aksine, C # 'da herhangi bir özel ilkel tür yoktur, C #' da (int dahil) bir türün her örneği bir nesnedir. İşte bazı örnek 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 ilkel değişkeni bildirmek için kullanılır

e.g. int i=10;

Integer, Integer sınıfının referans değişkenini oluşturmak için kullanılır

Integer a = new Integer();

Java gibi platformlarda ints ilkel, Integertam sayı alanı olan bir nesnedir. Önemli ayrım, ilkellerin her zaman değere göre aktarılması ve tanım gereği değişmez olmasıdır.

İlkel değişken içeren herhangi bir işlem her zaman yeni bir değer döndürür. Öte yandan, nesneler başvuru ile iletilir. Nesneye olan noktanın (AKA referansı) da değere göre aktarıldığı iddia edilebilir, ancak içerik değildir.

Önceki cevaplarda göremediğim bir şey daha var: Java'da Integer, Double, Float, Boolean ... ve String gibi ilkel sarmalayıcı sınıflarının değişmez olması gerekiyordu, böylece bu sınıfların bir örneğini ilettiğinizde yöntemi, dahili verilerin genel yöntemleriyle değiştirilebileceği diğer sınıfların çoğuna göre verilerinizi hiçbir şekilde değiştiremez. Böylece bu sınıfların kurucu dışında sadece 'getter' yöntemleri vardır, 'setter' yoktur.

Bir java programında String değişmezleri, bu örnekleri yeniden kullanarak belleği kaydetmek için yığın belleğin ayrı bir bölümünde (yalnızca değişmez bir örnek) saklanır

daha önce programladınız mı (int) değişkenleriniz için ayarlayabileceğiniz ilkel türlerden biridir (char, float, ... gibi).

ancak Integer, int değişkeninde bazı işlevler yapmak için kullanabileceğiniz bir sarmalayıcı sınıfıdır (örneğin, dizeye dönüştürmek veya tam tersi, ...), ancak sarmalayıcı sınıflarındaki yöntemlerin statik olduğunu unutmayın. bir Integer sınıf örneği oluşturmadan. özet olarak:

int x;
Integer y; 

x ve y her ikisi de int türünde değişkenlerdir, ancak y bir Integer sınıfı tarafından sarılır ve kullandığınız çeşitli yöntemlere sahiptir, ancak tamsayı sarmalayıcı sınıfının bazı işlevlerini çağırmanız yeterlidir.

Integer.toString(x);

ancak hem x hem de y'nin doğru olduğunu unutmayın, ancak bunları sadece ilkel bir tür olarak kullanmak istiyorsanız, basit formu kullanın (x'i tanımlamak için kullanılır).

Java:

int, double, long, byte, float, double, short, boolean, char- ilkel. Dilin desteklediği temel veri türlerini tutmak için kullanılır. ilkel türler nesne hiyerarşisinin bir parçası değildir ve Nesneyi devralmazlar. Bir yönteme istinaden geçemezler.

Double, Float, Long, Integer, Short, Byte, Character, Ve Boolean, içinde paketlenmiş, mahfazalar tip olanjava.lang . Tüm sayısal tür paketleyicileri, bir nesnenin belirli bir değerden veya bu değerin dize olarak temsil edilmesinden oluşturulmasına izin veren yapıcıları tanımlar. Nesneleri kullanmak, en basit hesaplamalara bile ek yük getirebilir.

JDK 5'ten başlayarak, Java iki çok yararlı özellik içeriyordu: otomatik kutulama ve otomatik kutu açma. Otomatik kutulama / kutudan çıkarma, ilkel türleri nesnelere dönüştürmesi gereken kodu büyük ölçüde basitleştirir ve düzenler;

Kurucu örnekleri:

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

Boks / kutudan çıkarma örneği:

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

Otomatik kutulama / otomatik kutulama örneği:

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 Schildt'in kitabı referans olarak alınmıştır.

Bir int değişkeni 32 bit işaretli bir tamsayı değeri tutar. Bir Tamsayı (büyük harf I ile), (sınıf) tamsayı türündeki bir nesneye veya null değerine başvuru içerir.

Java ikisi arasında otomatik olarak yayın yapar; Integer nesnesi bir int işlecine bağımsız değişken olarak oluştuğunda veya bir int değişkenine atandığında veya bir Integer değişkenine int değeri atandığında, Integer'den int'e. Bu yayınlamaya boks / kutudan çıkarma denir.

Null değerine başvuran bir Integer değişkeni kutudan çıkarılmışsa, açıkça veya örtük olarak, bir NullPointerException oluşturulur.

Java ve C # içindeki int ve Integer, farklı şeyleri temsil etmek için kullanılan iki farklı terimdir. Tam olarak depolanabilen bir değişkene atanabilen ilkel veri türlerinden biridir. Bir kerede bildirilen türünün bir değeri.

Örneğin:

int number = 7;

intYedi değerini tutan değişken numarasına atanan veri türü nerede . Yani bir intnesne değil, sadece bir ilkeldir.

A Integerise statik yöntemlere sahip ilkel bir veri türü için bir sarmalayıcı sınıftır. Bu, bir nesne gerektiren bir yönteme bağımsız değişken olarak kullanılabilir; burada int, tamsayı değeri gerektiren bir yönteme bağımsız değişken olarak kullanılabilir; bu, aritmetik ifade için kullanılabilir.

Örneğin:

Integer number = new Integer(5);

Her iki dilde de (Java ve C #) int4 bayt imzalı tam sayıdır.

Java'nın aksine, C # Hem imzalı hem de imzasız tamsayı değerleri sağlar. Java ve C # nesne nesnesine yönelik olduğundan, bu dillerdeki bazı işlemler doğrudan çalışma süresi tarafından sağlanan talimatlarla eşleşmez ve bu nedenle bir tür nesnenin parçası olarak tanımlanması gerekir.

C #, System.Int32bellekte öbek üzerinde başvuru türüne ait olan bir bölümü kullanan bir değer türü sağlar.

java, java.lang.Integerüzerinde çalışan bir referans türüdür int. Yöntemler Integerbiz tamsayı örneğine haline dönüştürmek ve bazı tip örneği tahmin yöntemleri (gibi kullanmak için bir int değeri kutu instructions.So kutu olup zaman çalıştırmak için, doğrudan derlenmiş toString(), parseInt(), valueOf()vb.)

C # değişkeninde int System.Int32.Any, bellekte 4 bayt değere karşılık gelir, ilkel bir int olarak yorumlanabilir, bu System.Int32.So ile değiştirilebilir. Yani int , vb. System.Int32.WhenGibi tamsayı ile ilgili yöntemleri kullanmak için bir takma addır. FCL gibi ilgili yöntemler çağrı yapısına bir , .int.Parse()int.ToString()System.Int32Int32.Parse()Int32.ToString()

Java'da, inttür ilkel bir veri türüdür; burada Integertür olarak bir nesnedir.

C # 'da, inttür aynı bir veri türüdür System.Int32. Bir integernesne (diğer değer türlerinde olduğu gibi) bir nesneye kutulanabilir ("sarılabilir").

Java'da ilkel bir veri türü, Integer bir Helper sınıfı iken, bir veri türünü diğerine dönüştürmek için kullanılır.

Örneğin:

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

İlkel veri türleri, Helper sınıfının karmaşık olduğu en hızlı belleği saklar ve koyun belleğinde saklanır.

"David Gassner" Java Temel Eğitimi referans.

"int", ilkel veri türüdür ve Java'daki Wrapper Sınıfındaki "Tamsayı" dır. "Tamsayı", bir nesne gerektiren bir yönteme bağımsız değişken olarak kullanılabilir; burada "int", aritmetik ifade için kullanılabilecek bir tamsayı değeri gerektiren bir yönteme bağımsız değişken olarak kullanılabilir.

01. Tam sayı boş olabilir. Ancak int boş olamaz.

Integer value1 = null; //OK

int value2 = null      //Error

02. Sadece Wrapper Classes tip değerlerini herhangi bir koleksiyon sınıfına iletebilir.

(Sarıcı Sınıfları - Boole, Karakter, Bayt, Kısa, Tamsayı, Uzun, Kayan Nokta, Çift)

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

Ama normalde toplama sınıfına ilkel değerler ekliyoruz? 02 nolu nokta doğru mu?

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

Evet 02 doğrudur, çünkü autoboxing.

Otomatik kutulama, java derleyicisinin ilkel tip ve karşılık gelen sarmalayıcı sınıfı arasında yaptığı otomatik dönüşümdür.

Sonra 5 otomatik kutulama ile Tamsayı değeri olarak dönüştürün.

int c # kütüphane fonksiyonunda önceden tanımlanmıştır ancak java'da Integer

(Java Sürümü) Basit kelimelerde int ilkeldir ve Integer int için sarıcı nesnesidir.

Integer vs int'in nasıl kullanılacağına bir örnek, int değişkenini karşılaştırmak istediğinizde null değerini atar.

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

Java'da benim bilgime göre öğrenirseniz, o zaman int a yazdığınızda; sonra java jenerik kodu gibi derler Integer a = new Integer(). Yani, jeneriklere Integergöre kullanılmaz int, kullanılır. orada böyle bir fark var.

int , ilkel bir veri türüdür. Tamsayı bir sarıcı sınıftır. İnt verilerini nesne olarak saklayabilir.

int, ilkel bir veri tipidir, oysa Integer bir nesnedir. Integer ile bir nesne oluşturmak, Integer sınıfında bulunan tüm yöntemlere erişmenizi sağlar. Ancak, int ile ilkel bir veri türü oluşturursanız, bu oluşturma yöntemlerini kullanamazsınız ve bunları kendiniz tanımlamanız gerekir. Ancak, başka bir yöntem istemiyorsanız ve programı daha fazla bellek verimli yapmak istiyorsanız, ilkel veri tipiyle devam edebilirsiniz, çünkü bir nesne oluşturmak bellek tüketimini artıracaktır.