Wat is het verschil tussen een int en een Integer in Java en C #?

stemmen
222

Ik las Meer Joel on Software toen ik over kwam Joel Spolsky iets over een bepaald type programmeur kennen het verschil tussen een zeggen inten een Integerin Java / C # (Object Oriented Programming Languages).

Dus, wat is het verschil?

De vraag is gesteld op 02/08/2008 om 22:47
bron van user
In andere talen...                            


27 antwoorden

stemmen
216

Op Java, het type 'int' is een primitieve, terwijl het 'Integer' type object.

In C #, het type 'Int' is gelijk System.Int32en is een waarde type (dat wil zeggen meer op de java 'Int'). Een getal (net als andere waardetypes) kunnen worden doos ( "ingepakt") in een object.


De verschillen tussen objecten en primitieven enigszins buiten het bestek van deze vraag, maar te vatten:

Voorwerpen faciliteiten ter polymorfisme worden doorgegeven als verwijzing (of beter gezegd hebben gevonden voorbij waarde), en worden toegewezen uit de stapel . Omgekeerd primitieven onveranderlijk soorten die waarde doorgegeven en worden vaak toegewezen uit de stapel .

antwoordde op 02/08/2008 om 22:55
bron van user

stemmen
135

Nou, in Java een int is een primitieve, terwijl een geheel getal is een object. Wat betekent dat, als je een nieuwe Integer gemaakt:

Integer i = new Integer(6);

Je zou een methode een beroep doen op i:

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

Overwegende dat met een int:

int i = 6;

U kunt niet bellen geen methoden op, want het is gewoon een primitief. Zo:

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

zou een fout veroorzaken, omdat int geen object.

int is een van de weinige primitieven in Java (samen met char en enkele anderen). Ik ben niet 100% zeker, maar ik denk dat de Integer object min of meer heeft gewoon een int eigendom en een hele hoop manieren om te communiceren met die eigenschap (zoals de methode toString () bijvoorbeeld). Dus Integer is een mooie manier om te werken met een int (Net als misschien wel String is een mooie manier om te werken met een groep van tekens).

Ik weet dat Java is niet C, maar omdat ik nooit in C geprogrammeerd hebt is dit het beste wat ik aan het antwoord zou kunnen komen. Ik hoop dat dit helpt!

Integer object javadoc

Integer Ojbect vs. int primitief vergelijking

antwoordde op 02/08/2008 om 23:05
bron van user

stemmen
11

In C #, int is slechts een alias voor System.Int32, string voor System.String, dubbel voor System.Doubleetc ...

Persoonlijk geef ik de voorkeur int, koord, dubbel, enz. Omdat ze geen nodig using System;verklaring :) Een domme reden dan ook, ik weet het ...

antwoordde op 03/08/2008 om 00:37
bron van user

stemmen
32

Ik zal toevoegen aan de uitstekende bovenstaande antwoorden, en praten over boksen en unboxing, en hoe dit geldt voor Java (hoewel C # heeft het ook). Ik gebruik gewoon Java terminologie, want ik ben meer au fait mee.

Als antwoord vermeld, intis maar een getal (de unboxed type), terwijl Integereen object (die het nummer bevat derhalve een boxed type). In Java termen, dat middelen (afgezien van het niet kunnen methodes op te bellen int), kan je niet opslaan intof andere soorten niet-object in verzamelingen ( List, Mapetc.). Om ze op te slaan, moet u eerst vak hen op in de bijbehorende doos type.

Java 5 hebben verder een zogenaamde auto-boxing en auto-unboxing die het mogelijk maken het boksen / unboxing te doen achter de schermen. Vergelijk en contrast: Java 5 versie:

Deque<Integer> queue;

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

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

Java 1.4 of eerder (geen generics ofwel):

Deque queue;

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

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

Opgemerkt moet worden dat, ondanks de beknoptheid in de Java-5-versie, beide versies te genereren identiek bytecode. Dus, hoewel auto-boksen en auto-unboxing is erg handig, omdat je minder code te schrijven, deze operaties niet gebeuren achter de schermen, met dezelfde runtime kosten, zodat u nog steeds bewust te zijn van hun bestaan.

Ik hoop dat dit helpt!

antwoordde op 03/08/2008 om 03:32
bron van user

stemmen
26

Ik zal gewoon hier posten omdat sommige van de andere posten zijn iets onjuist in relatie tot C #.

Correct: int is een alias voor System.Int32.
Fout: float is niet een alias voor System.Float, maar voorSystem.Single

In principe, int een gereserveerd sleutelwoord in de C # programmeertaal, en is een alias voor de System.Int32waardesoort.

Float drijven en niet hetzelfde echter het recht systeemtype voor '' float'' is System.Single. Er zijn een aantal soorten als dit, dat heeft gereserveerd zoekwoorden die niet lijkt op het type namen direct aan te passen.

In C # er geen verschil tussen '' int'' en '' System.Int32'', of een van de andere paren of zoektermen / systeemtypes, behalve bij de definitie opsommingen. Met enums kunt u de opslagruimte moet worden gebruikt en in dit geval kunt u alleen gebruik maken van de gereserveerde zoekwoord, en niet het systeem runtime typenaam.

Of de waarde in het int zal worden opgeslagen op de stack, in het geheugen, of als een referentie heap object is afhankelijk van de context en hoe je het gebruikt.

Deze verklaring bij een werkwijze:

int i;

definieert een variabele ivan het type System.Int32, die in een register of in de stack, afhankelijk van optimalisaties. Dezelfde verklaring type (struct of klasse) een lid veld. Dezelfde verklaring in een methode lijst met argumenten definieert een parameter, met dezelfde opties voor opslag als voor een lokale variabele. (merk op dat deze paragraaf is niet geldig als je begint te trekken iterator methoden in de mix, dit zijn verschillende beesten in totaal)

Om een ​​hoop object te krijgen, kunt u gebruik maken van het boksen:

object o = i;

dit zal een boxed kopie van de inhoud van te maken iop de heap. In IL kunt u toegang tot de methoden op de heap object rechtstreeks, maar in C # die u nodig hebt om het terug te werpen naar een int, die een ander exemplaar zal leiden. Dus het object op de heap kan niet gemakkelijk worden veranderd in C # zonder een nieuwe boxed exemplaar van een nieuwe waarde int. (Ugh, deze paragraaf niet dat gemakkelijk te lezen allemaal.)

antwoordde op 04/08/2008 om 15:11
bron van user

stemmen
7

Dit is reeds beantwoord voor Java, hier is de C # antwoord:

"Integer" is geen geldig type naam in C # en "int" is gewoon een alias voor System.Int32. Ook, in tegenstelling Java (of C ++) er zijn geen speciale primitieve types in C #, elke instantie van een type C # (inclusief int) een object. Hier zijn een paar demonstratief 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;
}
antwoordde op 04/08/2008 om 22:02
bron van user

stemmen
18

Ten aanzien van Java 1.5 en autoboxing is er een belangrijk "gril" die komt om te spelen bij het vergelijken van Integer objecten.

In Java, Integer objecten met de waarden -128 tot 127 zijn onveranderlijk (dat wil zeggen, voor één bepaalde gehele waarde, laten we zeggen 23, alle Integer objecten geconcretiseerd via uw programma met de waarde van 23 punten op de exact hetzelfde object).

Bijvoorbeeld, deze geeft true:

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

Hoewel deze false:

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

De == vergelijkt referentie (doet de variabelen verwijzen naar hetzelfde object).

Dit resultaat kan wel of niet verschillen, afhankelijk van wat JVM die u gebruikt. De specificatie autoboxing voor Java 1.5 vereist dat integers (-128 tot 127) steeds doos dezelfde wrapper object.

Een oplossing? =) Men dient altijd de Integer.equals () methode bij het vergelijken Integer objecten.

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

Meer info op java.net Voorbeeld bij bexhuff.com

antwoordde op 05/08/2008 om 21:49
bron van user

stemmen
17

In Java zijn er twee basistypen in de JVM . 1) Primitieve types en 2) Reference Types. int is een primitieve en Integer is een type klasse (die een soort verwijzingstype).

Primitieve waarden niet staat te delen met andere primitieve waarden. Een variabele met type een primitieve heeft altijd een primitieve waarde van dit soort.

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

Een object is een dynamisch gecreëerde klasse-instantie of een array. De referentiewaarden (vaak alleen referenties) zijn verwijzingen naar deze doelstellingen en een speciale nul referentie, dat betrekking heeft op geen rol. Er kunnen vele verwijzingen naar hetzelfde object.

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

Ook in Java is alles voorbij waarde. Met voorwerpen de waarde die wordt doorgegeven is de verwijzing naar het object. Dus een ander verschil tussen int en Integer in java is hoe ze worden doorgegeven in methode gesprekken. Bijvoorbeeld

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

De variabele twee wordt doorgegeven als de oorspronkelijke integer 2. Overwegende

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 variabele twee wordt doorgegeven als een verwijzing naar een object dat de gehele waarde 2 bezit.


@WolfmanDragon: Pass aan de hand zou werken als volgt:

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

Wanneer increment wordt langs een referentie (pointer) variabele a . En de increment functie direct wijzigt variabele a .

En voor object types zou het als volgt te werk:

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

Zie je nu het verschil?

antwoordde op 06/08/2008 om 12:08
bron van user

stemmen
6

Nog een ding dat ik zie niet in eerdere antwoorden: In Java de primitieve wrappers klassen zoals Integer, Double, Float, Boolean ... en String zijn suposed invariant te zijn, zodat wanneer u een exemplaar van deze klassen passeren de ingeroepen methode kan je gegevens niet wijzigen op enigerlei wijze, in Oposition met de meeste andere klassen, welke interne gegevens kunnen worden veranderd door de openbare methoden. Zodat deze klassen slechts 'getter' methoden, nee 'setters', naast de constructeur.

In een java programma letterlijke tekenreeksen opgeslagen in een apart gedeelte van heapgeheugen, maar een voorbeeld voor letterlijke om geheugenruimte te sparen hergebruik die gevallen

antwoordde op 06/08/2008 om 15:33
bron van user

stemmen
8

In platforms zoals Java, ints zijn primitieven terwijl Integereen object dat een integerveld bezit. Het belangrijkste verschil is dat primitieven altijd rond zijn waarde doorgegeven en per definitie zijn onveranderlijk.

Elke operatie waarbij een primitieve variabele geeft altijd een nieuwe waarde. Anderzijds worden objecten rondgestuurd referentie. Men zou kunnen zeggen dat het punt op het voorwerp (AKA het referentie) wordt ook rond voorbij waarde, maar de inhoud niet.

antwoordde op 31/01/2009 om 03:49
bron van user

stemmen
7

int wordt gebruikt primitieve variabele declareert

e.g. int i=10;

Integer wordt gebruikt om de gewenste waarde van de klasse Integer creëren

Integer a = new Integer();
antwoordde op 11/12/2011 om 08:19
bron van user

stemmen
6

heb je ooit eerder dan geprogrammeerd (int) is één van de primitieve die u kunt instellen voor uw variabelen (net als char, vlotter, ...).

maar Integer is een wrapper klasse die je kunt gebruiken om bepaalde functies uit te voeren op een int variabele (bijvoorbeeld converteren naar een string of vise versa, ...), maar houd er rekening mee dat de methoden in de wrapper klassen zijn statisch, zodat u ze kunt gebruiken op elk moment zonder dat een instantie van Integer klasse. als een samenvatting:

int x;
Integer y; 

x en y zijn beide variabelen van het type int, maar y is verpakt door een Integer klasse en heeft een aantal methoden die u kunt gebruiken, maar ik geval u enkele functies van Integer wrapper klasse noemen kun je het gewoon doen.

Integer.toString(x);

maar wees ervan bewust dat zowel x en y corect maar als je ze wilt gebruiken net als een primitief soort, gebruik dan de eenvoudige vorm (gebruikt voor het definiëren van x).

antwoordde op 17/05/2014 om 12:56
bron van user

stemmen
4

In beide talen (Java en C #) intis 4-byte signed integer.

In tegenstelling tot Java, C # Biedt zowel ondertekend en unsigned integer waarden. Als Java en C # zijn object object-oriented, sommige operaties in deze talen niet direct in kaart op instructies van de looptijd en dus moet worden gedefinieerd als deel van een object van een bepaald type.

C # verschaft System.Int32die een waarde in met behulp van een deel van het geheugen dat behoort tot de referentie-type op de heap.

Java verschaft java.lang.Integerdie een verwijzingstype die op int. De werkwijzen Integerkunnen niet direct worden gecompileerd tot tijd draaien instructions.So we een doos int waarde om te zetten in een geval van Integer en gebruiken de werkwijzen die bijvoorbeeld verwacht van een soort (zoals toString(), parseInt(), valueOf()etc).

In C # verwijst variabele int System.Int32.Any4-byte waarde geheugen kan worden geïnterpreteerd als een primitieve int, die kan worden gemanipuleerd door exemplaar van System.Int32.So int is een alias voor System.Int32.Whengebruik integer-gerelateerde methoden zoals int.Parse(), int.ToString()is enz Integer gecompileerd in de FCL System.Int32struct het aanroepen van de respectieve methoden zoals Int32.Parse(), Int32.ToString().

antwoordde op 17/07/2014 om 07:02
bron van user

stemmen
8

Er zijn vele redenen om wrapper klassen:

  1. We krijgen extra gedrag (bijvoorbeeld kunnen we methodes te gebruiken)
  2. We kunnen null-waarden, terwijl op te slaan in primitieven kunnen we niet
  3. Verzamelingen ondersteunen opslaan objecten en niet primitieven.
antwoordde op 31/07/2014 om 11:07
bron van user

stemmen
4

Een int en Integer in Java en C # zijn twee verschillende termen die worden gebruikt om verschillende dingen te vertegenwoordigen. Het is één van de primitieve gegevenstypen die een variabele die exact kan opgeslagen worden toegewezen. Een waarde van de gedeclareerde type tegelijk.

Bijvoorbeeld:

int number = 7;

Waar intis het datatype toegewezen aan de variabele getal dat de waarde zeven houdt. Dus een intis gewoon een primitief geen object.

Terwijl een Integeris een wrapper klasse voor een primitief soort gegevens die statische methoden heeft. Die kunnen worden gebruikt als argument een werkwijze waarin een object, waarbij int kan worden gebruikt als een argument van een werkwijze waarbij een gehele waarde, die kan worden gebruikt voor rekenkundige expressie vereist vereist.

Bijvoorbeeld:

Integer number = new Integer(5);
antwoordde op 07/08/2014 om 11:50
bron van user

stemmen
3

Een int variabele bevat een 32 bits geheel getal met waarde. Een Integer (kapitaal I) bevat een verwijzing naar een doel (klasse) type Integer of op nul.

Java werpt automatisch tussen de twee; van Integer int wanneer de Integer object optreedt als argument voor een int operator of is toegewezen aan een int variabele, of een int waarde wordt toegewezen aan een integer variabele. Deze casting heet boksen / unboxing.

Als een Integer variabele referencing null is unboxed, expliciet of impliciet, wordt een NullPointerException gegooid.

antwoordde op 26/11/2015 om 10:54
bron van user

stemmen
3

In Java int is een primitief datatype terwijl Integer is een Helper klasse, is het te gebruiken om te zetten voor een bepaald type gegevens naar andere.

Bijvoorbeeld:

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

Primitieve types gegevens op te slaan de snelste beschikbare geheugen waar de Helper klasse is complex en op te slaan in heep geheugen.

verwijzing van "David Gassner" Java Essential Training.

antwoordde op 28/02/2016 om 18:42
bron van user

stemmen
7

Java:

int, double, long, byte, float, double, short, boolean, char- primitieven. Gebruikt voor het ruim van het basisgegevens types ondersteund door de taal. de primitieve types maken geen deel uit van het object hiërarchie, en ze niet erven Object. Thet can'be langs hand van een methode.

Double, Float, Long, Integer, Short, Byte, CharacterEn Booleanzijn soort wrappers, verpakt java.lang. Alle numeriek wrappers bouwers definiëren waarmee een voorwerp wordt vervaardigd uit een gegeven waarde of een reeks representatie van die waarde. Met behulp van objecten kunnen een overhead toe te voegen aan de eenvoudigste van de berekeningen gelijk te.

Te beginnen met JDK 5, heeft Java inclusief twee zeer handige functies: autoboxing en autounboxing. Autoboxing / unboxing vereenvoudigt en stroomlijnt code die primitieve moet omzetten in objecten, en vice versa.

Voorbeeld constructors:

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

Voorbeeld dozen / 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
    }
}

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

boek PS Herbert Schildt werd als referentie genomen.

antwoordde op 13/06/2016 om 19:31
bron van user

stemmen
0

In java als per mijn kennis als je lerende dan, als je schrijft int a; dan in java generieke zal code zoals integer a = new integer samen te stellen. Dus, zoals per generieke integer wordt niet gebruikt, maar int wordt gebruikt. dus er is dus dit verschil zijn.

antwoordde op 22/09/2016 om 09:53
bron van user

stemmen
1

int wordt vooraf gedefinieerd in de bibliotheek functie C #, maar in Java kunnen we oject van Integer creëren

antwoordde op 06/03/2017 om 05:08
bron van user

stemmen
4

Op Java, het inttype een primitief gegevenstype, waarbij de Integertype een object.

In C #, het inttype een gegevenstype gelijk System.Int32. Een integer(net als elke andere cijfers) moeten verpakt ( "ingepakt") in een object.

antwoordde op 27/04/2017 om 07:25
bron van user

stemmen
1

"Int" primitief is data-type en "Integer" in Wrapper klasse in Java. "Integer" kan worden gebruikt als een argument van een werkwijze waarin een object, waarbij de "int" kan worden gebruikt als een argument van een werkwijze waarbij een gehele waarde, die kan worden gebruikt voor rekenkundige expressie vereist vereist.

antwoordde op 04/08/2017 om 09:57
bron van user

stemmen
0

(Java Version) in eenvoudige woorden int is primitief en Integer is wrapper object voor int.

Een voorbeeld waar te Integer gebruiken vs int, Wanneer u wilt vergelijken en int variabele weer null zal het fout gooien.

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...}
antwoordde op 15/02/2018 om 21:04
bron van user

stemmen
0

01. Integer kan null zijn. Maar int kan niet null zijn.

Integer value1 = null; //OK

int value2 = null      //Error

02. Alleen kan passeren Wrapper klassen soort waarden op de collectie klasse.

(Wrapper klassen - Boolean, Character, Byte, kort, Integer, Lang, Float, Double)

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

Maar normaal gesproken voegen we primitieve waarden collectie klasse? Is punt 02 correct?

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

Ja 02 correct is, beacouse autoboxing.

Autoboxing is de automatische conversie dat de Java-compiler maakt tussen de primitieve en de bijbehorende wrapperklasse.

Dan 5 bekeerling als Integer waarde autoboxing.

antwoordde op 05/06/2018 om 11:35
bron van user

stemmen
3

int is een primitief gegevenstype. Integer is een wrapper klasse. Het kan int gegevens als objecten.

antwoordde op 03/06/2019 om 10:01
bron van user

stemmen
0

int is een primitieve datatype dat Integer een object. Het creëren van een object met Integer heeft u toegang tot alle methoden die beschikbaar zijn in de klasse Integer geven. Maar, als je een primitief datatype met int maken, zult u niet in staat zijn om die inbuild methoden te gebruiken en je hebt om ze te definiëren door uzelf. Maar als je geen andere methoden en willen het programma meer geheugen efficiënter te maken, kun je gaan met primitieve datatype omdat het creëren van een object het geheugengebruik zal toenemen.

antwoordde op 03/07/2019 om 08:35
bron van user

stemmen
0

Waar is het type 'integer' in C #? Kan iemand me helpen om het te vinden in C #?

antwoordde op 20/08/2019 om 12:52
bron van user

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more