Operatorii unari sunt urmați de operatorii aritmetici în ordinea de prioritate. Acest grup include cei mai comuni patru operatori: adunare, scădere, înmulțire, împărțire. Și nu numai ei. Există, de asemenea, un operator modulo, notat cu%. Operatorii aritmetici sunt împărțiți în două grupuri. Primul grup, mai prioritar, conține *, /,%. În al doilea, respectiv, + și -.

Înmulțirea și împărțirea (* și /)

Operatorii * și / efectuează înmulțirea și împărțirea pe toate tipurile numerice și caracterele primitive. Împărțirea la zero are ca rezultat ArithmeticException.

Probabil vă întrebați de ce vă vorbesc despre înmulțire și împărțire, pe care le cunoașteți încă din clasa I. Cu toate acestea, în programare ne ocupăm de unele limitări asociate cu reprezentarea numerelor într-un computer. Aceste restricții se aplică tuturor formatelor numerice, de la octet la dublu. Dar ele sunt cele mai vizibile pentru tipul int.

Dacă înmulțiți sau împărțiți două numere, rezultatul este calculat folosind aritmetica întregului și stocat fie în int, fie în long. Dacă numerele sunt foarte mari, atunci rezultatul va fi mai mare decât numărul maxim care poate fi reprezentat în aceste numere. Aceasta înseamnă că rezultatul nu va putea fi codificat corect de computer și nu va avea sens. De exemplu, tipul octet este folosit pentru a reprezenta numere în intervalul -128 la 127. Dacă înmulțim 64 și 4, rezultatul 256, care are nouă caractere în 100.000.000 binar, este codificat ca 0 deoarece octetul folosește doar 8 caractere.

Luați în considerare împărțirea. Dacă împărțiți în aritmetică întregi, rezultatul trebuie să fie întreg. Aceasta înseamnă că partea fracțională se va pierde. De exemplu, 7/4 ne dă 1,75, dar în aritmetica întregului ar fi 1.

Astfel, dacă ai de-a face cu expresii complexe, poți alege o succesiune de înmulțiri și împărțiri. Dar rețineți că înmulțirea poate avea ca rezultat revărsare, iar diviziunea - la pierderea preciziei... Înțelepciunea populară crede că efectuarea mai întâi a înmulțirilor și apoi a împărțirilor, în cele mai multe cazuri, dă rezultatul corect. Să luăm în considerare un exemplu:

1.int a = 12345, b = 234567, c, d;
2.lung e, f;
3.
4.c = a * b / b; // trebuie să fie egal cu a = 12345
5.d = a / b * b; // trebuie de asemenea să fie egal cu a = 12345
6. System.out.println („a este“ + a +
7. „\ nb este“ + b +
8. „\ nc este“ + c +
9. „\ nd este“ + d);
10.
11.e = (lung) a * b / b;
12.f = (lung) a / b * b;
13. System.out.println (
14. „\ ne este“ + e +
15. „\ nf este“ + f);

Rezultatul lucrării acestui fragment va da următoarele:

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

Nu vă confundați cu valorile numerice din acest exemplu. Important este că atunci când facem mai întâi înmulțirea, am primit un overflow (c este -5965) când l-am codificat pentru a tasta int. Cu toate acestea, putem obține rezultatul corect dacă îl terminăm într-un tip mai lung, cum ar fi lung. În ambele cazuri, aplicarea primei diviziuni va fi dezastruoasă pentru rezultat, indiferent de lungimea tipului acesteia.

Diviziune modulo%

Rezultatul diviziunii modulo este restul diviziunii. De exemplu, 7/4 este egal cu 1 cu un rest de 3. Prin urmare, 7% 4 = 3. De obicei operanzii sunt de tip întreg, dar uneori operatorul este aplicat numerelor în virgulă mobilă. De asemenea, ar trebui să fiți conștienți de unele dintre caracteristicile acestui operator atunci când operanzii sunt negativi.

Pentru operanzi negativi sau fracționari, regula este: scădeți operandul drept din cel stâng până când ultimul este mai mic decât primul. Exemple:

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

Notă: semnul rezultatului (pozitiv sau negativ) este determinat în întregime de semnul operandului din stânga, adică dividendul.

Când împărțirea modulo este efectuată pe numere fracționale, esența acestei operații este scăderea divizorului de mai multe ori. Rezultatul poate fi și un număr fracționar.

O regulă simplă pentru operanzii negativi este să îndepărtați semnul minus din operanzi, să împărțiți modulo cu operanzi pozitivi și apoi să adăugați rezultatul cu minus dacă operandul din stânga (dividend) a fost negativ.

Diviziunea în modul, ca și diviziunea normală, poate arunca o ArithmeticException dacă divizorul (operandul din dreapta) este zero.

Majoritatea operațiunilor pe tipuri primitive sunt efectuate nu folosind metode, ci folosind caractere speciale numite semn de operare.

Operațiune de atribuire

Atribuirea unei variabile a valorii unei constante, altei variabile sau unei expresii (variabile și/sau constante separate prin semne de operație) se numește operatiune de atribuireși este indicat prin semnul „ = ", de exemplu: x = 3; y = x; z = x; În Java, este posibil să se refolosească operația de atribuire într-o expresie, de exemplu: x1 = x2 = x3 = 0; Această operație se efectuează de la dreapta la stânga, adică mai întâi variabilei x3 i se atribuie valoarea 0, apoi variabilei x2 i se atribuie valoarea variabilei x3 (0), iar în final variabilei x1 i se atribuie valoarea variabilei x2 (0). semnele operațiilor ale căror argumente sunt numere se împart în două categorii: unar jetoane (unare) pentru operații cu un singur argument și binar(binar) cu două argumente.

Operații unare

Următoarele operații unare sunt definite în Java:

• unar minus "-" - schimbă semnul unui număr sau al unei expresii la opus;
• unar plus „+” - nu efectuează nicio acțiune asupra unui număr sau expresie;
• complement pe biți „~” (numai pentru numere întregi) - inversează toți biții câmpului numeric (schimbă de la 0 la 1 și de la 1 la 0);
• increment "++" (doar pentru numere întregi) - crește valoarea variabilei cu 1;
• decrementează „-” (numai pentru numere întregi) - scade valoarea variabilei cu 1.

Exemple de operații unare „+” și „-”: int i = 3, j, k; j = - i; // j = -3 k = + i; // k = 3 Un exemplu de operație de complement pe biți: int a = 15; int b; b = ~ a; // b = -16 Numerele a și b sunt int, adică. sunt reprezentate intern ca numere întregi cu semn binar cu o lungime de 32 de biți, astfel încât reprezentarea binară a numerelor a și b va arăta astfel: zero biți din numărul a au fost modificați cu cei din b, iar cei din a sunt modificați cu zero biți. Reprezentarea zecimală a lui b este –16. Semnele operației de creștere și decreștere pot fi plasate fie înainte, fie după variabilă. Aceste opțiuni sunt denumite corespunzător prefixși postfix prin înregistrarea acestor operaţii. Semnul operatorului în notația de prefix returnează valoarea operandului său după evaluarea unei expresii. Pentru notația postfix, semnul operației primul returnează valoarea operandului său și numai după aceea calculează creșterea sau decrementarea, de exemplu: int x = 1, y, z; y = ++ x; z = x ++; Variabilei y i se va atribui valoarea 2, deoarece mai întâi valoarea lui x va fi incrementată cu 1, iar apoi rezultatul va fi atribuit variabilei y. Variabilei z i se va atribui valoarea 1, deoarece mai întâi variabilei z i se va atribui o valoare, iar apoi valoarea lui x va fi incrementată cu 1. În ambele cazuri, noua valoare a lui x va fi 2. De remarcat că în Java, spre deosebire de C, operațiile de decrementare și de creștere pot fi aplicate și variabilelor reale (de tipurile float și double). Semne de operare binară sunt împărțite în operații cu rezultat numeric și operații de comparare, al căror rezultat este o valoare booleană.

Operații binare aritmetice

Java definește următoarele operații binare aritmetice:

• adăugare „+”;
• scăderea „-”;
• înmulțirea „*”;
• Divizia "/";
• calcularea restului de împărțire a numerelor întregi „%” (returnează restul împărțirii primului număr la al doilea, iar rezultatul va avea același semn ca și dividendul), de exemplu, rezultatul operațiunii 5% 3 va fi 2 și rezultatul operației (-7) % (- 4) va fi -3. În Java, operația poate fi folosită și pentru variabile reale (cum ar fi float sau double).

Exemple de operații aritmetice binare: 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 (la împărțirea numerelor întregi // partea fracționată este aruncată) x5 = x% 4 // x5 = 3 (restul diviziunii// 7 cu 4)

Operații pe biți

• Operațiile pe biți tratează valorile numerice originale ca câmpuri de biți și fac următoarele pe ele:
• setarea bitului la i-a poziție a câmpului rezultat la 1, dacă ambii biți sunt în i--lea poziții ale operanzilor sunt egale cu 1, sau cu 0, în caz contrar - ȘI pe biți ("&");
• setarea bitului la i-a poziție a câmpului rezultat la 1, dacă cel puțin un bit în i--a poziție a operanzilor este egală cu 1, sau cu 0, în caz contrar - SAU pe biți ("|");
• setarea bitului la i-a poziție a câmpului rezultat la 1, dacă biții sunt introduși i pozițiile --lea ale operanzilor nu sunt egale între ele sau cu 0, în caz contrar - SAU exclusiv pe biți ("^");
• deplasarea la stânga a biților din câmpul primului operand cu numărul de biți determinat de cel de-al doilea operand (bitul de semn al numărului nu se modifică în acest caz) - deplasare pe biți la stânga, ținând cont de semnul "<< ";
• deplasarea la dreapta a biților din câmpul primului operand cu numărul de biți determinat de al doilea operand (bitul de semn al numărului nu se modifică în acest caz) - deplasare pe biți la dreapta, ținând cont de " semnul >>";
• deplasarea la dreapta a biților din câmpul primului operand cu numărul de biți determinat de al doilea operand (bitul de semn al numărului este, de asemenea, deplasat în acest caz) - deplasare pe biți la dreapta fără a lua în considerare " >>>" semn.

Exemple de operații pe biți:

1. ȘI pe biți

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

2. SAU pe biți

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

3. SAU exclusiv pe biți

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

4. Schimbați la stânga, ținând cont de semn

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

5. Schimbați la dreapta, ținând cont de semn

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

6. Schimbați la dreapta fără a ține cont de semn

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

Operații combinate

În Java, pentru operații aritmetice binare, puteți utiliza combinate Jetoane de operație (compuse): operațiune de identificare = expresie Aceasta este echivalentă cu următoarea operație: expresie de operare de identificare = identificator Exemple:

1. Expresia x + = b înseamnă x = x + b.
2. Expresia x - = b înseamnă x = x - b.
3. Expresia x * = b înseamnă x = x * b.
4. Expresia x / = b înseamnă x = x / b.
5. Expresia x% = b înseamnă x = x% b.
6. Expresia x & = b înseamnă x = x & b.
7. Expresia x | = b înseamnă x = x | b.
8. Expresia x ^ = b înseamnă x = x ^ b.
9. Expresia x<<= b означает x = x << b .
10. Expresia x >> = b înseamnă x = x >> b.
11. Expresia x >>> = b înseamnă x = x >>> b.

Operatii de comparatie

Java definește următorii operatori de comparație:

• "==" (egal), "! =" (nu este egal),
• ">" (mai mare decât), "> =" (mai mare sau egal),
• " < " (меньше) " <= " (меньше или равно)

au doi operanzi și returnează o valoare booleană corespunzătoare rezultatului comparației ( fals sau Adevărat). Rețineți că atunci când comparați două valori pentru egalitate în Java, ca în C și C ++, simbolurile " == „(două semne egale fără spațiu), spre deosebire de operatorul de atribuire, care folosește „ = ". Folosirea simbolului" = "la compararea a două valori fie provoacă o eroare de compilare, fie produce un rezultat incorect. Exemple de operații de comparare: boolean isEqual, isNonEqual, isGreater, isGreaterOrEqual, isLess, isLessOrEqual; int x1 = 5, x2 = 5, x3 = 3, x4 = 7; este egal = x1 == x2; // este Egal = adevărat esteNonEqual = x1! = x2; // isNonEqual = false isGreater = x1> x3; // isGreater = adevărat // isGreaterOrEqual = adevărat isGreaterOrEqual = x2> = x3; isLess = x3< x1; // isLess = true isLessOrEqual = x1 <= x3; // isLessOrEqual = false

Operații booleene

Operații booleene sunt executate pe variabile booleene iar rezultatul lor este tot o valoare de tip boolean... Următoarele operații booleene sunt definite în Java:

• negație "!" - înlocuirea falsului cu adevărat, sau invers;
• Operația AND „&” - rezultatul este adevărat numai dacă ambii operanzi sunt adevărati, în caz contrar rezultatul este fals;
• Operația SAU „|” - rezultatul este adevărat numai dacă cel puțin unul dintre operanzi este adevărat, în caz contrar rezultatul este fals.
• Operația XOR „^” - rezultatul este adevărat numai dacă operanzii nu sunt egali între ei, în caz contrar rezultatul este fals.

Operatorii „&”, „|” și „^” pot fi utilizați, precum și operatorii corespunzători pe biți, în operatorii de alocare compuși: „& =", "| =" și "^ =" În plus, operațiile " = sunt aplicabile operanzilor booleeni. = „(egal) și”! = „(nu este egal). După cum puteți vedea din definiția SAU și ȘI, operația OR evaluează la adevărat atunci când primul operand este adevărat, indiferent de valoarea celui de-al doilea operand, iar operatorul AND evaluează la fals atunci când primul operand este fals, indiferent de valoarea celui de-al doilea operand. Java mai definește două operații booleene: a doua versiune a AND și OR boolean, cunoscute sub numele de operații logice de scurtcircuit: ȘI scurt „&&” și SAU scurt „||”. Folosind aceste operații, cel de-al doilea operand nu va fi deloc evaluat, ceea ce este util în cazurile în care funcționarea corectă a operandului din dreapta depinde dacă operandul din stânga este adevărat sau fals. Exemple de operații booleene: boolean isInRange, isValid, isNotValid, isEqual, isNotEqual; int x = 8; isInRange = x> 0 && x< 5 ; // isInRange = false isValid = x >0 || x> 5; // isValid = adevărat isNotValid =! este valabil; // isNotValid = fals isEqual = isInRange == isValid; // isEqual = fals // isNotEqual = adevărat isNotEqual = isInRange! = isValid

Funcționare condiționată

O operație condiționată se scrie sub forma expresie-1?Expresie-2: expresie-3. În acest caz, expresia-1 este evaluată mai întâi, ceea ce ar trebui să dea o valoare booleană, iar apoi, dacă expresia-1 este adevărată, expresia-2 este evaluată și returnată ca rezultat al operației sau (dacă expresia-1 este falsă ), iar expresia-3 este returnată ca rezultat al operației. Un exemplu de operație condiționată: x = n> 1? 0: 1; Variabilei x i se va atribui valoarea 0 dacă n> 1 (expresia n> 1 evaluează drept adevărat) sau 1 dacă n≤1 (expresia n> 1 evaluează fals).

Vechimea operațiunilor

Operațiile în expresii sunt efectuate de la stânga la dreapta, însă, în funcție de prioritatea lor. Deci operații de înmulțire în expresia y = x + z * 5; va fi executat înainte de operația de adunare deoarece prioritatea operației de înmulțire este mai mare decât prioritatea operației de adunare. Prioritățile de operare (în ordinea priorității descrescătoare) în Java sunt prezentate în tabel. unu.
Parantezele măresc prioritatea operațiilor care se află în interiorul lor. Deci, dacă introduceți paranteze în expresia de mai sus: y = (x + z) * 5; apoi se va executa mai întâi operația de adunare, iar apoi operația de înmulțire. Uneori, parantezele sunt folosite pur și simplu pentru a face expresia mai lizibilă, de exemplu: (x> 1) && (x<= 5 ) ;

Conversia tipului și turnarea atunci când efectuați operațiuni

În alocare și expresii aritmetice se pot folosi literale, variabile și expresii de diferite tipuri, de exemplu: y dublu; octet x; y = x + 5; Acest exemplu adaugă variabila octet x la literalul 5 (int) și atribuie rezultatul variabilei duble y. În Java, ca și în limbajul C, conversiile de tip în evaluarea expresiilor pot fi efectuate automat, sau folosind un operator cast. Cu toate acestea, regulile de turnare sunt oarecum diferite de cele ale limbajului C și, în general, sunt mai stricte decât în ​​limbajul C. La efectuarea unei operații de atribuire, conversia tipului are loc automat dacă transformare de lărgire(conversie de lărgire) și cele două tipuri sunt compatibile... Transformările de lărgire sunt transformări octet® mic de statura® int® lung® pluti® dubla... Pentru extinderea conversiilor, tipurile numerice, inclusiv numărul întreg și virgulă mobilă, sunt compatibile între ele. Cu toate acestea, tipurile numerice nu sunt compatibile cu tipurile char și boolean. Nici tipurile char și boolean nu sunt compatibile între ele. Java efectuează, de asemenea, conversie automată de tip atunci când stochează o constantă întreg literal (care este de tip int în mod implicit) în variabile de tip octet, scurt sau lung (cu toate acestea, dacă literalul are o valoare în afara intervalului de valori valide pentru aceasta tip, este afișat un mesaj de eroare: posibilă pierdere de precizie). Dacă conversia este o conversie de îngustare, adică o conversie este efectuată byte ¬ short ¬ char ¬ int ¬ long ¬ float ¬ dublu, atunci o astfel de conversie poate duce la pierderea preciziei sau la distorsiunea numărului. Prin urmare, odată cu restrângerea conversiilor, atunci când programul este compilat, este afișat un mesaj de diagnostic despre incompatibilitatea de tip și fișierele de clasă nu sunt create. Acest mesaj va fi afișat și atunci când se încearcă convertirea expresiilor de tip octet sau scurt într-o variabilă de tip char. Dacă totuși este necesar să se efectueze astfel de conversii, se folosește o operațiune de turnare, care are următorul format: ( tip de conversie) sens, Unde tip de conversie definește tipul la care ar trebui convertit datele date sens, de exemplu, ca urmare a executării operatorilor: octet x = 71; simbol char = (char) x; variabila simbol va fi setată la „G”. Dacă o valoare în virgulă mobilă este atribuită unui tip întreg, atunci (dacă valoarea în virgulă mobilă are o parte fracțională), are loc și o conversie explicită a tipului trunchiere(trunchiere) numere. Deci, ca urmare a executării operatorului int x = (int) 77,85; variabila x va fi setată la 77. Dacă valoarea atribuită este în afara intervalului conversii de tip , atunci rezultatul conversiei va fi restul împărțirii valorii la modulul intervalului tipului atribuit (pentru numere de tip octet, modulul intervalului va fi 256, pe scurt - 65536, pentru int - 4294967296 și pentru mult timp - 18446744073709551616). De exemplu, ca rezultat al instrucțiunii octet x = (octet) 514; variabila x va fi setată la 2. La conversia numerelor întregi sau reale în date de tip char, conversia într-un caracter are loc dacă numărul inițial este în intervalul de la 0 la 127, în caz contrar caracterul primește valoarea „?”. Când se efectuează conversii aritmetice și pe biți, toate valorile octet și scurte, precum și char, sunt extinse la int (în timp ce valoarea numerică a codului caracterului este utilizată în calculele pentru char), atunci, dacă cel puțin un operand este de tip lung , tipul expresiei întregi este extins la lung. Dacă unul dintre operanzi este de tip float, atunci tipul expresiei complete este extins la float, iar dacă unul dintre operanzi este de tip double, atunci tipul rezultatului va fi dublu. Deci, dacă variabilele sunt declarate octetul a, c; b scurt; apoi în expresia a + b * c - 15 L + 1,5F + 1,08 - 10; mai întâi, înainte de a calcula a + b * c, valorile variabilelor vor fi extinse la int, apoi, deoarece constanta 15 este de tip lung, rezultatul calculului va fi crescut cu mult înainte de scădere. După aceea, deoarece literalul 1.5 este de tip float, rezultatul calculării a + b * c - 15L va fi extins pentru a flota înainte de a fi adăugat la acest literal. Înainte de a efectua adunarea cu numărul 1.08, rezultatul calculelor anterioare va fi extins la dublu (deoarece constantele reale sunt de tip double implicit) și, în final, înainte de efectuarea ultimei adunări, va fi literal 10 (int implicit) extins la dublare. Astfel, rezultatul evaluării expresiei va fi de tip double. Extensiile de tip automat (în special extensiile scurte și de octeți la int) pot provoca erori de compilare prost recunoscute. De exemplu, în operatorii: octet x = 30, y = 5; x = x + y; înainte de efectuarea adunării, valoarea variabilelor x și y va fi extinsă la int și apoi va fi afișat un mesaj de eroare când se încearcă atribuirea rezultatului unui calcul de tip int unei variabile de tip octet. Pentru a evita acest lucru este necesar să folosiți o conversie explicită de tip în al doilea operator: x = (octet) (x + y); Trebuie să includeți expresia x + y între paranteze, deoarece prioritatea modelului inclus între paranteze este mai mare decât prioritatea operației de adăugare. Apropo, dacă scrieți al doilea operator ca: x + = y; nu va fi niciun mesaj de eroare. Link la primul

Să ne dăm seama una dintre abordările pentru introducerea datelor din fluxul standard printr-o clasă java.util.Scanner... Să facem asta folosind exemplul unei sarcini simple de pe site-ul foarte util e-olimp.com

Sarcină

Introduceți un număr din fluxul standard. Presupunând că acesta este un număr întreg pozitiv de două cifre, tipăriți fiecare cifră separat (separată printr-un spațiu) în fluxul de ieșire standard. Ordinea numerelor nu trebuie schimbată.

Teste

Nu sunt presupuse cazuri specifice în algoritm. Facem trei teste - cel mai mic număr din intervalul valid, cel mai mare și o anumită valoare de la mijlocul intervalului.

Intrare	Ieșire
10	1 0
99	9 9
54	5 4

Soluţie

Să folosim clasa java.util.Scanner, pentru a introduce date în format întreg. Și să calculăm ambele numere.

Afișarea cifrelor unui număr întreg de două cifre

Java

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

clasa principala ( public static void main (String args) aruncă java. lang. Excepție ( java. util. Scanner i = java nou. util. Scanner (System. In); int n = i. nextInt (); Sistem. afară. println (n / 10 + "" + n% 10);

Explicații

1. Descriem variabila i tip java.util.Scannerși atribuiți-i imediat valoarea unui nou obiect din această clasă. Constructorul realizează obiectul Scanner„Dar de la stdin. Acestea. i devine un supliment la intrarea standard. Acest lucru ne permite să citim un întreg și nu doar să-l citim cu metoda citit() câte un octet.
2. Folosind metoda următorInt() citește o secvență de numere și o transformă într-un număr întreg. Stocăm numărul în variabila n.
3. n/ 10 - numărul zecilor din număr. Zecile vor fi de zece ori mai mici decât numărul în sine. Se efectuează împărțirea întregului - împărțirea întregului.
4. n% 10 - calculați restul împărțirii cu zece - numărul de unități - cifra cea mai din dreapta a numărului.
5. n/ 10 + "" + n% 10 - introduceți o singură linie de spațiu între două numere întregi. În acest caz, numerele sunt, de asemenea, convertite în reprezentare șir și toate cele trei șiruri sunt concatenate - numită concatenare șir. Așa funcționează operațiunea „+” cu date șir.

Accelerează I/O

Cu toată comoditatea acestei abordări, este destul de lentă și uneori sarcinile nu se execută la timp. Puteți accelera semnificativ lucrul folosind StreamTokenizer și PrintWriter.
Acest lucru va crește cantitatea de cod, dar va economisi timp.

Accelerarea I/O

Java

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

import java. io. *; import java. util. *; clasa principala ( static StreamTokenizer in = new StreamTokenizer (nou BufferedReader (nou InputStreamReader (System. in))); static PrintWriter out = nou PrintWriter (System. out); static int nextInt () aruncă IOException (

Studii ca „Dezvoltator de jocuri” + angajare

Operatori Java

Limbajul Java folosește operatorii obișnuiți + - * / aritmetici pentru a indica adunarea, scăderea, înmulțirea și împărțirea.

Operatorul / denotă diviziunea întregului dacă ambele argumente sunt numere întregi. În caz contrar, acest operator denotă diviziunea în virgulă mobilă. Restul împărțirii numerelor întregi (adică funcția mod) este notat cu simbolul %.
De exemplu, 15/2 este 7, 15% 2 este 1 și 15. 0/2 este egal cu 7. 5.

Rețineți că împărțirea întregului cu 0 face o excepție, în timp ce împărțirea cu 0 a numerelor în virgulă mobilă are ca rezultat infinit sau NaN.

Operatorii aritmetici pot fi utilizați pentru a inițializa variabile.

int n = 5;
int a = 2 *n; // Valoarea variabilei a este 10.

Este convenabil să folosiți operatori aritmetici binari prescurtati în operatorii de atribuire.

De exemplu, operatorul
x + = 4;
echivalent cu operator
x = x + 4;

(Operatorii de atribuire abreviați sunt formați prin prefixarea unui caracter de operație aritmetică, cum ar fi * sau%, înainte de caracterul =, cum ar fi * = sau% =.)

Unul dintre obiectivele declarate ale limbajului Java este independența mașinii.

Calculele ar trebui să conducă la același rezultat, indiferent de mașina virtuală care le rulează. Pentru aritmetica în virgulă mobilă, acest lucru este surprinzător de dificil. Tipul dublu folosește 64 de biți pentru a stoca valori numerice, dar unele procesoare folosesc registre în virgulă mobilă de 80 de biți. Aceste registre oferă o precizie suplimentară în etapele intermediare de calcul. Să luăm următoarea expresie ca exemplu:

dublu w = x * y / z;

Multe procesoare Intel evaluează expresia x * y și stochează acest rezultat intermediar într-un registru de 80 de biți, apoi îl împart la valoarea lui z și rotunjește răspunsul la 64 de biți la sfârșit. Acest lucru poate îmbunătăți acuratețea calculelor și poate evita depășirile. Cu toate acestea, acest rezultat poate fi diferit dacă un procesor pe 64 de biți este utilizat în toate calculele.

Din acest motiv, specificația originală Java Virtual Machine a declarat că toate calculele intermediare ar trebui să fie rotunjite. Acest lucru a enervat comunitatea informatică. Nu doar calculele rotunjite pot provoca debordări. De fapt, acestea sunt mai lente decât calculele mai precise, deoarece operațiunile de rotunjire necesită o anumită perioadă de timp. Drept urmare, dezvoltatorii limbajului Java s-au răzgândit, căutând să rezolve conflictul dintre performanța optimă și reproductibilitatea excelentă.

În mod implicit, dezvoltatorii de mașini virtuale permit acum precizie extinsă în calculele intermediare. Cu toate acestea, metodele marcate cu cuvântul cheie strictfp trebuie să utilizeze operații precise în virgulă mobilă pentru a asigura rezultate reproductibile. De exemplu, metoda principală poate fi etichetată cu cuvinte cheie, după cum se arată mai jos:
public static strictfp void main (Argumente șir)

În acest caz, toate comenzile din cadrul metodei principale vor efectua operații exacte asupra numerelor în virgulă mobilă.

Detaliile acestor operațiuni sunt strâns legate de modul în care funcționează procesoarele Intel. În mod implicit, rezultatele intermediare pot folosi metrica extinsă, dar nu mantisa extinsă. (Cipurile Intel acceptă rotunjirea mantisei fără a sacrifica performanța.) Prin urmare, singura diferență între calculul implicit și calculul exact este că calculul precis poate depăși, în timp ce calculul implicit nu.

Dacă privirea îți dispare în timp ce citești această notă, nu-ți face griji. Pentru majoritatea programatorilor, această întrebare este complet irelevantă. Debordările în virgulă flotantă nu apar în majoritatea cazurilor. Nu vom folosi cuvântul cheie strictfp în această carte.

Operatori de creștere și decreștere

Programatorii, desigur, știu că una dintre cele mai comune operațiuni pe variabile numerice este adunarea sau scăderea uneia. În limbajul Java, ca și în limbajele C și C++, există operatori de creștere și decrementare: operatorul x ++ adaugă unul la valoarea curentă a variabilei x, iar operatorul x- scad unul din aceasta.

De exemplu codul
int n = 12;
n ++;
face valoarea variabilei n egală cu 13.

Deoarece acești operatori modifică valoarea unei variabile, ei nu pot fi aplicați numerelor în sine. De exemplu, operatorul 4++ nu este valid.

Există două tipuri de acești operatori. Mai sus arată forma „postfix” a operatorului, în care caracterele operatorului sunt plasate după operand. Există și o formă „prefix” - ++ n.
Ambii acești operatori cresc valoarea variabilei cu unul. Diferența dintre cele două apare doar atunci când acești operatori sunt utilizați în expresii. Forma de prefix a operatorului de increment adaugă mai întâi unul la valoarea unei variabile, în timp ce forma de postfix folosește vechea valoare a acelei variabile.

int m = 7;
int n = 7;
int a = 2 * ++ m; // Acum a este 16 și m este 8.
int b = 2 * n ++; // Acum b este 14 și n este 8.

(Deoarece operatorul ++ a fost cel care a dat numele limbajului C ++, acesta a fost motivul primei glume despre acesta. Nedoritorii subliniază că până și numele acestui limbaj conține o eroare: „Printre altele , acest limbaj ar trebui să se numească ++ C, deoarece dorim să folosim acest limbaj numai după ce îl îmbunătățim. ")

1. Operații aritmetice de bază

Următorul tabel listează operațiile aritmetice de bază utilizate în limbajul Java:

Să luăm în considerare câteva reguli pentru lucrul cu operații aritmetice:

• Expresiile sunt evaluate de la stânga la dreapta, cu excepția cazului în care sunt adăugate paranteze sau unele operații au prioritate.
• Operațiile *, / și% au prioritate față de + și -.

Exemplul 1. Operații aritmetice pe valori întregi

De exemplu, în acest cod, variabilele Ași b va avea semnificații diferite:

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

Rezultatul executiei:

A = 3 b = 13

• Operația de scădere unară schimbă semnul singurului său operand.
• O operație de adăugare unară returnează pur și simplu valoarea operandului său. În principiu, nu este necesar, dar posibil.

Exemplul 2. Operații de adunare și scădere unare

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

• Când se efectuează o operație de împărțire pe un tip de date întreg, rezultatul nu va conține o componentă fracțională.

Exemplul 3. Împărțirea numerelor întregi

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

Rezultatul rulării acestui program:

• Operanzii pentru operațiile aritmetice trebuie să fie de tip numeric. Operațiile aritmetice nu pot fi efectuate pe tipuri de date booleene, dar pot fi efectuate pe tipuri de date char deoarece în Java acest tip este în esență o variație a tipului int.

Exemplul 4. Operații aritmetice pe variabile de tip char

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

Rezultatul executiei:

N 111 22

Exemplul 5. Operații aritmetice pe variabile de tip char

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

Rezultatul executiei:

Operator modul - notat cu%. Acest operator returnează restul primului număr împărțit la al doilea. La împărțirea unui număr întreg, rezultatul este, de asemenea, un număr întreg.

Exemplul 6. Diviziunea modulului

clasă publică 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);))

Rezultatul executiei:

1 1.2000000000000002

2. Operații aritmetice compuse cu atribuire

Java are operații speciale care combină aritmetica cu atribuirea. Luați în considerare următoarea expresie:

A = a + 4;

În Java, această operație poate fi scrisă după cum urmează:

A + = 4;

Operațiile de atribuire compusă nu numai că vă permit să reduceți cantitatea de cod, dar vă permit și să efectuați conversie automată, care nu se face prin operațiuni convenționale.

Exemplul 5. Operații de alocare aritmetică compusă

clasă publică 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); System.out.println (b); System.out.println (c);))