streamalism.org

1. Inleiding

Java is een getypte taal, wat betekent dat het het concept van typen gebruikt. Er zijn twee verschillende typen groepen:

1. primitieve gegevenstypen
2. abstracte gegevenstypen.

In dit artikel zullen we ons concentreren op conversies van primitieve typen.

2. Overzicht van primitieven

Het eerste dat we moeten weten, is wat voor soort waarden kunnen worden gebruikt met primitieve typen. Er zijn acht primitieve typen die zijn:

• byte - 8 bits en gesigneerd

• kort - 16 bits en gesigneerd

• char - 16 bits en ongetekend, zodat het Unicode-tekens kan vertegenwoordigen

• int - 32 bits en gesigneerd

• lang - 64 bits en gesigneerd

• vlotter - 32 bits en gesigneerd

• dubbele - 64 bits en gesigneerd

• boolean - het is niet numeriek, alleen mogelijk waar of false waarden

Dit is niet bedoeld als een uitgebreide discussie over primitieven en we zullen wat meer over hun details praten als dat nodig is tijdens de conversies.

3. Verbreding van primitieve conversies

Wanneer we moeten converteren van een primitief die eenvoudiger of kleiner is dan het bestemmingstype, hoeven we daarvoor geen speciale notatie te gebruiken:

int myInt = 127; lang myLong = myInt;

Bij verbredende conversie wordt de kleinere primitieve waarde over een grotere container geplaatst, wat betekent dat alle extra ruimte, links van de waarde, wordt gevuld met nullen. Dit kan ook worden gebruikt om van de integer-groep naar de drijvende komma te gaan:

zweven myFloat = myLong; dubbel myDouble = myLong;

Dit is mogelijk omdat bij het verhuizen naar een bredere primitief geen informatie verloren gaat.

4. Beperking van primitieve conversie

Soms moeten we een waarde passen die groter is dan het type dat in de variabeledeclaratie wordt gebruikt. Dit kan leiden tot informatieverlies aangezien sommige bytes moeten worden verwijderd.

In dit geval moeten we expliciet aangeven dat we op de hoogte zijn van de situatie en daarmee akkoord gaan, door een cast te gebruiken:

int myInt = (int) myDouble; byte myByte = (byte) myInt;

5. Verbreding en versmalling van primitieve conversie

Deze situatie doet zich voor in een heel specifiek geval wanneer we willen converteren van een byte naar een char. De eerste conversie is de verbreding van de byte naar int en vervolgens van de int het is teruggebracht tot char.

Een voorbeeld zal dit punt verduidelijken:

byte myLargeValueByte = (byte) 130; // 0b10000010 -126

De binaire weergave van 130 is hetzelfde voor -126, het verschil is de interpretatie van het signaalbit. Laten we nu converteren van byte naar char:

char myLargeValueChar = (char) myLargeValueByte; // 0b11111111 10000010 niet-ondertekende waarde int myLargeValueInt = myLargeValueChar; // 0b11111111 10000010 65410

De char representatie is een Unicode-waarde, maar wordt geconverteerd naar een int toonde ons een zeer grote waarde die de onderste 8 bits precies hetzelfde heeft als -126.

Als we het opnieuw converteren naar byte we krijgen:

byte myOtherByte = (byte) myLargeValueInt; // 0b10000010 -126

De oorspronkelijke waarde die we hebben gebruikt. Als de hele code begon met een char de waarden zullen verschillen:

char myLargeValueChar2 = 130; // Dit is een int, geen byte! // 0b 00000000 10000010 niet-ondertekende waarde int myLargeValueInt2 = myLargeValueChar2; // 0b00000000 10000010130 byte myOtherByte2 = (byte) myLargeValueInt2; // 0b10000010 -126

Hoewel de byte vertegenwoordiging is hetzelfde, namelijk -126, de char representatie geeft ons twee verschillende karakters.

6. Conversie in dozen doen / uitpakken

In Java hebben we een Wrapper Class voor elk primitief type, dit is een slimme manier om programmeurs nuttige verwerkingsmethoden te bieden, zonder de overhead van alles als een zware objectreferentie. Sinds Java 1.5 is de mogelijkheid om automatisch van / naar een primitief naar een object en terug te converteren opgenomen en dit wordt bereikt door eenvoudige attributie:

Geheel getal myIntegerReference = myInt; int myOtherInt = myIntegerReference;

7. String-conversies

Alle primitieve typen kunnen worden omgezet naar Draad via hun Wrapper Classes, die de toString () methode:

String myString = myIntegerReference.toString ();

Als we terug moeten naar een primitief type, moeten we een parse-methode gebruiken die is gedefinieerd door de overeenkomstige Wrapper-klasse:

byte myNewByte = Byte.parseByte (myString); short myNewShort = Short.parseShort (myString); int myNewInt = Geheel getal.parseInt (myString); long myNewLong = Long.parseLong (myString); zweven myNewFloat = Float.parseFloat (myString); double myNewDouble = Double.parseDouble (myString); 

boolean myNewBoolean = Boolean.parseBoolean (myString);

De enige uitzondering hierop is de Karakter Klasse omdat a Draad is gemaakt van chars hoe dan ook, op deze manier, gezien het feit dat waarschijnlijk de Draad is gemaakt van een enkele char, kunnen we de karakter () methode van de Draad klasse:

char myNewChar = myString.charAt (0);

8. Numerieke promoties

Om een ​​binaire bewerking uit te voeren, is het noodzakelijk dat beide operanden qua grootte compatibel zijn.

Er zijn een aantal eenvoudige regels die van toepassing zijn:

1. Als een van de operanden een dubbele, de andere wordt gepromoveerd tot dubbele
2. Anders, als een van de operanden een vlotter, de andere wordt gepromoveerd tot vlotter
3. Anders, als een van de operanden een lang, de andere wordt gepromoveerd tot lang
4. Anders worden beide overwogen int

Laten we een voorbeeld bekijken:

byte op1 = 4; byte op2 = 5; byte myResultingByte = (byte) (op1 + op2);

Beide operanden werden gepromoveerd tot int en het resultaat moet terneergeslagen zijn byte opnieuw.

9. Conclusie

Conversie tussen typen is een veel voorkomende taak bij dagelijkse programmeeractiviteiten. Er is een reeks regels die bepalen hoe statisch getypeerde talen deze conversies uitvoeren. Het kennen van deze regels kan veel tijd besparen wanneer u probeert uit te zoeken waarom een ​​bepaalde code compileert of niet.

De code die in dit artikel wordt gebruikt, is te vinden op GitHub.