Operatii aritmetice. Operațiuni extinse de atribuire

Pentru tipurile de date numerice întregi - long, int, short, char și byte - este definit un set suplimentar de operatori cu care puteți verifica și modifica starea biților individuali ai valorilor corespunzătoare. Tabelul 4.2 oferă un rezumat al acestor operatori. Operatorii aritmetici de biți lucrează cu fiecare bit ca valoare independentă.

Tabelul 4.2. Operatori aritmetici de biți

Tabelul 4.3 arată modul în care fiecare dintre operatorii aritmetici de biți afectează posibilele combinații de biți ale operanzilor lor.

Tabelul 4.3

Schimb la stânga

Operator<< выполняет сдвиг влево всех битов своего левого операнда на число позиций, заданное правым операндом. При этом часть битов в левых разрядах выходит за границы и теряется, а соответствующие правые позиции заполняются нулями.

Schimbați la dreapta

Operatorul >> înseamnă schimbare la dreapta în Java. Mută ​​toți biții operandului său din stânga la dreapta cu numărul de poziții specificat de operandul din dreapta. Când biții operandului din stânga sunt împinși dincolo de poziția din dreapta cuvântului, ei se pierd. Când treceți la dreapta, cifrele superioare (stânga) eliberate ale numărului deplasat sunt completate cu conținutul anterior al cifrei semnate. Acest lucru se face astfel încât, atunci când se deplasează la dreapta, numerele își păstrează semnul.

Schimb dreapta nesemnat

Este adesea necesar ca, la deplasarea la dreapta, bitul de semn să nu se extindă, iar cifrele din stânga libere să fie umplute cu zerouri. Operatorul de schimbare la dreapta nesemnat >>> este folosit în acest scop.

4.3. Operatori relaționali

Pentru a putea compara două valori, Java are un set de operatori care descriu relația și egalitatea. Lista acestor operatori este prezentată în Tabelul 4.4.

Tabelul 4.4

Valorile de orice tip, inclusiv numere întregi, numere reale, simboluri, booleeni și referințe, pot fi comparate folosind operatorul de egalitate == și operatorul de inegalitate! =. Rețineți că în Java, testarea egalității este indicată de secvența (==). Un semn (=) este operatorul de atribuire.

Operatorii de relație pot fi aplicați numai operanzilor de tipuri numerice. Cu ajutorul lor, puteți lucra cu tipuri întregi, reale și de caractere. Fiecare dintre operatorii relaționali returnează un rezultat boolean, adică. sau Adevărat sau fals.

Note de curs Java. Sesiunea 4

Operatori Java

Majoritatea operațiunilor Java sunt simple și intuitive. Acestea sunt operații precum +, -, *, /,<,>si altele.Operatiile au propria ordine de executie si prioritati. Deci în expresie

se face mai întâi înmulțirea, apoi adunarea, deoarece înmulțirea are o prioritate mai mare decât adunarea. În expresie

mai întâi se calculează a + b și apoi se scade c din rezultat, deoarece ordinea acestor operații este de la stânga la dreapta.

Dar operațiunile Java au propriile lor particularități. Fără a intra într-o descriere detaliată a celor mai simple operațiuni, să ne oprim asupra caracteristicilor.

Sa incepem cu sarcinile... Spre deosebire de o serie de alte limbaje de programare din Java, atribuirea nu este un operator, ci o operație. Semantica acestei operații poate fi descrisă după cum urmează.

• Operația de atribuire este indicată de simbolul „=". Acesta calculează valoarea operandului său din dreapta și o atribuie operandului din stânga și returnează valoarea atribuită ca rezultat. Această valoare poate fi folosită de alte operațiuni. O succesiune de mai multe sarcini este efectuată de la dreapta la stânga.

În cel mai simplu caz, totul arată ca de obicei.

Aici se întâmplă exact ceea ce ne referim în mod intuitiv - se calculează suma a și b, rezultatul este introdus în x. Dar iată alte două exemple.

În primul, primul 1 este introdus în b, rezultatul operației este 1, apoi acest rezultat este introdus în a. În al doilea exemplu, se calculează suma a și b și rezultatul se pierde. Este inutil, dar valid din punct de vedere sintactic.

Operatii de comparatie

Acestea sunt operațiuni>,<, >=, <=, != и ==. Следует обратить внимание, что сравнение на равенство обозначается двумя знаками "=". Операндами этих операций могут быть арифметические данные, результат — типа boolean.

Operații de creștere, decreștere

Acestea sunt operațiuni ++ și -. Deci y ++ (increment) este prescurtare pentru y = y +1, în mod similar cu operația de decrementare (-).

Dar există o subtilitate în aceste operațiuni. Ele vin în două forme, prefix (++ y) și postfix (y ++). Efectul acestor operații este același - își măresc (operații de decrementare - descrește) operandul lor cu 1, dar rezultatul lor este diferit. Ca rezultat, forma prefixului dă valoarea operandului deja schimbată cu 1, iar forma postfixului dă valoarea operandului înainte de modificare.

A = 5; x = a ++; y = ++ a;

În acest fragment, x va fi setat la 5 și y la 7.

Operațiunea diviziunii întregi

Trebuie avut în vedere că împărțirea unui întreg la altul produce un întreg și nu rotunjește, ci elimină partea fracțională.

Restul diviziunii (valoarea modulului)

Java are operatorul%, care denotă restul unei diviziuni.

Operațiuni extinse de atribuire

În plus față de operația obișnuită „=" în Java, există operații + =, - =, * =, / = etc. Acestea sunt notații scurte. Deci a + = b este complet echivalent cu a = a + b. La fel, cu alte astfel de operațiuni.

Operații logice

! - negație && - „și” logic || - „sau” logic

Operanzii acestor operații trebuie să fie de tip boolean, rezultatul este boolean. && și || au o particularitate - operandul lor din dreapta poate să nu fie calculat dacă rezultatul este deja cunoscut din operandul din stânga. Deci, dacă operandul din stânga al operației && este fals, atunci operandul din dreapta nu va fi calculat, deoarece rezultatul este încă fals.

Această proprietate trebuie luată în considerare, mai ales când operandul din dreapta conține un apel la o funcție.

Operații logice pe biți

Acestea sunt operațiuni

& - pe biți „și” | - bitwise "sau" ^ - bitwise "exclusiv sau" ~ - bitwise negation

Ele sunt executate pentru fiecare pereche de biți ai operanzilor lor.

Operații în schimburi

<< — сдвиг влево >> - shift right >>> - shift right nesemnat

Aceste operații schimbă valoarea operandului din stânga cu numărul de biți specificat de operandul din dreapta.

Funcționare condiționată

Aceasta este singura operațiune ternară, adică. o operație care are trei operanzi. În consecință, nu se folosește un singur semn de operare, ci două.

<условие> ? <выражение1> : < выражение2>

Dacă<условие>este adevărat, rezultatul este< выражение1>, in caz contrar< выражение2>.

De exemplu, „a< b ? a: b" вычисляет минимум из a и b.

Operație de turnare

Aceasta este o operațiune foarte importantă. În mod implicit, toate conversiile care pot duce la probleme sunt interzise în Java. Deci, nu puteți atribui o valoare lungă unui operand int. În cazurile în care este încă necesar, trebuie să introduceți o conversie de tip explicită.

De exemplu, să presupunem că metoda f (...) returnează lung.

int x = (int) f (10);

Aici (int) este o operație de conversie de tip. O operație de conversie a tipului este indicată de numele tipului cuprins între paranteze.

Această operație se aplică nu numai tipurilor de bază, ci și claselor. Vom arunca o privire mai atentă la asta când ne uităm la moștenire.

Literale (constante)

Aritmetic

Exemple de constante aritmetice

10 - 010 este 8 - 0123 este 83 (1 * 64 + 2 * 8 + 3) - 0x10 este 16 - 0x123 este 291 (1 * 256 + 2 * 16 +3) - 1e5 este 100000 - 1,203 e-03 e.

Pentru a indica tipul unei constante se folosesc sufixe: l (sau L) - lung, f (sau F) - float, d (sau D) - dublu. De exemplu,

1L este unul, dar de tip lung.

Literale booleene

Literale booleene sunt adevărate și false

Literale șiruri

Sunt scrise între ghilimele duble, de exemplu

„acesta este un șir”

Litere de caractere

Sunt scrise cu apostrofe, de exemplu „F”, „w”.

În șiruri și caractere literale, există reguli pentru scrierea specialelor. personaje. În primul rând, există un set de oferte speciale predefinite. personaje. Acest

- "\ n" - sfârșit de linie (line feed) - "\ r" - retur car - "\ t" - filă

si o serie de altele.

În al doilea rând, puteți scrie în mod explicit codul caracterului (trebuie doar să-l știți). Codul este de obicei scris în sistemul octal: „\ 001” este un caracter cu codul 1 etc.

Declarații

Operator - Expresie

Sintaxă

<выражение>;

Un astfel de operator constă dintr-o expresie, la sfârșit este „;”. Acțiunea sa este de a evalua expresia, valoarea calculată de această expresie se pierde. Acestea. de obicei, o astfel de expresie conține un operator de atribuire, deși acest lucru nu este cerut de sintaxă.

A = 0; x = (a> b? a: b); cnt ++;

Declarație condiționată (dacă)

Sintaxă

Dacă (<условие>) <оператор1>

Aici<условие>Este o expresie logică, adică o expresie care returnează adevărat sau fals. După cum puteți vedea din sintaxă, partea restul este opțională. Există un operator după dacă și după else. Dacă trebuie să puneți mai mulți operatori acolo, atunci trebuie să puneți bloc . blocîncepe cu „(” și se termină cu „)”.

În Java, este obișnuit să puneți întotdeauna un bloc, chiar dacă există o declarație după if sau else.

If (a> b) (x = a;) else (x = b;) if (flag) (flag = fals; init ();)

În ultimul exemplu, flag este o variabilă sau un câmp boolean, init () este o metodă numită dacă flag-ul este adevărat (se spune „dacă flag este setat”).

Declarația de returnare (deja văzută)

Operator de buclă după precondiție (în timp ce)

Sintaxă

In timp ce (<условие>) <оператор>

Ca și în cazul instrucțiunii if, este obișnuit în Java<оператор>închideți în bretele.

Int i = 0; în timp ce (mai mult) (x / = 2; mai mult = (++ i< 10); }

În acest exemplu, mai multe ar trebui să fie o variabilă sau un câmp boolean, x o variabilă sau un câmp aritmetic. Ciclul se execută de 10 ori.

Operator de buclă postcondiție (do while)

Sintaxă

Do<оператор>in timp ce (<условие>);

Operatorul de buclă după postcondiție diferă de operatorul de buclă prin precondiție doar prin aceea că iterația buclei este întotdeauna executată în ea cel puțin o dată, în timp ce în operatorul de precondiție poate să nu existe o singură iterație de buclă (dacă condiția este imediat falsă).

Int i = 0; face (x \ = 2; mai mult = (++ i< 10); } while (more);

Operator de contor buclă (pentru)

Sintaxă

Pentru (<инициализация>; <условие>; <инкремент>) <оператор>

Antetul unui astfel de ciclu conține trei expresii (în cel mai simplu caz). Din numele operatorului se poate înțelege că acesta servește la organizarea unui ciclu cu contor. Prin urmare expresia<инициализация>este executat o dată înainte de prima iterație a buclei. După fiecare iterație a buclei, expresia este executată<инкремент>iar apoi expresia<условие>... Ultima expresie trebuie să fie logică și este folosită pentru a seta condiția pentru continuarea ciclului. Acestea. atâta timp cât este adevărat, bucla va continua să circule.

Pentru comoditatea compunerii operatorilor de buclă cu un numărător, în această construcție au fost introduse o mulțime de extensii.

• <инициализация>poate să nu fie o expresie, ci o descriere cu inițializare de tip „int i = 0”.
• <инициализация>poate fi o listă de expresii separate prin virgulă, cum ar fi „i = 0, r = 1”.
• <инкремент>poate fi, de asemenea, o listă de expresii, de exemplu, „i ++, r * = 2”
• Toate componentele (<инициализация>, <условие>și<инкремент>) sunt opționale. A exprima<условие>aceasta înseamnă că condiția este întotdeauna considerată adevărată (adică ieșirea din buclă trebuie organizată prin anumite mijloace în interiorul buclei în sine).

Acestea. să spunem următoarea buclă (buclă infinită):

Pentru (;;) (...)

Pentru (int i = 0; i< 10; i++) x /=2;

Aceasta este cea mai „economică” implementare a buclei din exemplele anterioare.

Rupe și continuă declarațiile

Nu există declarații goto în Java. După cum știți, goto duce la programe nestructurate. Declarațiile break și continue sunt analoge structurate ale goto.

Ele pot fi folosite în bucle, iar break poate fi folosit și într-o instrucțiune switch. Executarea instrucțiunii break face ca bucla să se încheie imediat. Instrucțiunea continue determină sfârșitul iterației curente a buclei și începutul uneia noi. În acest caz, verificarea condiției este încă efectuată, așa că continuarea poate cauza și sfârșitul buclei.

Pentru (int i = 0;; i ++) (dacă (doar impar && i% 2 == 0) continuă; y = (x + 1) / x; dacă (y - x< 0.001) break; x = y; }

Aici oddOnly este o variabilă booleană. Dacă este setat, atunci toate iterațiile buclei cu numere pare sunt sărite utilizând instrucțiunea continue;

Condiția de terminare a buclei din acest exemplu este verificată în mijlocul buclei și, dacă este satisfăcută, bucla este terminată folosind instrucțiunea break.

Cu bucle imbricate, instrucțiunile break și continue se pot referi nu numai la bucla în care se află, ci și la bucla care le încadrează. Pentru a face acest lucru, instrucțiunea buclă de încadrare trebuie să fie marcată cu o etichetă, care trebuie specificată în instrucțiunea break sau continue. De exemplu,

Lbl: în timp ce (...) (... Pentru (...) (... Dacă (...) rupe lbl;)...)

Aici, instrucțiunea break va determina terminarea atât a buclei for, cât și a buclei while.

Declarație de selecție (comutator)

Servește la organizarea unei selecții după o anumită valoare a uneia dintre mai multe ramuri de execuție.

Sintaxă

Intrerupator (<выражение>) (caz<константа1>: <операторы1>caz<константа2>: <операторы2> . . . }

Expresia trebuie să returneze o valoare întreagă sau caracter, iar constantele trebuie să fie de același tip cu valoarea acestei expresii.

Elementele carcasei<константа>: "sunt etichete de salt, dacă valoarea expresiei coincide cu o constantă, atunci se va face un salt la această etichetă. Dacă valoarea expresiei nu se potrivește cu niciuna dintre constante, atunci totul depinde de prezența fragmentului implicit. Dacă aceasta este, atunci tranziția are loc la eticheta implicită dacă nu, atunci întreaga instrucțiune switch este omisă.

• Într-o instrucțiune switch, fragmentele de caz nu formează niciun bloc. Daca dupa ultima afirmatie a acestui fragment de caz exista cazul urmator, atunci executia va continua, incepand de la prima afirmatie a acestui fragment de caz.
• Din această cauză, o instrucțiune break este de obicei folosită într-o instrucțiune switch. Este plasat la sfârșitul fiecărui fragment de carcasă.

Exemplu (fișier SymbolTest.java)

Luați în considerare un program demonstrativ care utilizează instrucțiunile for și switch.

Acest program generează aleatoriu 100 de caractere din alfabetul latin și le clasifică drept „vocale”, „consoane” și „uneori vocale”. Ultima categorie include simbolurile „y” și „w”.

Clasa publică SymbolTest (public static void main (String args) (pentru (int i = 0; i< 100; i++) { char c = (char)(Math.random()*26 + "a"); System.out.print(c + ": "); switch (c) { case "a": case "e": case "i": case "o": case "u": System.out.println("гласная"); break; case "y": case "w": System.out.println("иногда гласная"); break; default: System.out.println("согласная"); } } } }

În acest exemplu, există mai multe elemente care sunt noi pentru noi.

• Este folosită metoda aleatoare () a clasei Math. Să ne uităm la documentația pentru clasa de matematică și să vedem ce face.
• În declarația char c = (char) (Math.random () * 26 + „a”); la simbol se adaugă valoarea aritmetică. Cu această adăugare în Java, simbolul este convertit într-un număr care este egal cu codul acestui simbol.
• În instrucțiunea System.out.print (c + ":"); not println (...) este folosit, dar print (...). Metoda print (...) diferă de println (...) numai prin faptul că nu se imprimă pe o linie nouă, astfel încât următoarea instrucțiune print (...) sau println (...) va continua tipărirea pe aceeași linie.

Ar trebui să acordați atenție și fragmentelor de carcasă. Formal, există 7 astfel de fragmente, dar 5 dintre ele nu conțin niciun operator. Deci, putem presupune că există 2 fragmente de caz, dar fiecare dintre ele are mai multe etichete de caz.

Teme pentru acasă

• 1 Schimbați SymbolTest.java astfel încât numărul de simboluri generate să fie specificat de parametrul de apel de program.
• 2 Scrieți un program care ia două numere ca parametri de apel - lungimile catetelor unui triunghi dreptunghic și, ca rezultat, imprimă unghiurile în grade.

(nici unul)

Ultima actualizare: 30.10.2018

Operațiile pe biți sau pe biți sunt efectuate pe biți individuali sau pe biți de numere. În aceste operații, numai numerele întregi pot fi folosite ca operanzi.

Fiecare număr are o reprezentare binară specifică. De exemplu, numărul 4 în binar este 100, iar numărul 5 este 101 și așa mai departe.

De exemplu, luați următoarele variabile:

Octet b = 7; // 0000 0111 s scurt = 7; // 0000 0000 0000 0111

Tipul octet ocupă 1 octet sau, respectiv, 8 biți, reprezentați de 8 biți. Prin urmare, valoarea binară a variabilei b va fi 00000111. Tipul scurt ocupă 2 octeți sau 16 biți în memorie, deci numărul de acest tip va fi reprezentat de 16 biți. Și în acest caz, variabila s din sistemul binar va avea valoarea 0000 0000 0000 0111.

Pentru a scrie numere semnate în Java, utilizați cod suplimentar(complementul a doi), în care bitul cel mai semnificativ este semnat. Dacă valoarea sa este 0, atunci numărul este pozitiv, iar reprezentarea sa binară nu diferă de cea a unui număr fără semn. De exemplu, 0000 0001 în zecimală 1.

Dacă bitul cel mai semnificativ este 1, atunci avem de-a face cu un număr negativ. De exemplu, 1111 1111 în zecimală reprezintă -1. În consecință, 1111 0011 reprezintă -13.

Operații logice

Operațiile logice pe numere reprezintă operații pe biți. În acest caz, numerele sunt considerate în reprezentare binară, de exemplu, 2 în sistemul binar este egal cu 10 și are două cifre, numărul 7 - 111 și are trei cifre.

& (înmulțire logică)

Înmulțirea se realizează bit cu bit, iar dacă ambii operanzi au valori de biți egale cu 1, atunci operația returnează 1, în caz contrar se returnează numărul 0. De exemplu:

Int a1 = 2; // 010 int b1 = 5; // 101 System.out.println (a1 & b1); // rezultatul este 0 int a2 = 4; // 100 int b2 = 5; // 101 System.out.println (a2 & b2); // rezultatul este 4

În primul caz, avem două numere 2 și 5. 2 în binar reprezintă numărul 010 și 5 - 101. Înmulțirea pe biți a numerelor (0 * 1, 1 * 0, 0 * 1) dă rezultatul 000.

În al doilea caz, în loc de două, avem numărul 4, care are 1 în prima cifră, la fel ca și numărul 5, deci aici rezultatul operației (1 * 1, 0 * 0, 0 * 1) = 100 va fi numărul 4 în format zecimal...

| (adăugare logică)

Această operație se efectuează și pe cifre binare, dar acum se returnează o unitate dacă cel puțin un număr din acest bit are o unitate (operație „SAU logic”). De exemplu:

Int a1 = 2; // 010 int b1 = 5; // 101 System.out.println (a1 | b1); // rezultat 7 - 111 int a2 = 4; // 100 int b2 = 5; // 101 System.out.println (a2 | b2); // rezultat 5 - 101

^ (SAU logic exclusiv)

Această operație se mai numește și XOR, este adesea folosită pentru criptare simplă:

Număr int = 45; // 1001 Valoarea de criptat - în formă binară 101101 int key = 102; // Cheie de criptare - în binar 1100110 int encrypt = număr ^ cheie; // Rezultatul va fi numărul 1001011 sau 75 System.out.println ("Număr criptat:" + criptare); int decrypt = encrypt ^ cheie; // Rezultatul va fi numărul original 45 System.out.println ("Număr decriptat:" + decriptare);

Aici se efectuează și operațiuni pe biți. Dacă avem valori diferite ale bitului curent pentru ambele numere, atunci se returnează 1, în caz contrar se returnează 0. De exemplu, rezultatul expresiei 9 ^ 5 va fi numărul 12. Și pentru a descifra numărul, aplicăm operația inversă rezultatului.

~ (negație logică)

O operație pe biți care inversează toate cifrele unui număr: dacă valoarea bitului este 1, atunci devine zero și invers.

Octet a = 12; // 0000 1100 System.out.println (~ a); // 1111 0011 sau -13

Operații în schimburi

Operațiile de schimbare sunt efectuate și pe cifrele numerelor. Deplasarea poate avea loc la dreapta și la stânga.

A<

a >> b - deplasează numărul a la dreapta cu b cifre. De exemplu, 16 >> 1 mută numărul 16 (care în sistemul binar este 10.000) cu o cifră la dreapta, adică rezultatul este 1000 sau numărul 8 în notație zecimală.

a >>> b - spre deosebire de tipurile anterioare de deplasări, această operație reprezintă o schimbare fără semn - deplasează numărul a la dreapta cu b cifre. De exemplu, expresia -8 >>> 2 va fi egală cu 1073741822.

Astfel, dacă numărul inițial care trebuie mutat într-o parte sau cealaltă este împărțit la două, atunci de fapt se obține înmulțirea sau împărțirea cu doi. Prin urmare, o astfel de operație poate fi utilizată în locul înmulțirii directe sau împărțirii cu doi, deoarece operația de schimbare la nivel hardware este mai puțin costisitoare decât operația de împărțire sau înmulțire.

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 permisă reutilizarea operației de atribuire într-o expresie, de exemplu: x1 = x2 = x3 = 0; Această operație este efectuată de la dreapta la stânga, adică mai întâi variabilei x3 i se atribuie valoarea 0, apoi lui x2 i se atribuie valoarea x3 (0), iar în final lui x1 i se atribuie valoarea x2 (0). doua 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 >>";
• deplasare la dreapta 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 scurtat „&&” și SAU scurtat „||”. Când se utilizează aceste operații, al doilea operand nu va fi evaluat deloc, 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 acest caz, 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 long. 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 implicit de tip double) și, în final, înainte de efectuarea ultimei adunări, va fi literal 10 (implicit int) 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 cauza 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 atunci 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

Ultima actualizare: 30.10.2018

Majoritatea operațiunilor din Java sunt similare cu cele utilizate în alte limbaje asemănătoare C. Există operații unare (efectuate pe un operand), operații binare pe doi operanzi și operații ternare pe trei operanzi. Un operand este o variabilă sau o valoare (de exemplu, un număr) implicată într-o operație. Să luăm în considerare toate tipurile de operațiuni.

Ei participă la operații aritmetice după numere. Java are operații aritmetice binare (efectuate pe doi operanzi) și unare (efectuate pe un operand). Operațiile binare includ următoarele:

operația de adunare a două numere:

Int a = 10; int b = 7; int c = a + b; // 17 int d = 4 + b; // unsprezece

operația de scădere a două numere:

Int a = 10; int b = 7; int c = a - b; // 3 int d = 4 - a; // -6

operația de înmulțire a două numere

Int a = 10; int b = 7; int c = a * b; // 70 int d = b * 5; // 35

operația de împărțire a două numere:

Int a = 20; int b = 5; int c = a / b; // 4 dublu d = 22,5 / 4,5; // 5.0

Merită luat în considerare la împărțire, deoarece dacă în operație sunt implicate două numere întregi, rezultatul împărțirii va fi rotunjit la un număr întreg, chiar dacă rezultatul este atribuit unei variabile flotante sau duble:

Dublu k = 10/4; // 2 System.out.println (k);

Pentru ca rezultatul să fie un număr în virgulă mobilă, unul dintre operanzi trebuie să reprezinte și un număr în virgulă mobilă:

k dublu = 10,0 / 4; // 2.5 System.out.println (k);

obținerea restului din împărțirea a două numere:

Int a = 33; int b = 5; int c = a% b; // 3 int d = 22% 4; // 2 (22 - 4 * 5 = 2)

Există, de asemenea, două operații aritmetice unare care se efectuează pe același număr: ++ (incrementare) și - (decrementare). Fiecare dintre operații are două tipuri: prefix și postfix:

++ (increment de prefix)

Presupune creșterea variabilei cu unu, de exemplu, z = ++ y (în primul rând, valoarea variabilei y este mărită cu 1, iar apoi valoarea acesteia este atribuită variabilei z)

Int a = 8; int b = ++ a; System.out.println (a); // 9 System.out.println (b); // 9

++ (increment postfix)

De asemenea, reprezintă o creștere a unei variabile cu unul, de exemplu, z = y ++ (în primul rând, valoarea lui y este atribuită lui z, iar apoi valoarea lui y este mărită cu 1)

Int a = 8; int b = a ++; System.out.println (a); // 9 System.out.println (b); // opt

- (decrementarea prefixului)

scăderea variabilei cu unu, de exemplu, z = - y (în primul rând, valoarea variabilei y este redusă cu 1, iar apoi valoarea acesteia este atribuită variabilei z)

Int a = 8; int b = --a; System.out.println (a); // 7 System.out.println (b); // 7

- (scădere postfix)

z = y-- (mai întâi, valoarea variabilei y este atribuită variabilei z, iar apoi valoarea variabilei y este redusă cu 1)

Int a = 8; int b = a--; System.out.println (a); // 7 System.out.println (b); // opt

Prioritate aritmetică

Unele operații au prioritate față de altele și, prin urmare, sunt efectuate mai întâi. Operațiuni în ordinea descrescătoare a priorității:

++ (creștere), - (scădere)

* (înmulțire), / (diviziune),% (restul diviziunii)

+ (adunare), - (scădere)

Prioritatea operațiilor trebuie luată în considerare la executarea unui set de expresii aritmetice:

Int a = 8; int b = 7; int c = a + 5 * ++ b; System.out.println (c); // 48

În primul rând, va fi efectuată operația de creștere ++ b, care are o prioritate mai mare - va crește valoarea variabilei b și o va returna ca rezultat. Apoi se efectuează înmulțirea 5 * ++ b și numai ultima adunare este a + 5 * ++ b

Parantezele vă permit să redefiniți ordinea calculelor:

Int a = 8; int b = 7; int c = (a + 5) * ++ b; System.out.println (c); // 104

În ciuda faptului că operația de adunare are o prioritate mai mică, adunarea va fi efectuată mai întâi și nu înmulțirea, deoarece operația de adunare este cuprinsă între paranteze.

Asociativitatea operațiilor

Pe lângă prioritate, operațiunile se disting printr-un astfel de concept ca asociativitatea... Când operaţiile au aceeaşi prioritate, ordinea evaluării este determinată de asociativitatea operatorilor. Există două tipuri de operatori în funcție de asociativitate:

Operatori asociativi stânga care se execută de la stânga la dreapta

Operatori asociativi de dreapta care se execută de la dreapta la stânga

De exemplu, unele operații, cum ar fi înmulțirea și împărțirea, au aceeași prioritate. Care va fi atunci rezultatul în expresia:

Int x = 10/5 * 2;

Ar trebui să interpretăm această expresie ca (10/5) * 2 sau ca 10 / (5 * 2)? Într-adevăr, în funcție de interpretare, vom obține rezultate diferite.

Deoarece toți operatorii aritmetici (cu excepția prefixului de creștere și decrementare) sunt asociativi la stânga, adică sunt executați de la stânga la dreapta. Prin urmare, expresia 10/5 * 2 trebuie interpretată ca (10/5) * 2, adică rezultatul va fi 4.

Operații cu virgulă mobilă

Trebuie remarcat faptul că numerele în virgulă mobilă nu sunt potrivite pentru calcule financiare și alte calcule în care erorile de rotunjire pot fi critice. De exemplu:

Dublu d = 2,0 - 1,1; System.out.println (d);

În acest caz, variabila d nu va fi egală cu 0,9, așa cum s-ar putea presupune inițial, ci 0,899999999999999. Erorile de precizie ca aceasta apar deoarece sistemul binar este utilizat la un nivel scăzut pentru a reprezenta numere în virgulă mobilă, dar nu există o reprezentare binară pentru 0,1, precum și pentru alte valori fracționale. Prin urmare, dacă în astfel de cazuri, se folosește de obicei clasa BigDecimal, care vă permite să ocoliți astfel de situații.