Gotowe przykłady dot liczb

src/main/java/p01_zmienne/PrzegladTypow.java

@@ -7,13 +7,16 @@ public class PrzegladTypow {
 	public static void main(String[] args) {
 		// 8 typów prostych:
 		// liczby calkowite: byte, short, int, long
-		byte b = 100;
-		short s = 1000;
-		int i = 23;
-		long l = 333;
+	    // typy różnią się dostępnym zakresem wartości
+		byte b = 100;   // 1 bajt, zakres od -128 do +127
+		short s = 1000; // 2 bajty, zakres od ok -32k do + 32k
+		int i = 23;     // 4 bajty, zakres od - 2mld do + 2mld
+		long l = 333;   // liczby 18-19 cyfrowe
+		// nie opłaca się używać pojedynczych zmiennch typu bye i short, bo i tak sa w pamięci zaokgrąglane do 4 bajtów
+		// dość często używa się typu byte[] "tablica bajtów"
 		System.out.println(b * s * i * l);
 		
-		// 2 typy dla liczb z ułamkiem. liczby "zmiennopozycyjne" / "zmiennoprzeconkowe" (floating point)
+		// 2 typy dla liczb z ułamkiem. liczby "zmiennopozycyjne" / "zmiennoprzecinkowe" (floating point)
 		float f = 3.14F;
 		double d = 123.456;
 		System.out.println(f * d);
@@ -22,6 +25,7 @@ public class PrzegladTypow {
 		// char - pojedynczy znak, ale patrząc technicznie, to jest liczba 16-bitowa, która może być kodem znaku
 		char c = 'A';
 		System.out.println(c);
+		System.out.println((int)c); // 65
 		System.out.println(c+1); // kodem litery A jest 65
 		c++;
 		// teraz jednak "przesuwamy znak" o jedną pozycję do przodu

src/main/java/p02_liczby/BityIBajty.java

+package p02_liczby;
+
+public class BityIBajty {
+
+	public static void main(String[] args) {
+		System.out.println("Zwiększanie bajta:");
+		byte b = 0;
+		for (int i = 1; i <= 260; i++) {
+			String bity = Integer.toBinaryString(Byte.toUnsignedInt(b));
+			bity = String.format("%8s", bity);
+			bity = bity.replace(' ', '0');
+			
+			System.out.printf("%4d  :  %s%n", b, bity);
+			b++;
+		}
+	}
+}

src/main/java/p02_liczby/Ciekawostki.java

+package p02_liczby;
+
+public class Ciekawostki {
+
+	public static void main(String[] args) {
+		// Liczby całkowite mają ograniczony zakres,
+		// a wyjście poza ten zakres (gdy wynik obliczenia nie mieści się w zakresie)
+		// daje w efekcie "integer overflow", czyli przekręcenie licznika
+		int miliard = 1_000_000_000;
+		System.out.println(2 * miliard);
+		System.out.println(3 * miliard);
+		System.out.println(5 * miliard); // typ int - granica to nieco ponad 2 mld
+		System.out.println(5 * 1000000000);
+		System.out.println(5L * miliard); // typ long
+		System.out.println(10L * miliard * miliard); // ale long też ma swój limit
+		// To jest bardzo groźne, bo wychodzi błędny wynik i program działa dalej, ale pracuje na niepoprawnych danych.
+		// efekt: Ariane 5
+		
+		// Sposób na obsługę liczb całkowitych bez limitu: BigInteger.
+		System.out.println();
+		
+		// Obliczenia na liczbach zmiennoprzecinkowych (float oraz double) są nieprecyzyjne.
+		// Wewnętrznie liczba zapisana jest w systemie dwójkowym, a nie każdy ułamek dziesiętny da się w ten sposób zapisać.
+		// Liczby są pamiętane "w lekkim zniekształceniu", a niektóre operacje mogą ten błąd kumulować i staje się on coraz bardziej zauważalny.
+		double cena = 1.2;
+		System.out.println(3 * cena);
+		System.out.println();
+		
+		// Sposób na obsługę liczb z ułamkiem dziesiętnym bez pomyłek: BigDecimal.
+		// Zalecany sposób liczenie pieniędzy w Javie.
+		
+		
+		int x = 0321;
+		// System ósemkowy (oktalny), czyli to jest równe 3×8² + 2×8 + 1 = 192 + 16 + 1 = 209
+		System.out.println("x = " + x);
+		
+		System.out.println();
+		
+		x = 19;
+		System.out.println(x / 5);
+		// Dzielenie całkowite (gdy l.całkowitą dzielimy przez całkowitą) daje w wyniku część całkowitą ilorazu.
+		// Część ułamkowa jest odrzucana; to nie jest zaokrąglenie, tylko obcięcie.
+	}
+
+}

src/main/java/p02_liczby/Dzielenie.java

+package p02_liczby;
+
+public class Dzielenie {
+
+	public static void main(String[] args) {
+		double d = 1.25;
+		
+		int n = 5;
+		
+		// Uwaga na kolejność działań gdy miesza się inty i double
+		// Tutaj: int dzielony porzez int - wynik obcinany do liczby całkowitej
+		System.out.println(n / 3 * d);
+		
+		 // dzielenie na doublach
+		System.out.println(n * d / 3);
+		System.out.println(1.0 * n / 3 * d);
+		System.out.println((double)n / 3 * d);
+		System.out.println();
+		
+		System.out.println("Dzielenie całkowite i reszta z dzielenia:");
+		for(int i = -10; i <= 10; i++) {
+			System.out.printf("%3d / 3 = %2d      %3d %% 3 = %2d\n", i, i / 3, i, i % 3);
+		}
+
+	}
+
+}

src/main/java/p02_liczby/Floaty.java

+package p02_liczby;
+ 
+public class Floaty {
+ 
+    public static void main(String[] args) {
+        float f = 1.0000001f;
+        
+        System.out.println(f);
+        f += 1;
+        System.out.println(f);
+        f -= 1;
+        System.out.println(f);
+        System.out.println();
+ 
+        // Zaokroglęnia nie są robione w systemie dziesiętnym, tylko dwójkowym
+        f = 1.0000003f;
+        System.out.println(f);
+        f += 1;
+        System.out.println(f);
+        f -= 1;
+        System.out.println(f);
+
+        System.out.println();
+        f = 2222222222f;
+        // System.out.println(f);
+        System.out.printf("%8.0f\n", f);
+        f += 1000;
+        System.out.printf("%8.0f\n", f);
+        f -= 10000000;
+        System.out.printf("%8.0f\n", f);
+        
+        // lepsze dla pieniędzy: BigDecimal
+    }
+}

src/main/java/p02_liczby/IntegerOverflow.java

+package p02_liczby;
+
+public class IntegerOverflow {
+
+	public static void main(String[] args) {
+		System.out.println(2 * 1000_000_000);
+		System.out.println(3 * 1000_000_000);
+		System.out.println(5 * 1000_000_000);
+		System.out.println(3L * 1000_000_000);
+		System.out.println();
+
+        int x = 2147483646;
+
+        System.out.println(x);
+        x++;
+        System.out.println(x);
+        x++;
+        System.out.println(x);
+        x++;
+        System.out.println(x);
+	}
+}

src/main/java/p02_liczby/JakSprawdzicOverflow.java

+package p02_liczby;
+
+import java.util.Scanner;
+
+public class JakSprawdzicOverflow {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Podaj pierwszą liczbę: ");
+		int x = sc.nextInt();
+		System.out.println("Podaj drugą liczbę: ");
+		int y = sc.nextInt();
+		
+		int iloczyn = x * y;
+		System.out.println("Wynik zwykłego mnożenia: " + iloczyn);
+
+		try {
+			int sprawdzony = Math.multiplyExact(x, y);
+			System.out.println("Wynik zabezpieczonego mnożenia: " + sprawdzony);
+		} catch (ArithmeticException e) {
+			System.out.println("Overflow");
+		}
+	}
+
+}
+
+
+// YT   "Ariane 5"
+// przerwa do 13:30

src/main/java/p02_liczby/LiteralyLiczbowe.java

+package p02_liczby;
+
+public class LiteralyLiczbowe {
+
+	public static void main(String[] args) {
+		int x;
+
+		x = 123; // format dziesiętny
+		System.out.println(x);
+
+		x = 0123; // system ósemkowy
+		//NK x = 08;  // cyfry od 0 do 7
+		System.out.println(x);
+
+		x = 0x100; // system szesnastkowy
+		System.out.println(x);
+		x = 0x7F;
+		System.out.println(x);
+
+		// system dwójkowy - od Javy 7
+		x = 0b1101;
+		System.out.println(x);
+
+		// odstępy pomiędzy cyframi - od Javy 7
+		x = 2_000_000;
+		System.out.println(x);
+		
+		//NK long l = 4000000000; // wartość nie mieszcząca się w int
+		long l = 4000000000L; // OK
+		
+		// int _1000 = 1313;
+		
+		// x = _1000;  // odwołanie do zmiennej :)
+		// x = 1000_;
+		x = 10______00; // po prostu tysiąc
+		
+		// dopuszczalne są tylko pomiędzy cyframi.
+		// nie na początku, nie na końcu, nie obok kropki ani obok litery typu i wykładnika
+		
+		x = 0x0F_FF_80_00;
+		x = 0b0011_0101;
+		
+		System.out.println(x); // 1000
+		
+		double dd = 10__00;
+		dd = 3.14; // literał liczbowy z częścią ułamkową jest typu double (a nie float)
+		dd = 1_00.0__0;
+		//dd = 100._9;
+		//dd = 100_.9;
+		
+		dd = 100.99d;
+		//dd = 100.99_f;
+		
+		// x = 0x_FF;
+
+		// NK x = 1L; // L na końcu oznacza typ long (może być duże lub małe)
+
+		l = 1L;
+		l = 1; // inta można wpisać na zmienną long
+
+		System.out.println();
+		
+		float f = 12; // int na float - OK
+		// f = 3.14;
+		// literał z ułamkiem jest typu double, a double nie można wpisać na float
+		f = 3.14F;
+		f = 1.0f;
+		f = 3f;
+		f = 1.13e2F;
+		f = (float)3.14; // kompiluje się, ale niezalecane, bo można zgubić precyzję
+		System.out.println(f);
+
+		double d = 3.14;
+		// NK f = d;
+		// na końcu double'a też można podać info o typie: D  albo d
+		d = 4.44d;
+		d = 4.445D;
+		
+		// liczba w notacji dziesiętnej razy 10 do podanej potęgi
+		d = 1.25e3;
+		System.out.println(d);
+		d = 4.44e-3;
+		System.out.println(d);
+		System.out.println();
+		
+		// liczba w notacji szestastkowej razy 2 do podanej potęgi - tak to jest przechowywane wewnętrznie!
+		d = 0x3p2; // 12
+		System.out.println(d);
+		d = 0x0.2p0; // 2/16 = 1/8 = 0.125 
+		System.out.println(d);
+		d = 0x1p-3;
+		System.out.println(d);
+	}
+}

src/main/java/p02_liczby/Mnozenie1_Int.java

+package p02_liczby;
+
+import java.util.Scanner;
+
+public class Mnozenie1_Int {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		
+		System.out.println("Podaj dwie liczby do pomnożenia: ");
+		long x = scanner.nextLong();
+		long y = scanner.nextLong();
+		
+		long wynik = x * y;
+		System.out.println("wynik normalnego mnożenia: " + wynik);
+		
+		// operacje matematyczne pod większą kontrolą (ale działające wolniej):
+		try {
+			long wynik2 = Math.multiplyExact(x, y);
+			System.out.println("wynik exact mnożenia: " + wynik2);
+		} catch(ArithmeticException e) {
+			System.out.println("wynik nie mieści się w zakresie");
+		}
+	}
+
+}

src/main/java/p02_liczby/Mnozenie2_Long.java

+package p02_liczby;
+
+import java.util.Scanner;
+
+public class Mnozenie2_Long {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		
+		System.out.println("Podaj dwie liczby do pomnożenia: ");
+		int x = scanner.nextInt();
+		int y = scanner.nextInt();
+		
+		int wynik = x * y;
+		System.out.println("wynik normalnego mnożenia: " + wynik);
+		
+		// operacje matematyczne pod większą kontrolą (ale działające wolniej):
+		try {
+			int wynik2 = Math.multiplyExact(x, y);
+			System.out.println("wynik exact mnożenia: " + wynik2);
+		} catch(ArithmeticException e) {
+			System.out.println("wynik nie mieści się w zakresie");
+		}
+	}
+
+}

src/main/java/p02_liczby/Mnozenie3_Double.java

+package p02_liczby;
+
+import java.math.BigDecimal;
+import java.util.Locale;
+import java.util.Scanner;
+
+public class Mnozenie3_Double {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		scanner.useLocale(Locale.US);
+		
+		System.out.println("Podaj dwie liczby do pomnożenia: ");
+		double x = scanner.nextDouble();
+		double y = scanner.nextDouble();
+		
+		double wynik = x * y;
+		System.out.println("wynik mnożenia: " + wynik);
+		
+		BigDecimal x_dokladny = new BigDecimal(x);
+		BigDecimal y_dokladny = new BigDecimal(y);
+		BigDecimal w_dokladny = new BigDecimal(wynik);
+		System.out.println("\nDokładnie w pamięci komputera");
+		System.out.println("x = " + x_dokladny);
+		System.out.println("y = " + y_dokladny);
+		System.out.println("w = " + w_dokladny);
+	}
+
+}

src/main/java/p02_liczby/OverflowWPetliShort.java

+package p02_liczby;
+
+public class OverflowWPetliShort {
+
+	public static void main(String[] args) {
+		// przy okazji: pętla nieskończona to nie tylko while(true), ale też for(;;)
+		short x = 0;
+		for(;;) {
+			System.out.println(x++);
+		}
+
+	}
+
+}

src/main/java/p02_liczby/Rzutowania.java

+package p02_liczby;
+
+public class Rzutowania {
+
+	// "Hierarchia" typów prostych:
+	// byte < short < int < long < float < double
+	// char < int
+	
+	public static void main(String[] args) {
+		int x = 107;
+		float f = 3.14f;
+		long l3 = 13;
+
+		// rzutowanie niejawne - na zmienną typu "szerszego" można zapisać wartość typu "węższego" (widening)
+		long l = x;
+		float f2 = l3;
+		//NK x = l;
+		//NK l = f;
+		f = l;
+		
+		// rzutowanie jawne można stosować zawsze; czasem może wiązać się z "popsuciem" wartości liczbowej
+		x = (int) l;
+		System.out.println(x);
+		
+		// można stosować jawne rzutowanie nawet gdy nie jest konieczne
+		l = x;
+		l = (long) x;
+		System.out.println(l);
+		
+		l = 4_000_000_000L;
+		x = (int) l;
+		System.out.println(x); // zmieniona wartość, ostatnie 32 bity z zapisu tej liczby
+
+		f = 100.99F;
+		x = (int)f;  // obcina do wartości całkowitej
+		System.out.println(x); // 100
+		
+		f = 4e9f; // 4 * 10^9 czyli 4mld
+		x = (int)f; // po wyjściu poza zakres przyjmuje MAXINT / MININT
+		System.out.println(x);
+		
+		// Na zmienne typu byte, short i char można wpisywać konkretne wartości całkowite, o ile kompilator widzi, że mieszczą się w zakresie
+		
+		byte b1 = 100;
+		//NK byte b2 = 200;
+
+		x = 100;
+		//NK byte b3 = x;
+		
+		final int fi = 10;
+		b1 = fi; // jeśli wartość jest "stałą" (jest final i jest znana w czasie kompilacji)
+		
+		b1 = 50;
+		//NK b1 = x; // bo "nie każdy int mieści się w byte"
+		x = b1;  // OK, bo byte mieści się w int
+		
+		//NK int i3 = 3L;
+		
+		float f3 = 3L;
+		
+		
+		byte b = 13;
+		b = 15;
+		//NK b = 130;
+		
+		x = 15;
+		//NK b = x;
+		b = (byte)x;
+		
+		//NK wezByte(88);
+		wezByte((byte)88);
+		wezByte(b);
+		System.out.println();
+		
+		System.out.println(dajByte());
+		System.out.println(dajZnak());
+		System.out.println();
+		
+		l = 5_000_000_000L;
+		x = (int)l;
+		System.out.println(x);
+		// rzutowanie liczb całkowitych - bierzemye ostatnie bity z zapisu liczby w pamięci
+		// zobaczę to samo, co w int overflow gdy mnożyłem 5 * 1000000000
+		System.out.println("5mld long   rzut na int: " + x);
+		
+		double d = 5_000_000_000.0;
+		x = (int)d;
+		System.out.println("5mld double rzut na int: " + x);
+		// rzutowanie float i double na liczbę całkowitą - bierzemy wartość, która jest najbliżej,
+		// w tym przypadku będzie to Integer.MAX_VALUE
+		
+		byte b2 = 40, b3 = 50;
+		
+		// Operacje arytmetyczne + - * / %  - są zdefiniowane dla typu int, a nie dla byte i short
+		// dlatego ich ywniki trzeba zrzutowa, aby pisać na zmienne tych typów
+		//NK byte b4 = b2 + b3;
+		byte b4 = (byte)(b2 + b3);
+		
+		// ale bez rzutowania działają ++ i +=
+		
+		System.out.println(b2);
+		b2++;
+		System.out.println(b2);
+		
+		b2 += 10;
+		System.out.println(b2);
+	}
+	
+	static byte dajByte() {
+		return 65;
+	}
+
+	/* NK
+	static byte dajByteInaczej() {
+		int x = 65;
+		return x;
+	}
+	*/
+
+	static char dajZnak() {
+		return 65;
+	}
+	
+	static void wezByte(byte bbb) {
+		System.out.println(bbb);
+	}
+
+}

src/main/java/p02_liczby/WypiszZakresy.java

+package p02_liczby;
+ 
+public class WypiszZakresy {
+ 
+    public static void main(String[] args) {
+        System.out.println("byte  " + Byte.BYTES + " bajtów, od " + Byte.MIN_VALUE + " do " + Byte.MAX_VALUE);
+        System.out.println("short " + Short.BYTES + " bajtów, od " + Short.MIN_VALUE + " do " + Short.MAX_VALUE);
+        System.out.println("int   " + Integer.BYTES + " bajtów, od " +Integer.MIN_VALUE + " do " + Integer.MAX_VALUE);
+        System.out.println("long  " + Long.BYTES + " bajtów, od " +Long.MIN_VALUE + " do " + Long.MAX_VALUE);
+ 
+        System.out.println("char  " + Character.BYTES + " bajtów, od " + (int) Character.MIN_VALUE + " do " + (int) Character.MAX_VALUE);
+        System.out.println();
+        
+        // bez ograniczen: klasy BigInteger (calkowite) i BigDecimal (z ulamkiem)
+        
+        System.out.println("float  " + Float.BYTES + " bajtów, od " +Float.MIN_VALUE + " do " + Float.MAX_VALUE);
+        System.out.println("    min normal : " + Float.MIN_NORMAL);
+        System.out.println("double  " + Double.BYTES + " bajtów, od " +Double.MIN_VALUE + " do " + Double.MAX_VALUE);
+        System.out.println("    min normal : " + Double.MIN_NORMAL);
+        System.out.println();
+        
+        System.out.println("boolean : false i true");
+    }
+}

src/main/java/p02_liczby/Znaki.java

+package p02_liczby;
+
+public class Znaki {
+
+	public static void main(String[] args) {
+		System.out.println("A");
+		System.out.println("A" + 5);
+
+		System.out.println('A');
+		System.out.println('A' + 5);
+		System.out.println('A' + 'B');
+		System.out.println();
+		
+		
+		char c = 65; // można wpisywać konkretną wartość int, o ile mieści się w zakresie
+		//NK char d = -1;
+		
+		int x = 65;
+		int y = 'A';
+		//NK c = x;  // ale nie int-a ze zmiennej
+		c = (char)x;
+		System.out.println(c);
+		
+		x = c;
+		System.out.println(x);
+		x = (int)c;
+		System.out.println((int)c);
+		System.out.println();
+		
+		for(char znak = 'A'; znak <= 'Z'; znak++) {
+			System.out.print(znak + " ");
+		}
+		System.out.println();
+		
+		int ącki = 'Ą';
+		System.out.println(ącki);
+	}
+}