Mi a különbség egy int és egy egész szám, Java és C #?

szavazat
222

Olvastam több Joel on Software amikor rábukkantam Joel Spolsky mondott valamit egy bizonyos típusú programozó ismerve a különbség egy intés egy IntegerJava / C # (objektum-orientált programozási nyelvek).

Szóval, mi a különbség?

A kérdést 02/08/2008 22:47
a forrás felhasználó
Más nyelveken...                            


27 válasz

szavazat
216

A Java, a „int” típusú primitív, mivel az „Egész” típusú objektum.

C #, a „int” típusú megegyezik System.Int32, és az érték típusú (azaz több, mint a java „int”). Egy egész szám (mint bármely más típusú érték) lehet dobozos ( „csomagolt”) egy objektum.


A különbség objektumok és primitívek némileg túlmutat a kérdés, de összefoglalni:

Tárgyak megteremtik polimorfizmus átadása hivatkozás (vagy pontosabban referenciákkal által elfogadott érték), és osztják a kupac . Ezzel szemben, primitívek megváltoztathatatlanok típusok érték szerint adódnak át, és gyakran utalt ki a köteget .

Válaszolt 02/08/2008 22:55
a forrás felhasználó

szavazat
135

Nos, Java int egy primitív, míg egy Egész egy objektum. Vagyis ha készített új Integer:

Integer i = new Integer(6);

Nevezhetjük néhány módszert i:

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

Míg egy int:

int i = 6;

Nem lehet hívni olyan módszereket rajta, mert egyszerűen primitív. Így:

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

hozna egy hiba, mert int nem egy tárgy.

int az egyik pár primitívek Java (együtt char és mások). Nem vagyok 100% -ig biztos, de azt hiszem, hogy az Egész objektum csak többé-kevésbbé van egy int tulajdon és egy csomó módszerek lépni az ingatlan (mint például a toString () metódus például). Tehát Egész divatos módja hogy együtt dolgozik egy int (Mint ahogy talán karakterlánc egy díszes munkába egy csoport után).

Tudom, hogy a Java nem C, de mivel én még soha nem programozott C ez van a legközelebb tudtam jönni a választ. Remélem ez segít!

Integer objektum javadoc

Integer Ojbect vs. int primitív összehasonlítás

Válaszolt 02/08/2008 23:05
a forrás felhasználó

szavazat
11

C #, int csak egy alias a System.Int32, string System.String, kétágyas System.Double, stb ...

Személy szerint én inkább int, string, dupla, stb, mert nem igényelnek using System;nyilatkozatot :) Egy fura okból, tudom ...

Válaszolt 03/08/2008 00:37
a forrás felhasználó

szavazat
32

Adom hozzá a kiváló választ a fenti, és beszélni boksz és unboxing, és ez hogyan vonatkozik a Java (bár a C # ez túl). Fogom használni, csak a Java terminológiát, mert én jobban au fait azzal.

Ahogy a választ említettük, intcsak egy szám (az úgynevezett bontatlan ), miközben Integeregy olyan objektum (amely tartalmazza azt a számot, így a dobozos típus). A Java szempontjából ez azt jelenti, (eltekintve, hogy nem tud hívni módszereket int), akkor nem lehet tárolni intvagy más, nem-objektum típusok gyűjteményekben ( List, Mapstb.) Annak érdekében, hogy tárolni őket, akkor először a doboz fel őket a megfelelő dobozos típusát.

Java 5-től van egy úgynevezett automatikus boksz és auto-kicsomagolós amely lehetővé teszi a box / unboxing kell tenni a színfalak mögött. Összehasonlítás és kontraszt: Java 5 verzió:

Deque<Integer> queue;

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

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

Java 1.4 vagy korábbi (nincs a generikus gyógyszerek sem):

Deque queue;

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

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

Meg kell jegyezni, hogy annak ellenére, hogy az egyszerűség kedvéért a Java 5 verzió, mindkét változat generál azonos bytecode. Így, bár auto-box és az automatikus kicsomagolós nagyon kényelmes, mert írsz kevesebb kódot, ezek a műveletek nem történnek a színfalak mögött, az azonos futási költségeket, így még mindig van tisztában a létezésükről.

Remélem ez segít!

Válaszolt 03/08/2008 03:32
a forrás felhasználó

szavazat
26

Majd csak postai úton van, mivel néhány más hozzászólás kissé pontatlan kapcsolatban a C #.

Helyes: int álneve System.Int32.
Rossz: float nem egy álnevet System.Float, deSystem.Single

Alapvetően int egy fenntartott kulcsszót a C # programozási nyelv és egy álnevet az System.Int32érték típusát.

úszó és Float nem azonos azonban, mint a megfelelő rendszert típusú „” float„” jelentése System.Single. Vannak olyan típusú, mint ez, hogy fenntartotta a kulcsszavakat, amelyek úgy tűnik, nem felel meg a típus nevét közvetlenül.

A C # nincs különbség a „” int„” és „” System.Int32„”, vagy bármely más párokat vagy kulcsszavak / rendszer típusok, kivéve akkor, ha meghatározásakor enums. A enums megadhatja a tárolási méret használni, és ebben az esetben csak akkor tudjuk használni a lefoglalt kulcsszó, és nem a rendszer futási típus neve.

Wether az érték az int lesz a veremben tárolt, a memóriában, vagy a hivatkozott objektum kupac függ az adott helyzettől és hogyan használja azt.

Ez a nyilatkozat a módszer:

int i;

meghatároz egy változó itípusú System.Int32, élő nyilvántartásban vagy a veremben, attól függően, optimalizálás. Ugyanez nyilatkozatot egy típusú (struct vagy osztály) definiál egy tagja mezőt. Ugyanez nyilatkozat eljárásában argumentumlista meghatároz egy paraméter, ugyanazzal a tárolási lehetőségek, mint a helyi változó. (Megjegyzendő, hogy ez a bekezdés nem érvényes, ha elkezdi húzza bejáró módszerek a mix, ezek különböző állatok összesen)

Ahhoz, hogy egy halom tárgyat, akkor boksz:

object o = i;

Ez létrehoz egy dobozos példányt a tartalmát ia kupac. Az IL érheti módszerek a kupac objektumot közvetlenül, hanem a C # meg kell vetni, hogy vissza int, amely létrehoz egy példányt. Így a tárgy a kupac nem könnyen módosítható C # létre egy új dobozos példányt egy új int értéket. (Huh, ez a bekezdés nem olvassa el az összes ilyen könnyen.)

Válaszolt 04/08/2008 15:11
a forrás felhasználó

szavazat
7

Ezt már megválaszolták a Java, itt a C # választ:

„Egész” nem érvényes típus neve C # és „int” csak egy alias a System.Int32. Továbbá, ellentétben a Java (vagy C ++) nincsenek különleges primitív típusok: C #, minden esetben olyan típusú, C # (beleértve int) egy objektum. Íme néhány demonstratív kód:

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;
}
Válaszolt 04/08/2008 22:02
a forrás felhasználó

szavazat
18

Ami Java 1.5 és autoboxing van egy fontos „trükkje”, hogy jön játszani, ha összehasonlítjuk Egész tárgyakat.

A Java, Egész objektumok értékeit -128 127 megváltoztathatatlanok (azaz egy bizonyos egész érték, mondjuk 23, az összes egész objektum példányai keresztül a programot, melynek értéke 23 pont, hogy a pontos ugyanazt a tárgyat).

Például ez igaz értékkel tér vissza:

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

Bár ez a hamis értékkel tér vissza:

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

A == le hivatkozással (nem a változók ugyanarra a tárgy).

Ez az eredmény lehet, hogy nem különböznek attól függően, hogy milyen JVM használ. A leírás autoboxing Java 1.5 megköveteli, hogy egész (-128 127) mindig mezőbe ugyanazt átalakító objektum.

Egy megoldás? =) Egy mindig használja a Integer.equals () metódust, ha összehasonlítjuk Egész tárgyakat.

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

További információ: java.net példa a bexhuff.com

Válaszolt 05/08/2008 21:49
a forrás felhasználó

szavazat
17

A Java van két alapvető típusa a JVM . 1) ősi típusú és 2) Referencia típusok. int egy primitív típusú és integer egy osztály típusú (amely olyan referenciát típus).

Primitív értékek ne ossza állam más primitív értékeket. A változó, amelynek típusa primitív típus mindig tart egy primitív értéket az ilyen típusú.

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

Egy objektum egy dinamikusan létrehozott osztály például vagy egy tömb. A referenciaértékeket (gyakran csak hivatkozásokat) mutató pointer ezeket a tárgyakat, és egy különleges null referencia arra utal, hogy nem számít. Lehet, hogy sok utalást ugyanazt a tárgyat.

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

Szintén Java mindent fogad el érték. A tárgyak az érték, amely eltelt a hivatkozás az objektumot. Tehát egy másik különbség int és egész java hogyan kerülnek átadásra az eljárásoknak. Például a

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

A változó két vezetjük, mint a primitív egész típusú 2. mivel a

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

A változó két vezetjük, mint a referencia, hogy egy tárgy, hogy tartja a egész érték 2.


@WolfmanDragon: Pass referenciaként fog működni, mint így:

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

Amikor növekmény nevezzük áthalad egy referencia (pointer), hogy a változó egy . És a növekmény funkció közvetlenül módosítja a változó egy .

És objektumtípusra, hogy működni fog a következő:

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

Látod a különbséget most?

Válaszolt 06/08/2008 12:08
a forrás felhasználó

szavazat
6

Még egy dolog, hogy én nem látom az előző választ: A Java primitív csomagolóanyagokat osztályok, mint Integer, Double, Float, logikai ... és a String vannak suposed változatlannak úgy, hogy amikor át egy példányát az osztályok a meghívott módszer nem változtatják meg az adatait semmilyen módon, a opositión a legtöbb más osztályokba, amelyek a belső adatokat lehet változtatni annak nyilvános módszerekkel. Annak érdekében, hogy ez osztályok csak „getter” módszerekkel, nem „alkotóinak” mellett a kivitelező.

Egy Java program sztring literálok vannak tárolva egy külön része kupacmemóriája csak fokon szó, hogy mentse a memória újrafelhasználása azokban az esetekben,

Válaszolt 06/08/2008 15:33
a forrás felhasználó

szavazat
8

A platformok, mint a Java, ints olyan primitívek, miközben Integeregy olyan objektum, amely rendelkezik egy egész szám mezőt. A legfontosabb különbség az, hogy primitívek mindig körbejárnak az érték és a definíció szerint megváltoztathatatlan.

Bármilyen művelet esetében egy primitív változó mindig visszatér egy új értéket. Másrészt, a tárgyak körbejárnak hivatkozunk. Lehet azzal érvelni, hogy az a pont, hogy a tárgy (AKA referencia) is vezetjük körül az érték, de a tartalmát nem.

Válaszolt 31/01/2009 03:49
a forrás felhasználó