Aritmeetilised tehted

Sissejuhatus

Aritmeetilised operaatorid võimaldavad läbi viia matemaatilisi tehteid numbriliste väärtustega. Java toetab kõiki põhilisi matemaatilisi tehteid ning pakub ka spetsiaalseid operaatoreid väärtuste muutmiseks.

Binaarsed operaatorid

Binaarsed operaatorid vajavad kahte operanti (tehtepoolt). Eesmärk on läbi viia tehe kahe elemendi vahel.

Liitmine

Liitmine toimub pluss (+) märgiga:

int a = 5;
int b = 3;
int sum = a + b;  // 8

double x = 2.5;
double y = 1.5;
double result = x + y;  // 4.0

Liitmisoperaatorit kasutatakse ka sõnede ühendamiseks:

String greeting = "Tere" + " " + "maailm";  // "Tere maailm"
int age = 25;
String message = "Vanus: " + age;  // "Vanus: 25"

Lahutamine

Lahutamiseks kasutatakse miinus (-) märki:

int a = 10;
int b = 3;
int difference = a - b;  // 7

double x = 5.5;
double y = 2.3;
double result = x - y;  // 3.2

Korrutamine

Korrutamiseks kasutatakse tärni (*):

int a = 5;
int b = 4;
int product = a * b;  // 20

double x = 2.5;
double y = 2.0;
double result = x * y;  // 5.0

Jagamine

Jagamiseks kasutatakse kaldkriipsu (/):

double a = 10.0;
double b = 3.0;
double result = a / b;  // 3.3333...

canceloht

Kui mõlemad operandid on täisarvulised (int, long, byte, short), siis tulemus on samuti täisarv ning komakohad kaovad:

int a = 5;
int b = 2;
int result = a / b;  // 2, not 2.5!

// Solution, convert one side to a floating point number
double correctResult = (double) a / b;  // 2.5

Sellest saab rohkem lugeda tüüpide teisendamise peatükis.

canceloht

Täisarvude nulliga jagamisel tekib viga - ArithmeticException. Seda saab vältida kontrolliga, ega jagaja ei ole 0

Jääk/Modulo

Jagamistehtest tekkiva jäägi arvutamiseks kasutatakse protsendi (%) märki:

int a = 10;
int b = 3;
int remainder = a % b;  // 1 (10 = 3 * 3 + 1)

int c = 15;
int d = 5;
int noRemainder = c % d;  // 0 (15 jagub 5-ga täpselt)

Unaarsed operaatorid

Unaarsed operaatorid vajavad ainult ühte operandi. Eesmärk on rakendada tehe ühele elemendile.

Ühekordsed märgid - positiivne ja negatiivne

Antud operaatorite mõte on määrata arvu märk - kas väärtus on positiivne või negatiivne - või muuta olemasoleva arvu märki.

int a = 5;
int positive = +a;  // 5 (very rarely used, but it exists)
int negative = -a;  // -5

double x = 3.14;
double negX = -x;   // -3.14

Kahekordsed märgid - inkrement ja dekrement

Kahekordsed märgid tähistavad väärtuse suurendamist (++) või vähendamist (--) ühe võrra. Nende puhul mängib olulist rolli ka see, kas need märgid esinevad enne või peale muutujat.

Kui ++ või -- esinevad peale muutujat, siis tagastatakse vana väärtus ning alles siis suurendatakse/vähendatakse väärtust:

int a = 5;
int b = a++;  // b = 5, a = 6 (b gets old value, a is incremented)

int x = 10;
int y = x--;  // y = 10, x = 9

Kui antud märgid esinevad enne muutujat, siis see toimib vastupidi - muutujas olev väärtus suurendatakse ning peale seda tagastatakse:

int a = 5;
int b = ++a;  // a = 6, b = 6 (a is incremented, b gets new a value)

int x = 10;
int y = --x;  // x = 9, y = 9

Need operaatorid on väga laialdaselt kasutusel, all on paar näidet, kus neid kasutada võiks:

int counter = 0;

// All of these behave the same way, adds one to counter
// The last form is the most commonly used
counter = counter + 1;
counter += 1;
counter++;

// Used frequently in for loops
for (int i = 0; i < 10; i++) {  // i++ increments the value of i at the end of every cycle
    System.out.println(i);
}

Tehete järjekord

Kui avaldises on mitu operaatorit, siis tehete sooritamise järjekord on oluline. Hierarhia on järgmine:

1. Unaarsed operaatorid: ++, --, +, -
2. Korrutamine/jagamine/modulo: *, /, %
3. Liitmine/lahutamine: +, -
4. Omistamine: = +=, -=

Samuti muudavad sulud tehete järjekorda

int result = 5 + 3 * 2;  // 11, not 16 (multiplication is done before sum)
int result2 = (5 + 3) * 2;  // 16 (calculations in parentheses are done before multiplication)

int a = 5;
int b = 2 + ++a;  // b = 8, a = 6

Enamus operaatorite puhul töödeldakse tehet vasakult paremale:

int result = 10 - 5 - 2;  // (10 - 5) - 2 = 3

Kuid omistamise puhul töötatakse paremalt vasakule:

int a, b, c;
a = b = c = 5;  // c = 5, then b = 5, finally a = 5

---

Koodiloetavuse mõttes võiks pikad avaldised jagada mitme rea peale laiali:

// Hard to follow what is going on
int total = basePrice * quantity + shippingCost - discount + tax;

// Easy to understand
int subtotal = basePrice * quantity;
int finalPrice = subtotal + shippingCost - discount;
int total = finalPrice + tax;

Samuti aitab loetavust paremaks teha ka sulgude kasutamine:

// Unclear
int result = a + b * c / d - e;

// Better to understand
int result = a + ((b * c) / d) - e;

---

Bitilised operaatorid

Java toetab ka operatsioone bittidega. Antud juhul iga tehe tehakse iga bitiga eraldi. Neid kasutatakse harva, kuid on kasulikud näiteks süsteemiprogrammeerimises, krüptograafias ning ka koodi optimeerimises. Algajatele pole need vajalikud.

Operaator	Kirjeldus
&	Loogiline JA bittide vahel (AND)
|	Loogiline VÕI bittide vahel (OR)
^	Loogiline eksklusiivne VÕI (XOR)
~	Inversioon (NOT)
<<	Märgiga nihe vasakule
>>	Märgiga nihe paremale
>>>	Nihe paremale

Näited:

int a = 5;   // 0101 (binary)
int b = 3;   // 0011 (binary)

int and = a & b;   // 0001 = 1
int or = a | b;    // 0111 = 7
int xor = a ^ b;   // 0110 = 6

int shifted = a << 1;  // 1010 = 10 (shift left = multiply by 2)