Wat is die verskil tussen 'n int en 'n heelgetal in Java en C#?

StackOverflow https://stackoverflow.com/questions/564

  •  08-06-2019
  •  | 
  •  

Vra

ek het gelees Meer Joel oor sagteware toe ek teëgekom het Joel Spolsky iets te sê oor 'n spesifieke tipe programmeerder wat die verskil tussen 'n int en 'n Integer in Java/C# (Object Oriented Programming Languages).

So, wat is die verskil?

Was dit nuttig?

Oplossing

In Java, die 'int'-tipe is 'n primitief, terwyl die 'Geheelgetal'-tipe 'n voorwerp is.

In C#, die 'int' tipe is dieselfde as System.Int32 en is 'n waardetipe (dws meer soos die java 'int').'n Heelgetal (net soos enige ander waardetipes) kan wees geboks ("toegedraai") in 'n voorwerp.

Die verskille tussen objekte en primitiewe is ietwat buite die bestek van hierdie vraag, maar om op te som:

Voorwerpe voorsien fasiliteite vir polimorfisme, word deur verwysing geslaag (of meer akkuraat het verwysings deur waarde laat slaag), en word toegeken vanaf die hoop.Omgekeerd, primitiewe is onveranderlike tipes wat deur waarde geslaag word en word dikwels van die stapel.

Ander wenke

Wel, in Java is 'n int 'n primitief terwyl 'n heelgetal 'n objek is.Betekenis, as jy 'n nuwe heelgetal gemaak het:

Integer i = new Integer(6);

Jy kan een of ander metode op i noem:

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

Terwyl met 'n int:

int i = 6;

Jy kan nie enige metodes daarop noem nie, want dit is bloot 'n primitief.Dus:

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

sou 'n fout produseer, want int is nie 'n objek nie.

int is een van die min primitiewe in Java (saam met char en 'n paar ander).Ek is nie 100% seker nie, maar ek dink dat die Integer-objek min of meer net 'n int-eienskap en 'n hele klomp metodes het om met daardie eienskap te kommunikeer (soos die toString()-metode byvoorbeeld).Dus is Integer 'n spoggerige manier om met 'n int te werk (Net soos String miskien 'n spoggerige manier is om met 'n groep chars te werk).

Ek weet dat Java nie C is nie, maar aangesien ek nog nooit in C geprogrammeer het nie, is dit die naaste wat ek aan die antwoord kon kom.Hoop dit help!

Heelgetal voorwerp javadoc

Heelgetal Ojbekt vs.int primitiewe vergelyking

Ek sal byvoeg by die uitstekende antwoorde wat hierbo gegee is, en praat oor boks en unboxing, en hoe dit op Java van toepassing is (alhoewel C# dit ook het).Ek sal net Java-terminologie gebruik, want ek is meer au fait met daardie.

Soos die antwoorde genoem het, int is net 'n nommer (genoem die uitgepak tipe), terwyl Integer is 'n voorwerp (wat die getal bevat, dus a geboks tipe).In Java-terme beteken dit (behalwe dat u nie metodes kan aanroep nie int), kan jy nie stoor nie int of ander nie-voorwerp tipes in versamelings (List, Map, ens.).Om dit te stoor, moet jy dit eers in die ooreenstemmende boks tipe opberg.

Java 5 en verder het iets genoem outomatiese boks en outo-ontboks wat toelaat dat die boks/ontboks agter die skerms gedoen word.Vergelyk en kontrasteer:Java 5 weergawe:

Deque<Integer> queue;

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

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

Java 1.4 of vroeër (ook geen generieke nie):

Deque queue;

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

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

Daar moet kennis geneem word dat ten spyte van die bondigheid in die Java 5-weergawe, genereer beide weergawes identiese greepkode.Dus, hoewel outo-boks en outo-ontboks baie gerieflik is omdat jy minder kode skryf, is hierdie bewerkings doen gebeur agter die skerms, met dieselfde looptydkoste, so jy moet steeds bewus wees van hul bestaan.

Hoop dit help!

Ek sal net hier plaas aangesien sommige van die ander plasings effens onakkuraat is met betrekking tot C#.

Korrek: int is 'n alias vir System.Int32.
Verkeerde: float is nie 'n alias vir System.Float, maar vir System.Single

Basies is int 'n gereserveerde sleutelwoord in die C#-programmeertaal, en is 'n alias vir die System.Int32 waarde tipe.

float en Float is egter nie dieselfde nie, aangesien die regte stelseltipe vir ''float'' is System.Single.Daar is 'n paar tipes soos hierdie wat gereserveerde sleutelwoorde het wat blykbaar nie direk by die tipe name pas nie.

In C# is daar geen verskil tussen ''int'' en ''System.Int32'', of enige van die ander pare of sleutelwoorde/stelseltipes, behalwe wanneer enums gedefinieer word.Met enums kan jy die stoorgrootte spesifiseer om te gebruik en in hierdie geval kan jy net die gereserveerde sleutelwoord gebruik, en nie die stelsel se looptyd tipe naam nie.

Of die waarde in die int op die stapel gestoor sal word, in die geheue, of as 'n verwysde hoopvoorwerp hang af van die konteks en hoe jy dit gebruik.

Hierdie verklaring in 'n metode:

int i;

definieer 'n veranderlike i van tipe System.Int32, woon in 'n register of op die stapel, afhangende van optimalisering.Dieselfde verklaring in 'n tipe (struktuur of klas) definieer 'n lidveld.Dieselfde verklaring in 'n metode-argumentlys definieer 'n parameter, met dieselfde bergingsopsies as vir 'n plaaslike veranderlike.(let daarop dat hierdie paragraaf nie geldig is as jy iteratormetodes in die mengsel begin intrek nie, dit is heeltemal verskillende diere)

Om 'n hoop voorwerp te kry, kan jy boks gebruik:

object o = i;

dit sal 'n bokskopie van die inhoud van skep i op die hoop.In IL kan jy direk toegang tot metodes op die hoop voorwerp kry, maar in C# moet jy dit terugstuur na 'n int, wat nog 'n kopie sal skep.Die voorwerp op die hoop kan dus nie maklik in C# verander word sonder om 'n nuwe bokskopie van 'n nuwe int-waarde te skep nie.(Ugh, hierdie paragraaf lees nie so maklik nie.)

Met betrekking tot Java 1.5 en outoboks daar is 'n belangrike "quirk" wat kom om te speel wanneer heelgetal voorwerpe vergelyk word.

In Java is Heelgetal-objekte met die waardes -128 tot 127 onveranderlik (dit wil sê, vir een spesifieke heelgetalwaarde, sê 23, wys alle Heelgetal-objekte wat deur jou program met die waarde 23 geïnstansieer word na die presies dieselfde voorwerp).

Byvoorbeeld, dit gee waar:

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

Terwyl dit vals gee:

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

Die == vergelyk deur verwysing (wys die veranderlikes na dieselfde voorwerp).

Hierdie resultaat mag of mag nie verskil afhangende van watter JVM jy gebruik nie.Die spesifikasie outoboks vir Java 1.5 vereis dat heelgetalle (-128 tot 127) altyd by dieselfde omhulvoorwerp inboks.

'n Oplossing?=) 'n Mens moet altyd die Integer.equals()-metode gebruik wanneer jy Integer-objekte vergelyk.

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

Meer inligting by java.net Voorbeeld by bexhuff.com

In Java is daar twee basiese tipes in die JVM.1) Primitiewe tipes en 2) Verwysingstipes.int is 'n primitiewe tipe en Heelgetal is 'n klastipe (wat 'n soort verwysingstipe is).

Primitiewe waardes deel nie staat met ander primitiewe waardes nie.'n Veranderlike waarvan die tipe 'n primitiewe tipe is, het altyd 'n primitiewe waarde van daardie tipe.

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

'n Voorwerp is 'n dinamies geskepte klasinstansie of 'n skikking.Die verwysingswaardes (dikwels net verwysings) is verwysings na hierdie voorwerpe en 'n spesiale nulverwysing, wat na geen voorwerp verwys nie.Daar kan baie verwysings na dieselfde voorwerp wees.

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

Ook in Java word alles deur waarde deurgegee.Met voorwerpe is die waarde wat deurgegee word die verwysing na die voorwerp.So 'n ander verskil tussen int en Integer in java is hoe hulle in metode-oproepe deurgegee word.Byvoorbeeld in

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

Die veranderlike twee word deurgegee as die primitiewe heelgetal tipe 2.Terwyl 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 veranderlike twee word deurgegee as 'n verwysing na 'n voorwerp wat die heelgetalwaarde 2 bevat.

@WolfmanDragon:Slaag deur verwysing sal so werk:

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

Wanneer inkrement genoem word, stuur dit 'n verwysing (wyser) na veranderlike a.En die inkrement funksie verander veranderlike direk a.

En vir voorwerptipes sal dit soos volg werk:

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

Sien jy nou die verskil?

In C# is int net 'n alias vir System.Int32, string vir System.String, verdubbel vir System.Double ens...

Persoonlik verkies ek int, string, double, ens.omdat hulle nie 'n using System; stelling :) 'n simpel rede, ek weet ...

Daar is baie redes om wikkelklasse te gebruik:

  1. Ons kry ekstra gedrag (ons kan byvoorbeeld metodes gebruik)
  2. Ons kan nulwaardes stoor terwyl ons in primitiewe nie kan nie
  3. Versamelings ondersteun die stoor van voorwerpe en nie primitiewe nie.

Dit is reeds vir Java beantwoord, hier is die C#-antwoord:

"Geheelgetal" is nie 'n geldige tipe naam in C# nie en "int" is net 'n alias vir System.Int32.Ook, anders as in Java (of C++) is daar geen spesiale primitiewe tipes in C# nie, elke geval van 'n tipe in C# (insluitend int) is 'n objek.Hier is 'n paar demonstratiewe kode:

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 word gebruik om primitiewe veranderlike te verklaar 

e.g. int i=10;

Heelgetal word gebruik om verwysingsveranderlike van klas Heelgetal te skep

Integer a = new Integer();

In platforms soos Java, ints is primitiewe terwyl Integer is 'n voorwerp wat 'n heelgetalveld bevat.Die belangrike onderskeid is dat primitiewe altyd deur waarde deurgegee word en per definisie onveranderlik is.

Enige bewerking wat 'n primitiewe veranderlike behels gee altyd 'n nuwe waarde terug.Aan die ander kant word voorwerpe deur verwysing rondgestuur.Mens kan redeneer dat die punt na die voorwerp (ook bekend as die verwysing) ook deur waarde deurgegee word, maar die inhoud is nie.

Nog een ding wat ek nie in vorige antwoorde sien nie:In Java die primitiewe wikkelklasse soos Integer, Double, Float, Boolean...en String is veronderstel om onveranderlik te wees, sodat wanneer jy 'n instansie van daardie klasse slaag, die opgeroep metode nie jou data op enige manier kon verander nie, in teenstelling met die meeste ander klasse, welke interne data deur sy publieke metodes verander kan word.Sodat hierdie klasse slegs 'getter'-metodes het, geen 'setters', behalwe die konstruktor.

In 'n java-program word stringletters in 'n aparte gedeelte van hoopgeheue gestoor, slegs 'n instansie vir letterlik, om geheue te bespaar deur daardie instansies te hergebruik

het jy al ooit tevore geprogrammeer (int) is een van die primitiewe tipes wat jy vir jou veranderlikes kan stel (net soos char, float, ...).

maar Heelgetal is 'n wikkelklas wat jy dit kan gebruik om sommige funksies op 'n int-veranderlike te doen (bv. omskep dit na string of andersom,...), maar hou kennis dat metodes in die wikkelklasse staties is sodat jy dit kan gebruik enige tyd sonder om 'n instansie van Heelgetalklas te skep.as 'n opsomming:

int x;
Integer y;

x en y is albei veranderlikes van tipe int, maar y word toegedraai deur 'n Heelgetalklas en het verskeie metodes wat jy gebruik, maar as jy sekere funksies van Heelgetal-omhulklas moet noem, kan jy dit eenvoudig doen.

Integer.toString(x);

maar wees bewus daarvan dat beide x en y korrek is, maar as jy hulle net as 'n primitiewe tipe wil gebruik, gebruik die eenvoudige vorm (gebruik om x te definieer).

Java:

int, double, long, byte, float, double, short, boolean, char - primitiewe.Word gebruik om die basiese datatipes wat deur die taal ondersteun word, te hou.Die primitiewe tipes vorm nie deel van die voorwerphiërargie nie, en hulle erf nie voorwerp nie.Dit kan deur verwysing na 'n metode geslaag word.

Double, Float, Long, Integer, Short, Byte, Character, en Boolean, is tipe Wrappers, verpak in java.lang.Al die numeriese tipe omhulsels definieer konstruktors wat toelaat dat 'n voorwerp gekonstrueer word vanaf 'n gegewe waarde, of 'n string voorstelling van daardie waarde.Die gebruik van voorwerpe kan 'n oorhoofse koste byvoeg tot selfs die eenvoudigste berekeninge.

Begin met JDK 5, het Java twee baie nuttige kenmerke ingesluit:outoboks en outo-ontboks.Outoboks/ontboks vergemaklik en stroomlyn kode wat primitiewe tipes in voorwerpe moet omskakel, en omgekeerd.

Voorbeeld van konstrukteurs:

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

Voorbeeld van boks/ontboks:

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

Voorbeeld van outoboks/outo-ontboks:

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

P.S.Herbert Schildt se boek is as verwysing geneem.

int is 'n primitiewe datatipe.Heelgetal is 'n wikkelklas.Dit kan int-data as voorwerpe stoor.

'n Int-veranderlike hou 'n 32-bis getekende heelgetalwaarde.'n Heelgetal (met hoofletter I) hou 'n verwysing na 'n voorwerp van (klas) tipe Heelgetal, of na nul.

Java gooi outomaties tussen die twee;vanaf Heelgetal na int wanneer die Heelgetal-objek as 'n argument aan 'n int-operateur voorkom of aan 'n int-veranderlike toegeken word, of 'n int-waarde aan 'n Heelgetalveranderlike toegeken word.Hierdie rolverdeling word boks/ontboks genoem.

As 'n Heelgetal-veranderlike wat 'n nul verwys, uitgepak word, eksplisiet of implisiet, word 'n NullPointerException gegooi.

'n Int en Heelgetal in Java en C# is twee verskillende terme wat gebruik word om verskillende dinge voor te stel.Dit is een van die primitiewe datatipes wat aan 'n veranderlike toegeken kan word wat presies kan stoor.Een waarde van sy verklaarde tipe op 'n slag.

Byvoorbeeld:

int number = 7;

Waar int is die datatipe toegeken aan die veranderlike getal wat die waarde sewe hou.Dus 'n int is net 'n primitief nie 'n voorwerp nie.

Terwyl 'n Integer is 'n omhulklas vir 'n primitiewe datatipe wat statiese metodes het.Dit kan gebruik word as 'n argument vir 'n metode wat 'n objek vereis, waar as int gebruik kan word as 'n argument vir 'n metode wat 'n heelgetalwaarde vereis, wat gebruik kan word vir rekenkundige uitdrukking.

Byvoorbeeld:

Integer number = new Integer(5);

In beide tale (Java en C#) int is 4-grepe getekende heelgetal.

Anders as Java, bied C# beide getekende en ongetekende heelgetalwaardes.Aangesien Java en C# objekobjekgeoriënteerd is, word sommige bewerkings in hierdie tale nie direk afgebeeld op instruksies wat deur die looptyd verskaf word nie en moet dus gedefinieer word as deel van 'n voorwerp van een of ander tipe.

C# verskaf System.Int32 wat 'n waardetipe is wat 'n deel van geheue gebruik wat aan die verwysingstipe op die hoop behoort.

java verskaf java.lang.Integer wat 'n verwysingstipe is wat op werk int.Die metodes in Integer kan nie direk saamgestel word om tyd instruksies uit te voer nie. Ons boks dus 'n int-waarde om dit om te skakel na 'n instansie van Heelgetal en gebruik die metodes wat instansie van een of ander tipe verwag (soos toString(), parseInt(), valueOf() ens).

In C# verwys veranderlike int na System.Int32.Any 4-grepe waarde in geheue kan geïnterpreteer word as 'n primitiewe int, wat gemanipuleer kan word deur instansie van System.Int32.So int is 'n alias vir System.Int32.When gebruik heelgetalverwante metodes soos int.Parse(), int.ToString() ens.Heelgetal word saamgestel in die FCL System.Int32 struct noem die onderskeie metodes soos Int32.Parse(), Int32.ToString().

In Java, die int tipe is 'n primitiewe datatipe, waar as die Integer tipe is 'n voorwerp.

In C#, die int tipe is ook 'n datatipe dieselfde as System.Int32.An integer (net soos enige ander waardetipes) kan in 'n objek geboks ("toegedraai") word.

In Java is int 'n primitiewe datatipe terwyl Integer 'n Helper-klas is, dit word gebruik om vir een datatipe na 'n ander om te skakel.

Byvoorbeeld: 

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

Primitiewe datatipes stoor die vinnigste beskikbare geheue waar die Helper-klas kompleks is en stoor in heep-geheue.

verwysing van "David Gassner" Java Essential Training.

"int" is primitiewe datatipe en "Geheelgetal" in Wrapper Class in Java."Geheelgetal" kan gebruik word as 'n argument vir 'n metode wat 'n objek vereis, waar as "int" as 'n argument gebruik kan word vir 'n metode wat 'n heelgetalwaarde vereis, wat gebruik kan word vir rekenkundige uitdrukking.

01.Heelgetal kan nul wees.Maar int kan nie nul wees nie.

Integer value1 = null; //OK

int value2 = null      //Error

02.Slegs kan Wrapper Classes tipe waardes aan enige versamelingsklas deurgee.

(Omhulklasse - Boole, Karakter, Byte, Kort, Heelgetal, Lank, Float, Dubbel)

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

Maar gewoonlik voeg ons primitiewe waardes by versamelingsklas?Is punt 02 korrek?

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

Ja 02 is korrek, want autoboxing.

AutoBoxing is die outomatiese omskakeling wat die Java -samesteller tussen die primitiewe tipe en hul ooreenstemmende omhulselklas maak.

Skakel dan 5 om as heelgetalwaarde deur outoboks.

int is vooraf gedefinieer in biblioteekfunksie c#, maar in java kan ons 'n voorwerp skep van Integer

(Java -weergawe) In eenvoudige woorde is int primitief en heelgetal is 'n wikkelvoorwerp vir int.

Een voorbeeld waar om Integer vs int te gebruik, As jy wil vergelyk en int veranderlike weer null sal dit fout gooi.

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

In java volgens my kennis as jy leerder dan, wanneer jy int a skryf;dan in java generies sal dit kode saamstel soos Integer a = new Integer().Dus, soos per generiese Integer word nie gebruik nie, maar int is gebruik.so daar is so so 'n verskil daar.

Gelisensieer onder: CC-BY-SA met toeskrywing
Nie verbonde aan StackOverflow
scroll top