Laten we een van de manieren bedenken om gegevens uit de standaardstroom via een klasse in te voeren java.util.Scanner... Laten we dit doen aan de hand van het voorbeeld van een eenvoudige taak van de zeer nuttige site e-olimp.com

Taak

Voer één nummer uit de standaardstream in. Ervan uitgaande dat dit een positief geheel getal van twee cijfers is, drukt u elk cijfer afzonderlijk af (gescheiden door een spatie) naar de standaarduitvoerstroom. De volgorde van de nummers mag niet worden gewijzigd.

testen

In het algoritme worden geen specifieke gevallen verondersteld. We doen drie tests: het kleinste getal van het geldige bereik, het grootste en een waarde uit het midden van het bereik.

Ingang	Uitgang
10	1 0
99	9 9
54	5 4

Oplossing

Laten we de klas gebruiken java.util.Scanner, om gegevens in geheel getal in te voeren. En laten we beide getallen berekenen.

De cijfers van een tweecijferig geheel getal weergeven

Java

class Main (public static void main (String args) gooit java.lang.Exception (java.util.Scanner i = new java.util.Scanner (System.in); int n = i.nextInt (); System.out. println (n / 10 + "" + n% 10);))

klasse Hoofd ( public static void main (String args) gooit java. lang. Uitzondering ( Java. gebruik. Scanner i = nieuwe java. gebruik. Scanner (Systeem In); int n = ik. volgendeInt (); Systeem. uit. println (n / 10 + "" + n% 10);

uitleg

1. We beschrijven de variabele I type java.util.Scanner en wijs het onmiddellijk de waarde toe van een nieuw object van deze klasse. De constructor maakt het object Scanner‘Maar van stdin. Die. I wordt een aanvulling op de standaardinvoer. Hierdoor kunnen we een geheel getal lezen en niet alleen lezen met de methode lezen() één byte per keer.
2. De methode gebruiken volgendeInt() lees een reeks getallen en converteer deze naar een geheel getal. We slaan het getal op in de variabele n.
3. N/ 10 - het aantal tientallen in het getal. De tientallen zijn tien keer kleiner dan het getal zelf. Gehele deling wordt uitgevoerd - gehele deling.
4. N% 10 - bereken de rest van deling door tien - het aantal enen - het meest rechtse cijfer van het getal.
5. N/ 10 + "" + N% 10 - voeg een enkele spatie in tussen twee gehele getallen. In dit geval worden de getallen ook geconverteerd naar tekenreeksweergave en worden alle drie de tekenreeksen aaneengeschakeld - dit wordt tekenreeksaaneenschakeling genoemd. Dit is hoe de "+"-bewerking werkt met stringgegevens.

Versnel I / O

Met al het gemak van deze aanpak is het nogal traag en soms worden taken niet op tijd uitgevoerd. U kunt het werk aanzienlijk versnellen door StreamTokenizer en PrintWriter te gebruiken.
Dit zal de hoeveelheid code verhogen, maar het zal tijd besparen.

I / O . versnellen

Java

java.io importeren *; import java.util.*; class Main (static StreamTokenizer in = nieuwe StreamTokenizer (nieuwe BufferedReader (nieuwe InputStreamReader (System.in))); static PrintWriter out = nieuwe PrintWriter (System.out); static int nextInt () gooit IOException (in.nextToken (); return (int) in.nval;) public static void main (String args) gooit java.lang.Exception (int n = nextInt (); out.println (n / 10 + "" + n% 10); out.flush ( ;))

java importeren. io. *; java importeren. gebruik. *; klasse Hoofd ( statische StreamTokenizer in = nieuwe StreamTokenizer (nieuwe BufferedReader (nieuwe InputStreamReader (System. in))); statische PrintWriter uit = nieuwe PrintWriter (Systeem. uit); static int nextInt () gooit IOException (

Studeren als "Game Developer" + werk

Java-operators

De Java-taal gebruikt de gebruikelijke + - * / rekenkundige operatoren om optellen, aftrekken, vermenigvuldigen en delen aan te duiden.

De operator / geeft deling van gehele getallen aan als beide argumenten gehele getallen zijn. Anders geeft deze operator een deling met drijvende komma aan. De rest van de deling van gehele getallen (d.w.z. de mod-functie) wordt aangegeven met het% -symbool.
15/2 is bijvoorbeeld 7, 15% 2 is 1 en 15. 0/2 is gelijk aan 7. 5.

Merk op dat deling door 0 een uitzondering veroorzaakt, terwijl deling door 0 van getallen met drijvende komma resulteert in oneindig of NaN.

Rekenkundige operatoren kunnen worden gebruikt om variabelen te initialiseren.

int n = 5;
int a = 2 *N; // De waarde van de variabele a is 10.

Het is handig om verkorte binaire rekenkundige operatoren te gebruiken in toewijzingsoperatoren.

Bijvoorbeeld, de operator
x + = 4;
gelijk aan operator
x = x + 4;

(Verkorte toewijzingsoperatoren worden gevormd door een teken voor een rekenkundige bewerking, zoals * of%, vóór het teken = te plaatsen, zoals * = of% =.)

Een van de gestelde doelen van de Java-taal is machine-onafhankelijkheid.

De berekeningen zouden tot hetzelfde resultaat moeten leiden, ongeacht op welke virtuele machine ze worden uitgevoerd. Voor rekenen met drijvende komma is dit verrassend moeilijk. Het dubbele type gebruikt 64 bits om numerieke waarden op te slaan, maar sommige processors gebruiken 80-bits drijvende-kommaregisters. Deze registers bieden extra precisie in tussenstadia van de berekening. Laten we de volgende uitdrukking als voorbeeld nemen:

dubbele w = x * y / z;

Veel Intel-processors evalueren de uitdrukking x * y en slaan dit tussenresultaat op in een 80-bits register, delen het vervolgens door de waarde van z en ronden het antwoord helemaal af op 64 bits. Dit kan de nauwkeurigheid van de berekeningen verbeteren en overlopen voorkomen. Dit resultaat kan echter anders zijn als bij alle berekeningen een 64-bits processor wordt gebruikt.

Om deze reden stelde de oorspronkelijke Java Virtual Machine-specificatie dat alle tussentijdse berekeningen moeten worden afgerond. Dit irriteerde de computergemeenschap. Het zijn niet alleen afgeronde berekeningen die overflows kunnen veroorzaken. In feite zijn ze langzamer dan nauwkeurigere berekeningen omdat afrondingsbewerkingen een bepaalde tijd in beslag nemen. Als gevolg hiervan veranderden de ontwikkelaars van de Java-taal van gedachten en probeerden ze het conflict tussen optimale prestaties en uitstekende reproduceerbaarheid van resultaten op te lossen.

Ontwikkelaars van virtuele machines staan ​​nu standaard grotere precisie toe bij tussentijdse berekeningen. Methoden die zijn gemarkeerd met het trefwoord strictfp moeten echter nauwkeurige drijvende-kommabewerkingen gebruiken om reproduceerbare resultaten te garanderen. De hoofdmethode kan bijvoorbeeld worden getagd met trefwoorden, zoals hieronder weergegeven:
public static strictfp void main (String args)

In dit geval voeren alle opdrachten binnen de hoofdmethode exacte bewerkingen uit op getallen met drijvende komma.

De details van deze operaties hangen nauw samen met de manier waarop Intel-processors werken. Standaard kunnen tussenresultaten de uitgebreide metriek gebruiken, maar niet de uitgebreide mantisse. (Intel-chips ondersteunen het afronden van de mantisse zonder in te boeten aan prestaties.) Daarom is het enige verschil tussen standaardberekening en exacte berekening dat nauwkeurige berekening kan overlopen, terwijl standaardberekening dat niet doet.

Maak je geen zorgen als je blik vervaagt tijdens het lezen van deze notitie. Voor de meeste programmeurs is deze vraag volkomen irrelevant. Floating point overflows komen in de meeste gevallen niet voor. In dit boek zullen we het trefwoord strictfp niet gebruiken.

Verhogen en verlagen operators

Programmeurs weten natuurlijk dat een van de meest voorkomende bewerkingen op numerieke variabelen het optellen of aftrekken is. In de Java-taal, net als in de C- en C++-talen, zijn er increment- en decrement-operators: de x++-operator voegt één toe aan de huidige waarde van de x-variabele, en de x- operator trekt er één van af.

Bijvoorbeeld de code
int n = 12;
n++;
maakt de waarde van de variabele n gelijk aan 13.

Omdat deze operators de waarde van een variabele wijzigen, kunnen ze niet op de getallen zelf worden toegepast. De operator 4++ is bijvoorbeeld niet geldig.

Er zijn twee soorten van deze operators. Het bovenstaande toont de "postfix"-vorm van de operator, waarin de operatortekens achter de operand worden geplaatst. Er is ook een "prefix" -vorm - ++ n.
Beide operatoren verhogen de waarde van de variabele met één. Het verschil tussen de twee wordt alleen zichtbaar wanneer deze operators in expressies worden gebruikt. De prefixvorm van de incrementoperator voegt er eerst één toe aan de waarde van een variabele, terwijl de postfixvorm de oude waarde van die variabele gebruikt.

intm = 7;
int n = 7;
int a = 2 * ++ m; // Nu is a 16 en m is 8.
int b = 2 * n ++; // Nu is b 14 en n is 8.

(Aangezien het de ++-operator was die de naam aan de C ++-taal gaf, was dit de reden voor de eerste grap erover. Slechtgezinden wijzen erop dat zelfs de naam van deze taal een fout bevat: "Onder andere , deze taal zou ++ C moeten heten, omdat we deze taal pas willen gebruiken na verbetering ervan. ")

1. Basis rekenkundige bewerkingen

De volgende tabel geeft een overzicht van de rekenkundige basisbewerkingen die in de Java-taal worden gebruikt:

Laten we eens kijken naar enkele regels voor het werken met rekenkundige bewerkingen:

• Expressies worden van links naar rechts geëvalueerd, tenzij haakjes worden toegevoegd of bepaalde bewerkingen voorrang hebben.
• De bewerkingen *, / en% hebben voorrang op + en -.

Voorbeeld 1. Rekenkundige bewerkingen op gehele waarden

In deze code zijn bijvoorbeeld de variabelen een en B zal verschillende betekenissen hebben:

Public class BasicIntMath (public static void main (String args) (int a = 4 + 5 - 2 * 3; int b = 4 + (5 - 2) * 3; System.out.println ("a =" + a) ; Systeem.uit.println ("b =" + b);))

Uitvoering resultaat:

A = 3 b = 13

• De unaire aftrekbewerking verandert het teken van zijn enige operand.
• Een unaire optelbewerking retourneert eenvoudig de waarde van zijn operand. Het is in principe niet nodig, maar mogelijk.

Voorbeeld 2. Unaire optellen en aftrekken

public class UnarySignOperation (public static void main (String args) (double a = -6; double b = +6; System.out.println (a); System.out.println (b);))

• Wanneer een delingsbewerking wordt uitgevoerd op een gegevenstype met een geheel getal, bevat het resultaat geen fractionele component.

Voorbeeld 3. Deling van gehele getallen

public class IntDivision (public static void main (String args) (int a = 16/5; System.out.println (a);))

Het resultaat van het uitvoeren van dit programma:

• De operanden voor rekenkundige bewerkingen moeten van het numerieke type zijn. Rekenkundige bewerkingen kunnen niet worden uitgevoerd op booleaanse gegevenstypen, maar kunnen worden uitgevoerd op gegevenstypen char aangezien dit type in Java in wezen een variatie op het type is int.

Voorbeeld 4. Rekenkundige bewerkingen op typevariabelen char

public class BasicCharMath1 (public static void main (String args) (char c = "n"; System.out.println (c); System.out.println (c + 1); System.out.println (c / 5) ;))

Uitvoering resultaat:

N 111 22

Voorbeeld 5. Rekenkundige bewerkingen op typevariabelen char

public class BasicCharMath2 (public static void main (String args) (char c1 = "1"; char c2 = "\ u0031"; char c3 = 49; System.out.println (c1 + c2 + c3);))

Uitvoering resultaat:

Modulo-operator - aangegeven met%. Deze operator retourneert de rest van het eerste getal gedeeld door het tweede. Bij het delen van een geheel getal is het resultaat ook een geheel getal.

Voorbeeld 6. Modulo-verdeling

public class DivisionByModule (public static void main (String args) (int a = 6% 5; double b = 6,2% 5.0; System.out.println (a); System.out.println (b);))

Uitvoering resultaat:

1 1.2000000000000002

2. Samengestelde rekenkundige bewerkingen met toewijzing

Java heeft speciale bewerkingen die rekenen combineren met toewijzing. Beschouw de volgende uitdrukking:

A = een + 4;

In Java kan deze bewerking als volgt worden geschreven:

EEN + = 4;

Met samengestelde toewijzingsbewerkingen kunt u niet alleen de hoeveelheid code verminderen, maar kunt u ook automatische conversie uitvoeren, wat niet wordt gedaan door conventionele bewerkingen.

Voorbeeld 5. Samengestelde rekenkundige toewijzingsbewerkingen

public class CompoundOperations (public static void main (String args) (int a = 1; int b = 2; int c = 3; a + = 3; b * = 2; c + = a * b; System.out.println (a); Systeem.uit.println (b); Systeem.uit.println (c);))

De meeste bewerkingen op primitieve typen worden niet uitgevoerd met behulp van methoden, maar met speciale tekens die worden genoemd operatie teken.

Toewijzingsbewerking

Het toewijzen aan een variabele de waarde van een constante, een andere variabele of een uitdrukking (variabelen en/of constanten gescheiden door bewerkingstekens) wordt genoemd opdracht operatie en wordt aangegeven door het teken " = ", bijvoorbeeld: x = 3; y = x; z = x; In Java is het mogelijk om de toewijzingsbewerking in één uitdrukking opnieuw te gebruiken, bijvoorbeeld: x1 = x2 = x3 = 0; Deze bewerking wordt van rechts naar links, dat wil zeggen dat eerst aan de variabele x3 de waarde 0 wordt toegekend, vervolgens aan de variabele x2 de waarde van de variabele x3 (0) en tenslotte aan de variabele x1 de waarde van de variabele x2 (0). tekens van operaties waarvan de argumenten getallen zijn, vallen in twee categorieën: unair(unaire) tokens voor bewerkingen met één argument en binair(binair) met twee argumenten.

Unaire operaties

De volgende unaire bewerkingen zijn gedefinieerd in Java:

• unaire min "-" - verandert het teken van een getal of uitdrukking in het tegenovergestelde;
• unair plus "+" - voert geen actie uit op een getal of uitdrukking;
• bitsgewijze aanvulling "~" (alleen voor gehele getallen) - keert alle bits van het getalveld om (verandert 0 in 1 en 1 in 0);
• increment "++" (alleen voor gehele getallen) - verhoogt de waarde van de variabele met 1;
• decrement "-" (alleen voor gehele getallen) - verlaagt de waarde van de variabele met 1.

Voorbeelden van unaire bewerkingen "+" en "-": int i = 3, j, k; j = - ik; // j = -3 k = + ik; // k = 3 Een voorbeeld van een bitsgewijze complementbewerking: int a = 15; int b; b = ~ een; // b = -16 Getallen a en b zijn int, d.w.z. worden intern weergegeven als binair getekende gehele getallen met een lengte van 32 bits, dus de binaire weergave van de getallen a en b ziet er als volgt uit: a = 00000000 00000000 00000000 00001111 b = 11111111 11111111 11111111 11110000 Zoals je aan deze weergave kunt zien, nul bits in het getal a zijn veranderd in die in b, en die in a zijn veranderd in nul bits. De decimale weergave van b is –16. De tekens voor het verhogen en verlagen van de bewerking kunnen voor of na de variabele worden geplaatst. Deze opties worden dienovereenkomstig genoemd voorvoegsel en postfix door deze handelingen vast te leggen. Het operatorteken in de prefixnotatie retourneert de waarde van zijn operand na het evalueren van een uitdrukking. Voor postfix-notatie is het bewerkingsteken eerst geeft de waarde van zijn operand terug en berekent pas daarna de toename of afname, bijvoorbeeld: int x = 1, y, z; y = ++ x; z = x ++; De variabele y krijgt de waarde 2 toegewezen, omdat eerst de waarde van x met 1 wordt verhoogd en vervolgens het resultaat wordt toegewezen aan de variabele y. De variabele z krijgt de waarde 1, omdat eerst de variabele z een waarde krijgt en daarna de waarde van x met 1. In beide gevallen is de nieuwe waarde van x 2. Opgemerkt moet worden dat in Java, in tegenstelling tot in C, de decrement- en increment-bewerkingen ook kunnen worden toegepast op reële variabelen (van de typen float en double). Tekens voor binaire bewerkingen zijn onderverdeeld in bewerkingen met een numeriek resultaat en vergelijkingsbewerkingen, waarvan het resultaat een booleaanse waarde is.

Rekenkundige binaire bewerkingen

Java definieert het volgende: rekenkundige binaire bewerkingen:

• toevoeging "+";
• aftrekken "-";
• vermenigvuldiging " * ";
• divisie "/";
• het berekenen van de rest van het delen van gehele getallen "%" (retourneert de rest van het delen van het eerste getal door het tweede, en het resultaat zal hetzelfde teken hebben als het deeltal), bijvoorbeeld, het resultaat van bewerking 5% 3 zal 2 zijn, en het resultaat van bewerking (-7) % (- 4) zal -3 zijn. In Java kan de bewerking ook worden gebruikt voor echte variabelen (zoals float of double).

Voorbeelden van binaire rekenkundige bewerkingen: int x = 7, x1, x2, x3, x4, x5; x1 = x + 10; // x1 = 17 x2 = x - 8; // x2 = -1 x3 = x2 * x; // x3 = -7 x4 = x / 4; // x4 = 1 (bij het delen van gehele getallen // fractioneel deel wordt weggegooid) x5 = x% 4 // x5 = 3 (rest van deling// 7 bij 4)

Bitsgewijze bewerkingen

• Bitsgewijze bewerkingen behandelen de oorspronkelijke numerieke waarden als bitvelden en doen er het volgende op:
• het bit instellen op I-de positie van het resultaatveld naar 1, als beide bits in . zijn I-de posities van de operanden zijn gelijk aan 1, of aan 0, anders - bitsgewijze AND ("&");
• het bit instellen op I-de positie van het resultaatveld naar 1, indien ten minste één bit in I-de positie van de operanden is gelijk aan 1, of aan 0, anders - bitsgewijze OR ("|");
• het bit instellen op I-de positie van het resultaatveld naar 1, als de bits in I-de posities van de operanden zijn niet gelijk aan elkaar, of aan 0, anders - bitsgewijze exclusieve OR ("^");
• linkerverschuiving van de bits van het veld van de eerste operand door het aantal bits bepaald door de tweede operand (het tekenbit van het getal verandert in dit geval niet) - bitsgewijze verschuiving naar links, rekening houdend met het teken "<< ";
• verschuiving naar rechts van de bits van het veld van de eerste operand met het aantal bits bepaald door de tweede operand (het tekenbit van het getal verandert in dit geval niet) - bitsgewijze verschuiving naar rechts, rekening houdend met de " >>" teken;
• naar rechts verschuiven van de bits van het veld van de eerste operand met het aantal bits bepaald door de tweede operand (de tekenbit van het getal wordt in dit geval ook verschoven) - bitsgewijs naar rechts verschuiven zonder rekening te houden met de " >>>" teken.

Voorbeelden van bitsgewijze bewerkingen:

1. Bitgewijs EN

   intx = 112; int y = 94; int z; z = x & y; // z = 80: 00000000 00000000 00000000 01010000

2. Bitgewijs OF

   intx = 112; // x: 00000000 00000000 00000000 01110000 int y = 94; // j: 00000000 00000000 00000000 01011110 int z; z = x | j; // z = 126: 00000000 00000000 00000000 01111110

3. Bitwise exclusief OR

   intx = 112; // x: 00000000 00000000 00000000 01110000 int y = 94; // j: 00000000 00000000 00000000 01011110 int z; z = x ^ y; // z = 46: 00000000 00000000 00000000 00101110

4. Naar links verschuiven, rekening houdend met het bord

   int x = 31, z; // x: 00000000 00000000 00000000 00011111 z = x<< 2 ; // z = 124: 00000000 00000000 00000000 01111100

5. Shift naar rechts, rekening houdend met het bord

   int x = - 17, z; z = x >> 2; // z = -5: 11111111 11111111 11111111 11111011

6. Naar rechts verschuiven zonder rekening te houden met teken

   int x = - 17, z; // x: 11111111 11111111 11111111 11101111 z = x >>> 2; // z = 1073741819 // z: 00111111 11111111 11111111 11111011

Gecombineerde operaties

In Java kunt u voor binaire rekenkundige bewerkingen gecombineerd(samengestelde) bewerkingstokens: identifier bewerking = expressie Dit komt overeen met de volgende bewerking: identifier = identifier bewerking expressie Voorbeelden:

1. De uitdrukking x + = b betekent x = x + b.
2. De uitdrukking x - = b betekent x = x - b.
3. De uitdrukking x * = b betekent x = x * b.
4. De uitdrukking x / = b betekent x = x / b.
5. De uitdrukking x% = b betekent x = x% b.
6. De uitdrukking x & = b betekent x = x & b.
7. De uitdrukking x | = b betekent x = x | B.
8. De uitdrukking x ^ = b betekent x = x ^ b.
9. Uitdrukking x<<= b означает x = x << b .
10. De uitdrukking x >> = b betekent x = x >> b.
11. De uitdrukking x >>> = b betekent x = x >>> b.

Vergelijkingsbewerkingen

Java definieert de volgende vergelijkingsoperatoren:

• "==" (gelijk), "! =" (niet gelijk),
• ">" (groter dan), "> =" (groter of gelijk aan),
• " < " (меньше) " <= " (меньше или равно)

twee operanden hebben en een booleaanse waarde retourneren die overeenkomt met het resultaat van de vergelijking ( vals of waar). Merk op dat bij het vergelijken van twee waarden voor gelijkheid in Java, zoals in C en C ++, de symbolen " == "(twee gelijktekens zonder spatie), in tegenstelling tot de toewijzingsoperator, die de" = ". Het gebruik van het" = "symbool bij het vergelijken van twee waarden veroorzaakt ofwel een compilatiefout of levert een onjuist resultaat op. Voorbeelden van vergelijkingsbewerkingen: boolean is gelijk, is niet gelijk, is groter, is groter of gelijk, is minder, is minder of gelijk; int x1 = 5, x2 = 5, x3 = 3, x4 = 7; isGelijk = x1 == x2; // isEqual = waar isNonEqual = x1! = x2; // isNonEqual = false isGreater = x1> x3; // isGreater = true // isGreaterOrEqual = true isGreaterOrEqual = x2> = x3; isMinder = x3< x1; // isLess = true isLessOrEqual = x1 <= x3; // isLessOrEqual = false

Booleaanse bewerkingen

Booleaanse bewerkingen worden uitgevoerd op booleaanse variabelen en hun resultaat is ook een waarde van het type booleaans... De volgende booleaanse bewerkingen zijn gedefinieerd in Java:

• ontkenning "!" - onwaar vervangen door waar, of omgekeerd;
• AND-bewerking "&" - het resultaat is alleen waar als beide operanden waar zijn, anders is het resultaat onwaar;
• OF-bewerking "|" - het resultaat is alleen waar als ten minste één van de operanden waar is, anders is het resultaat onwaar.
• XOR-bewerking "^" - het resultaat is alleen waar als de operanden niet gelijk zijn aan elkaar, anders is het resultaat onwaar.

De operatoren "&", "|" en "^" kunnen, evenals de overeenkomstige bitsgewijze operatoren, worden gebruikt in samengestelde toewijzingsoperatoren: "& =", "| =" en "^ =" Daarnaast kunnen de bewerkingen " = zijn van toepassing op Booleaanse operanden = "(gelijk) en"! = "(niet gelijk). Zoals je kunt zien aan de hand van de definitie van OR en AND, evalueert de OR-bewerking naar waar als de eerste operand waar is, ongeacht de waarde van de tweede operand, en de operator AND evalueert naar onwaar wanneer de eerste operand onwaar is, ongeacht de waarde van de tweede operand. Java definieert nog twee booleaanse bewerkingen: de tweede versies van de booleaanse AND en OR, ook wel logische kortsluitbewerkingen genoemd: de verkorte AND "&&" en de verkorte OR "||". Bij gebruik van deze bewerkingen wordt de tweede operand helemaal niet geëvalueerd, wat handig is in gevallen waarin de juiste werking van de rechter operand afhangt van of de linker operand waar of onwaar is. Voorbeelden van booleaanse bewerkingen: boolean isInRange, isValid, isNotGalid, isEqual, isNotEqual; intx = 8; isInBereik = x> 0 && x< 5 ; // isInRange = false isValid = x >0 || x> 5; // isValid = waar isNotGalid =! is geldig; // isNotValid = false isEqual = isInRange == isGalid; // isEqual = false // isNotEqual = waar isNotEqual = isInRange! = isValid

Voorwaardelijke werking

Een voorwaardelijke bewerking wordt geschreven in de vorm expression-1?Expression-2: expression-3. In dit geval wordt eerst expressie-1 geëvalueerd, wat een booleaanse waarde zou moeten geven, en als expressie-1 waar is, wordt expressie-2 geëvalueerd en geretourneerd als het resultaat van de bewerking, of (als expressie-1 onwaar is ), en expressie-3 wordt geretourneerd als het resultaat van de bewerking. Een voorbeeld van een voorwaardelijke bewerking: x = n> 1? 0: 1; De variabele x krijgt de waarde 0 als n> 1 (uitdrukking n> 1 levert waar op) of 1 op als n≤1 (uitdrukking n> 1 wordt onwaar).

anciënniteit van operaties

Bewerkingen in uitdrukkingen worden echter van links naar rechts uitgevoerd op basis van hun prioriteit. Dus vermenigvuldigingsbewerkingen in de uitdrukking y = x + z * 5; wordt uitgevoerd vóór de optelbewerking omdat de prioriteit van de vermenigvuldigingsbewerking hoger is dan de prioriteit van de optelbewerking. Bewerkingsprioriteiten (in volgorde van afnemende prioriteit) in Java worden weergegeven in de tabel. een.
Haakjes verhogen de prioriteit van de bewerkingen die erin staan. Dus, als u haakjes invoegt in de bovenstaande uitdrukking: y = (x + z) * 5; dan wordt eerst de optelbewerking uitgevoerd en vervolgens de vermenigvuldigingsbewerking. Soms worden haakjes gebruikt om de uitdrukking leesbaarder te maken, bijvoorbeeld: (x> 1) && (x<= 5 ) ;

Typ conversie en casten bij het uitvoeren van bewerkingen

In toewijzings- en rekenkundige uitdrukkingen kunnen letterlijke waarden, variabelen en uitdrukkingen van verschillende typen worden gebruikt, bijvoorbeeld: dubbel y; byte x; y = x + 5; Dit voorbeeld voegt de bytevariabele x toe aan de letterlijke 5 (int) en wijst het resultaat toe aan de dubbele variabele y. In Java kunnen, net als in de C-taal, typeconversies bij de evaluatie van uitdrukkingen automatisch worden uitgevoerd of met behulp van een cast-operator. De castingregels verschillen echter enigszins van die van de taal C en zijn over het algemeen strenger dan in de taal C. Bij het uitvoeren van een toewijzingsbewerking vindt de typeconversie automatisch plaats als verbredende transformatie(verbredende conversie) en de twee typen zijn compatibel... Verbredende transformaties zijn transformaties byte® kort® int® lang® vlot® dubbele... Voor bredere conversies zijn numerieke typen, waaronder integer en floating point, compatibel met elkaar. Numerieke typen zijn echter niet compatibel met char- en booleaanse typen. De typen char en boolean zijn ook niet compatibel met elkaar. Java voert ook automatische typeconversie uit bij het opslaan van een letterlijke integer-constante (die standaard van het type int is) in variabelen van het type byte, kort of lang (echter, als de letterlijke waarde een waarde heeft buiten het bereik van geldige waarden hiervoor type wordt een foutmelding weergegeven: mogelijk verlies van nauwkeurigheid). Als de conversie een versmallende conversie is, dat wil zeggen, byte ¬ short ¬ char ¬ int ¬ long ¬ float ¬ double wordt uitgevoerd, dan kan een dergelijke conversie resulteren in verlies van precisie of vervorming van het getal. Daarom wordt bij het verkleinen van conversies, wanneer het programma wordt gecompileerd, een diagnostisch bericht over type-incompatibiliteit weergegeven en worden er geen klassenbestanden gemaakt. Dit bericht wordt ook weergegeven wanneer u probeert uitdrukkingen van het type byte of short om te zetten in een variabele van het type char. Als het toch nodig is om dergelijke conversies uit te voeren, wordt een cast-bewerking gebruikt, die het volgende formaat heeft: ( conversie-type) betekenis, waar conversie-type definieert het type waarnaar het gegeven moet worden geconverteerd betekenis, bijvoorbeeld als resultaat van het uitvoeren van operators: byte x = 71; char-symbool = (char) x; de symboolvariabele wordt ingesteld op "G". Als een drijvende-kommawaarde wordt toegewezen aan een geheel getal, dan (als de drijvende-kommawaarde een fractioneel deel heeft), vindt er ook een expliciete typeconversie plaats inkorting(truncatie) nummers. Dus, als resultaat van het uitvoeren van de operator int x = (int) 77.85; variabele x wordt ingesteld op 77. Als de toegewezen waarde buiten bereik is type-conversies , dan is het resultaat van de conversie de rest van het delen van de waarde door de modulus van het bereik van het toegewezen type (voor nummers van typebyte is de modulus van het bereik 256, kortweg - 65536, voor int - 4294967296 , en voor lang - 18446744073709551616). Bijvoorbeeld als resultaat van de instructie byte x = (byte) 514; variabele x wordt ingesteld op 2. Bij het converteren van gehele getallen of reële getallen naar gegevens van het type char, vindt conversie naar een teken plaats als het oorspronkelijke getal tussen 0 en 127 ligt, anders krijgt het teken de waarde "?". Bij het uitvoeren van rekenkundige en bitsgewijze conversies worden alle byte- en korte waarden, evenals char, uitgebreid tot int, (terwijl de numerieke waarde van de tekencode wordt gebruikt in berekeningen voor char), dan, als ten minste één operand van het type long is , wordt het type van de integer-expressie uitgebreid tot lang. Als een van de operanden van het type float is, dan wordt het type van de volledige expressie uitgebreid tot float, en als een van de operanden van het type double is, dan zal het type van het resultaat double zijn. Dus als variabelen worden gedeclareerd byte a, c; korte b; dan in de uitdrukking a + b * c - 15 L + 1.5F + 1.08 - 10; eerst, voordat a + b * c wordt berekend, worden de waarden van de variabelen uitgebreid tot int, en aangezien constante 15 van het type lang is, wordt het resultaat van de berekening verhoogd tot lang vóór aftrekking. Daarna, aangezien letterlijke 1.5 van het type float is, wordt het resultaat van de berekening van a + b * c - 15L uitgebreid tot float voordat het aan deze letterlijke waarde wordt toegevoegd. Voordat de optelling met het getal 1.08 wordt uitgevoerd, wordt het resultaat van de vorige berekeningen uitgebreid tot verdubbeling (aangezien echte constanten standaard van het type dubbel zijn) en ten slotte, voordat de laatste optelling wordt uitgevoerd, wordt de letterlijke 10 (standaard int) uitgebreid tot het dubbele. Het resultaat van het evalueren van de expressie zal dus van het type double zijn. Automatische type-extensies (vooral korte en byte-extensies voor int) kunnen slecht herkende compileerfouten veroorzaken. Bijvoorbeeld in de operatoren: byte x = 30, y = 5; x = x + y; voordat de optelling wordt uitgevoerd, wordt de waarde van de variabelen x en y uitgebreid tot int, en vervolgens wordt een foutmelding weergegeven wanneer wordt geprobeerd het resultaat van een berekening van het type int toe te wijzen aan een variabele van het type byte. Om dit te voorkomen is het nodig om een ​​expliciete typeconversie te gebruiken in de tweede operator: x = (byte) (x + y); U moet de uitdrukking x + y tussen haakjes plaatsen omdat de prioriteit van de cast tussen haakjes hoger is dan de prioriteit van de optelbewerking. Trouwens, als je de tweede operator schrijft als: x + = y; er zal geen foutmelding zijn. Link naar eerst

De unaire operatoren worden gevolgd door de rekenkundige operatoren in volgorde van prioriteit. Deze groep bevat de vier meest voorkomende operatoren: optellen, aftrekken, vermenigvuldigen, delen. En niet alleen zij. Er is ook een modulo-operator, aangeduid met%. Rekenkundige operatoren zijn verdeeld in twee groepen. De eerste, meer prioriteitsgroep bevat *, /,%. In de tweede respectievelijk + en -.

Vermenigvuldigen en delen (* en /)

De * en / operators voeren vermenigvuldiging en deling uit op alle primitieve numerieke typen en char. Delen door nul resulteert in Rekenkundige Uitzondering.

Je vraagt ​​je waarschijnlijk af waarom ik je vertel over vermenigvuldigen en delen, die je al kent vanaf de eerste klas. Bij het programmeren hebben we echter te maken met enkele beperkingen die verband houden met de weergave van getallen in een computer. Deze beperkingen zijn van toepassing op alle numerieke formaten, van byte tot double. Maar ze vallen het meest op bij het type int.

Als u twee getallen vermenigvuldigt of deelt, wordt het resultaat berekend met behulp van gehele rekenkunde en opgeslagen in int of long. Als de getallen erg groot zijn, zal het resultaat groter zijn dan het maximale aantal dat in deze getallen kan worden weergegeven. Dit betekent dat het resultaat niet correct door de computer kan worden gecodeerd en niet logisch is. Het bytetype wordt bijvoorbeeld gebruikt om getallen in het bereik van -128 tot 127 weer te geven. Als we 64 en 4 vermenigvuldigen, wordt het resultaat 256, dat negen tekens heeft in binair getal 100.000.000, gecodeerd als 0 omdat byte slechts 8 tekens gebruikt.

Denk aan verdeeldheid. Als u deelt in een geheel getal, moet het resultaat een geheel getal zijn. Dit betekent dat het fractionele deel verloren gaat. 7/4 geeft ons bijvoorbeeld 1,75, maar in gehele rekenkunde zou het 1 zijn.

Dus als je te maken hebt met complexe uitdrukkingen, kun je een reeks vermenigvuldigingen en delingen kiezen. Maar houd er rekening mee dat vermenigvuldiging kan resulteren in: overloop, en deling - naar verlies van nauwkeurigheid... Populaire wijsheid is van mening dat eerst vermenigvuldigen en vervolgens delen in de meeste gevallen het juiste resultaat geeft. Laten we een voorbeeld bekijken:

1.int a = 12345, b = 234567, c, d;
2. lange e, f;
3.
4.c = een * b / b; // moet gelijk zijn aan a = 12345
5.d = a / b * b; // moet ook gelijk zijn aan a = 12345
6. Systeem.uit.println (“a is“ + a +
7. “\ nb is“ + b +
8. “\ nc is“ + c +
9. "\ en is" + d);
10.
11.e = (lang) a * b / b;
12.f = (lang) a / b * b;
13. Systeem.uit.println (
14. "\ nee is" + e +
15. "\ nf is" + f);

Het resultaat van het werk van dit fragment geeft het volgende:

A is 12345
b is 234567
c is -5965
d is 0
e is 12345
f is 0

Laat u niet verwarren door de numerieke waarden in dit voorbeeld. Het belangrijkste is dat wanneer we eerst de vermenigvuldiging deden, we een overloop kregen (c is -5965) toen we het codeerden om int te typen. We kunnen echter het juiste resultaat krijgen als we het beëindigen in een langer type, zoals lang. In beide gevallen zal het toepassen van de eerste deling funest zijn voor het resultaat, ongeacht de lengte van het type.

Deling modulo%

Het resultaat van modulo deling is de rest van de deling. 7/4 is bijvoorbeeld gelijk aan 1 met een rest van 3. Daarom is 7% 4 = 3. Gewoonlijk zijn de operanden van het type integer, maar soms wordt de operator toegepast op getallen met drijvende komma. U moet zich ook bewust zijn van enkele kenmerken van deze operator wanneer de operanden negatief zijn.

Voor negatieve of fractionele operanden is de regel: trek de rechter operand van de linker af totdat de laatste kleiner is dan de eerste. Voorbeelden:

17%5 = ? 17-5=12>5; 12-5=7>5; 7-5=2<5. Значит 17%5 = 2

21%7? 21-7=14>7; 14-7=7=7; 7-7=0<7. Значит 21%7 = 0

7.6%2.9? 7.6-2.9=4.7>2.9; 4.7-2.9=1.8<2.9. Значит 7.6%2.9=1.8

Opmerking: het teken van het resultaat (positief of negatief) wordt volledig bepaald door het teken van de linker operand, dat wil zeggen het deeltal.

Wanneer modulo-deling wordt uitgevoerd op fractionele getallen, is de essentie van deze bewerking het meerdere keren aftrekken van de deler. Het resultaat kan ook een fractioneel getal zijn.

Een eenvoudige vuistregel voor negatieve operanden is om het minteken van de operanden te verwijderen, modulo te delen door positieve operanden en het resultaat vervolgens met een minteken te plaatsen als de linkeroperand (dividend) negatief was.

Modulo-deling kan, net als normale deling, een rekenkundige uitzondering geven als de deler (rechter operand) nul is.