Projekt Zespołowy w Javie Dr Robert Kowalczyk Łódź 2019

Programowanie strukturalne Wykład 2 Programowanie strukturalne varia

Klasa String i jej optymalizacje Wyrażenia regularne Zagadnienia Liczby i duże liczby Losowanie liczb Klasa String i jej optymalizacje Wyrażenia regularne Obsługa plików w Javie Kolekcje w Javie

1. Liczby całkowite i BigInteger byte 1 bajt od -128 do 127 short 2 bajty od -32 768 do 32 767 int 4 bajty od -2 147 483 648 do 2 147 483 647 long 8 bajtów od -9 223 372 036 854 775 808 do 9 223 372 036 854 775 807 Wartości zmiennych typu całkowitego Long oznaczamy dopisując L, np. 4000000000L Jeśli typ long jest za mały możemy skorzystać z typu BigInteger. Można zamienić wartość long na BigInteger: BigInteger n = BigInteger.valueOf(1000 000 000 000 000 000L); lub BigInteger k = new BigInteger("100000000000000000000000000000");

1. BigInteger BigInteger n = BigInteger.valueOf(1000000000000000000L); System.out.println(n.multiply(n)); System.out.println(n.add(n)); System.out.println(n.subtract(n)); System.out.println(n.divide(n)); System.out.println(n.add(BigInteger.valueOf(5))); BigInteger k = new BigInteger("10000000000000000000000000000000"); System.out.println(k.add(n));

1. silnia(1000) public static String silnia(int n) { BigInteger s = new BigInteger("1"); for (int i = 1; i <= n; i++) { s = s.multiply(new BigInteger(i+"")); } return s.toString(); private static String[] splitToNChar(String text, int size) { List<String> parts = new ArrayList<>(); int length = text.length(); for (int i = 0; i < length; i += size) { parts.add(text.substring(i, Math.min(length, i + size))); return parts.toArray(new String[0]); String silnia = silnia(1000); String[] tabNapis = splitToNChar(silnia, 60); for (String s : tabNapis) System.out.println(s);

1. Liczby zmiennoprzecinkowe i BigDecimal float 4 bajty +- 3.40282347E+38F (6-7 cyfr ) double 8 bajtów +- 1.79769313486231570E+308 (15 cyfr znaczących) Prosty wynik operacji: System.out.println(2.0-1.1); daje 0.8999999999999999 W obliczeniach finansowych warto korzystać z typu BigDecimal. BigDecimal liczba1 = new BigDecimal("2.0"); BigDecimal liczba2 = new BigDecimal("1.1"); System.out.println(liczba1.subtract(liczba2)); 0.9

2. Metoda nextInt()i losowanie liczb Stosowanie metody nextInt()klasy Random posiada 3 podstawowe wady: - gdy n jest małą potęgą dwójki, to generowane liczby nextInt() % n powtarzają się po jakimś czasie, gdy n nie jest potęgą dwójki, niektóre liczby są generowane częściej niż inne, czasami metoda może zawieźć w ogóle i zwrócić błąd. int n = 2 * (Integer.MAX_VALUE / 3); int counter1 = 0; Random rnd = new Random(); for (int i = 0; i < 1000000; i++) if (Math.abs(rnd.nextInt()) % n < n/2) counter1++; System.out.println(counter1);

2. Metoda nextInt(int n)i losowanie liczb Stosowanie metody nextInt(int n)klasy Random eliminuje błędy wspomniane na poprzednim slajdzie. Random rnd = new Random(); int n = 2 * (Integer.MAX_VALUE / 3); int counter2 = 0; for (int i = 0; i < 1000000; i++) if (rnd.nextInt(n) < n/2) counter2++; System.out.println(counter2);

3. Klasa String i łączenie napisów Klasa String jest przydatna i ma wiele pożytecznych metod. Operator + to operator konkatenacji jednak mało przydatny w przypadku łączenia wielu ciągów ze sobą. long startTime = System.currentTimeMillis(); String napis = ""; for (int i = 1; i < 50000; i++) { napis += "abcd"; } long stopTime = System.currentTimeMillis(); long elapsedTime = stopTime - startTime; System.out.println(napis); System.out.println(elapsedTime);

3. Klasa StringBuilder i łączenie napisów Klasa String jest przydatna i ma wiele pożytecznych metod. Operator + to operator konkatenacji jednak mało przydatny w przypadku łączenia wielu ciągów ze sobą. long startTime = System.currentTimeMillis(); StringBuilder sb = new StringBuilder(""); for (int i = 1; i < 50000; i++) { sb.append("abcd"); } long stopTime = System.currentTimeMillis(); long elapsedTime = stopTime - startTime; System.out.println(sb); System.out.println(elapsedTime);

3. Klasa String porównywanie napisów Co się pokaże, po wykonaniu poleceń: String s1 = "abc"; String s2 = "ab"; s2 += "c"; String s3 = s2; String s4 = new String("abc"); System.out.println(s1==s2); System.out.println(s1==s3); System.out.println(s1==s4); System.out.println(s2==s3); System.out.println(s2==s4); System.out.println(s3==s4);

3. Klasa String porównywanie napisów Co się pokaże, po wykonaniu poleceń: String s1 = "abc"; String s2 = "ab"; s2 += "c"; String s3 = s2; String s4 = new String("abc"); System.out.println(s1==s2); System.out.println(s1==s3); System.out.println(s1==s4); System.out.println(s2==s3); System.out.println(s2==s4); System.out.println(s3==s4);

4. Wyrażenia regularne Wyrażenie regularne (ang. regular expression) to „wzorzec”, który opisuje grupę łańcuchów znaków. Możemy powiedzieć, że łańcuch znaków pasuje do wzorca jeśli dane wyrażenie regularne go opisuje. Na przykład wyrażenie regularne \d{2}-\d{3} opisuje zbiór kodów pocztowych w Polsce. Wyrażenia regularne składają się ze znaków, część z nich w pewnych kontekstach ma specjalne znaczenie. Znaczenie to interpretowane jest przez tak zwany silnik wyrażeń regularnych. Istnieje wiele silników wyrażeń regularnych, w związku z tym istnieją też pewne różnice pomiędzy wyrażeniami regularnymi rozumianymi przez te silniki. Mówimy wówczas o dialekcie języka wyrażeń regularnych.

4. Klasy Pattern i Matcher W języku Java wyrażenia regularne obsługiwane są przez dwie klasy z biblioteki standardowej. Są to Pattern i Matcher. Klasa Pattern reprezentuje wyrażenie regularne. Klasa Matcher zawiera wyrażenie regularne w postaci wzorca. Pattern compiledPattern = Pattern.compile("Robert"); Matcher matcher = compiledPattern.matcher("Nazywam sie Robert"); System.out.println(matcher.find()); System.out.println(matcher.matches());

4. Dopasowanie do wzorca Mam na imię Robert Robertkowski Robert find - true matches - false find – true matches - true find - ? matches – ? find – ? matches - ?

5. Strumienie w Javie Klasy strumieniowe Klasy buforujące wejście wyjście Strumienie bajtowe FileInputStream FileOutputStream Strumienie znakowe FileReader FileWriter Klasy buforujące wejście wyjście Strumienie bajtowe BufferedInputStream BufferedOutputStream Strumienie znakowe BufferedReader BufferedWriter

5. Czytanie z pliku Scanner sc = new Scanner(new File("plik.txt")); sc.hasNext() – sprawdzamy czy jest kolejny wyraz do czytania sc.next() – pobieramy kolejny wyraz lub BufferedReader br = new BufferedReader(new FileReader("plik.txt")); br.readyLine() – sprawdzamy czy jest kolejna linia do czytania br.readLine() – pobieramy kolejną linię

5. Pisanie do pliku PrintWriter pw = new PrintWriter(new File("plik.txt")); pw.print("Hello")) – zapis do pliku pw.flush()– opróżnia bufor lub BufferedWriter bw = new BufferedWriter(new FileWriter("plik.txt")); bw.write("Hello") – zapis do pliku bw.flush() – opróżnia bufor

5. Odwrócenie obrazka – System.gc() File imgFile = new File("zdj1.jpg"); BufferedImage img1 = ImageIO.read(imgFile); int w = img1.getWidth(); int h = img1.getHeight(); int dl = w*h; int[] buff1 = new int[dl]; img1.getRGB(0, 0, w, h, buff1, 0, w); int[] buff2 = new int[dl]; for (int i=0; i<dl; i++) buff2[i] = buff1[dl-i-1]; img1 = null; buff1 = null; System.gc(); BufferedImage img2 = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB); img2.setRGB(0, 0, w, h, buff2, 0, w); File outFile = new File("zdj2.jpg"); ImageIO.write(img2, "JPG", outFile);

6. Kolekcje w Javie Java Collection Framework to zestaw klas i interfejsów, które implementują powszechnie używane struktury danych kolekcji.

6. Listy Lista (ang. list) podobnie jak tablica, grupuje elementy. Jej główną przewagą nad tablicą jest to, że programista nie musi się przejmować rozmiarem listy, jest ona automatycznie powiększana wraz z dodawaniem nowych elementów. Listy w języku Java reprezentowane są przez interfejs java.util.List. Listy z definicji są kolekcjami dla których kolejność elementów jest istotna, mogą przechowywać ten sam obiekt po kilka razy. Podstawowymi przykładami implementacji interfejsu java.util.List są klasy java.util.LinkedList oraz java.util.ArrayList.

6. Operacje na listach List<String> listaImion1 = new ArrayList<>(); listaImion1.add("Robert"); listaImion1.add("Paweł"); List<String> listaImion2 = new ArrayList<>(); listaImion2.add("Darek"); listaImion2.addAll(listaImion1); System.out.println(listaImion2.contains("Robert")); System.out.println(listaImion2.get(0)); System.out.println(listaImion2.isEmpty()); System.out.println(listaImion2.indexOf("Darek")); System.out.println(listaImion2.lastIndexOf("Darek"));

6. Zbiory Zbiór (ang. set) to kolekcja, która służy do przechowywania unikalnych elementów. Zbiory w języku Java implementują interfejs java.util.Set. W przypadku zbioru nie jest istotna kolejność dodawanych elementów. Innymi słowy jeśli do zbioru dodamy na początku element X a później Y to przechodząc po kolei po elementach zbioru możemy dostać je w odwrotnej kolejności. Najważniejszą implementacją interfejsu Set jest klasa java.util.HashSet.

6. Operacje na zbiorach Set<String> zbiorImion1 = new HashSet<>(); zbiorImion1.add("Robert"); zbiorImion1.add("Paweł"); Set<String> zbiorImion2 = new HashSet<>(); zbiorImion2.add("Darek"); zbiorImion2.addAll(zbiorImion1); System.out.println(zbiorImion2.isEmpty()); System.out.println(zbiorImion2.size()); System.out.println(zbiorImion2.contains("Darek")); System.out.println(zbiorImion2.remove("Paweł"));

6. Konwersja lista <-> zbiór Konwersja lista do zbiór: List<String> lista = new ArrayList<>(); Set<String> zbior= new HashSet<String>(lista); Konwersja zbiór do lista: Set<String> zbior= new HashSet<String>(); List<String> lista = new ArrayList<>(zbior);

6. Mapa Mapa (ang. map) jest kolekcją, która pozwala przechować odwzorowanie zbioru kluczy na listę wartości. Innymi słowy w mapie możemy trzymać klucze, którym odpowiadają wartości. Klucze muszą być unikalne (dlatego pisałem o zbiorze kluczy), wartości natomiast mogą się powtarzać. Czyli pod kluczem A i pod kluczem B może być ta sama wartość X. Ale sytuacja odwrotna gdzie klucz X występuje dwa razy i jeden z nich wskazuje na element A a inny na element B nie jest możliwa.

6. Operacje na mapach Map<String, String> mapaPar1 = new HashMap<>(); mapaPar1("Marcin", "Adela"); mapaPar1("Marek", "Magda"); Map<String, String> mapaPar2 = new HashMap<>(); mapaPar2("Marek", "Ewa"); mapaPar2("Adam", "Ewa"); mapaPar1.putAll(mapaPar2); System.out.println(mapaPar1.get("Marek")); System.out.println(mapaPar1.remove("Marek")); System.out.println(mapaPar1.size()); System.out.println(mapaPar1.isEmpty()); System.out.println(mapaPar1.containsKey("Jan")); System.out.println(mapaPar1.containsValue("Adela"));

6. Przykład użycia mapy Dobrym przykładem użycia mapy może być utworzenia z danego pliku słownika w którym będą przechowywane wszystkie wyrazy pliku z liczbą ich wystąpień (statystyka pliku). Schemat rozwiązania mógłby być następujący: Tworzymy klasę Slowo implementującą interfejs Comparable z dwoma polami wyraz (String) i liczba (int), którą uczymy porównywania słów po parametrze liczba. Odczytujemy wszystkie wyrazy z pliku (wcześniej je czyszcząc) i przepisujemy je do mapy Map<String,Integer> zliczając wystąpienie każdego wyrazu. Tworzymy strukturę ArrayList<Slowo> przepisując do niej wszystkie słowa z mapy Map<String,Integer>. Sortujemy mapę Collections.sort(Map<String,Integer>).

Dziękuję za uwagę