gotowe przykłady dot. liczb

src/main/java/gotowe1/p06_liczby/BityIBajty.java

+package gotowe1.p06_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/gotowe1/p06_liczby/Ciekawostki.java

+package gotowe1.p06_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(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/gotowe1/p06_liczby/Dzielenie.java

+package gotowe1.p06_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/gotowe1/p06_liczby/JakSprawdzicOverflow.java

+package gotowe1.p06_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/gotowe1/p06_liczby/LiteralyLiczbowe.java

+package gotowe1.p06_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/gotowe1/p06_liczby/Mnozenie1_Int.java

+package gotowe1.p06_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/gotowe1/p06_liczby/Mnozenie2_Long.java

+package gotowe1.p06_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/gotowe1/p06_liczby/Mnozenie3_Double.java

+package gotowe1.p06_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/gotowe1/p06_liczby/WypiszZakresy.java

+package gotowe1.p06_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");
+    }
+}