4IT101 7.přednáška

1. 4IT101 7.přednáška Třída String a regulární výrazy Algoritmy v kolekcích Vnitřní a vnořené třídy

2. Třída String • Specielní konstanty • Přetížený operátor + • Readonly třída – žádná metoda nemění obsah řetězce, vždy vrací novou instanci • Porovnávání obsahů řetězců podle equals() ne ==

3. Formátování řetězců • metoda format() ve třídě String, metody printf() u výstupních operací (PrintStream či PrintWriter), • interně se používá třída java.util.Formatter příklady: String vystup = String.format("strana: %d/%d“, strana, pocetStran); System.out.printf("úhly – alfa: %f6.4, beta: %f6.4, gama: %f6.4%n“, alfa, beta, gama); System.out.printf("%-30s %2d %f4.2%n", prijmeni, semestr, prumer);

4. Formátování řetězců • specifikace formátu %[argument_index$][příznaky][šířka][.přesnost]konverze konverze: d celé číslo v dekadickém tvaru x, h celé číslo hex, f desetinné číslo g desetinné číslo, u velkých čísel vědecký formát t formátování datumu a času b boolean s text, výsledek toString(), popř. null příznaky - zarovnání vlevo 0 vypíše se úvodní nula + u čísel i znaménko + , vloží se oddělovač řádů dle národního prostředí

5. Lokalizace • některé operace s textem závisí na nastavení jazyka a země, tzv. Locale, • třída java.util.Locale, • Metody závislé na Locale: • format(), • toLowerCase, • toUpperCase() • při spuštění JVM se nastaví defaultní Locale,

6. StringBuffer StringBuilder • pomocné třídy pro práci s řetězci • „rychlejší“ operace s řetězci, int length() StringBuffer append(String str) StringBuffer append(Object o) StringBuffer insert(int pozice, String str) StringBuffer insert(int pozice, Object o) StringBuffer delete(int zacatek, int konec) String toString() String substring(int beginIndex) String substring(int beginIndex, int endIndex)

7. Použití třídy StringBuffer for (String klic: mapa.keySet()) { StringBuffer sb = new StringBuffer(); sb.append("zvire "); sb.append(klic); sb.append(", pocet kusu "); sb.append(mapa.get(klic)).toString(); String radek = sb.toString(); } for (String klic: mapa.keySet()) { String radek = "zvire "+klic+", pocet kusu "+mapa.get(klic); }

8. Použití třídy StringBuilder StringBuilder sb = new StringBuilder(60); for (String klic: mapa.keySet()) { sb.delete(0, sb.length()); sb.append("zvire ").append(klic); sb.append(", pocet kusu ").append(mapa.get(klic)); String radek = sb.toString(); }

9. Regulární výrazy • od verze 1.4 • regulární výraz je posloupnost znaků a symbolů, která definuje skupinu textových řetězců. • balíček java.util.regex: • třídy Pattern a Matcher • výjimka PatternSyntaxException • rozšíření třídy String

10. Třídy Pattern a Matcher Pattern p = Pattern.compile("a*b"); Matcher m = p.matcher("aaaaab"); boolean b = m.matches();

11. Metody třídy String využívající regulární výrazy matches(String vzor) replaceAll(String vzor, String repl) replaceFirst(String vzor, String repl) split(String vzor) split(String vzor, int n)

12. Syntaxe regulárních výrazů • jednotlivé znaky: x konkrétní znak \\ zpětné lomítko (jeden znak) \0n znak zadaný pomocí oktalové soustavy (0-377) \xhh znak zadaný pomocí hexadecimální soustavy \uhhhh znak z Unicode zadaný pomocí hexadecimální soustavy \ttabelátor \nznak LF (linefeed, newline) \rznak CR (carriage-return) \eznak escape

13. Syntaxe regulárních výrazů • množiny znaků, tj jeden ze znaků v zadané množině [abc] jednoduchá množina (tj. jeden ze znaků a b c) [^abc] negace, tj. žádný ze znaků a b c, [a-zA-Z] rozsah znaků (znaky a až z a znaky A-Z) . (tečka) libovolný znak \d číslice, tj. [0-9] \Dnečíslice, tj. [^0-9] \s “netisknutelné” znaky, tj mezera, tabelátor, znaky konce řádku a konce stránky, \Sopak \s

14. Syntaxe regulárních výrazů • označení hranic ^ začátek řetězce $konec řetězce \bhranice slova • znaky opakování ? předchozí znak bude 1x nebo 0x, * 0 a více opakování předchozího znaku, +předchozí znak je minimálně jedenkrát, {n} přesně n opakování předchozího znaku, {n,} minimálně n opakování předchozího znaku, {m,n} minimálně m a maximálně n opakování předchozího znaku,

15. Syntaxe regulárních výrazů • další operátory XY znaky X a Y musí být vedle sebe, X|Y buď znak X nebo znak Y, (X) označení skupiny, \nobsah n-té skupiny,

16. Zápis regulárního výrazu v Javě • V regulárním výrazu zapsaném ve zdrojovém textu musí být všechny \ zdvojené: "\\s+" " [0-9]+"

17. Příklady regulárních výrazů • Zadání: Napište regulární výraz, který odpovídá řetězci "ahoj" ahoj if (retezec.matches("ahoj")) { vhodnější je if (retezec.equals("ahoj"))

18. Příklady regulárních výrazů • Zadání: Napište regulární výraz, pomocí kterého je možno najít přebytečné mezery v textu \s+ if (retezec.matches("\\s+")) {

19. Příklady regulárních výrazů • napište regulární výraz, pomocí kterého lze zjistit, zda řetězec obsahuje pouze číslice [0-9]+ if (retezec.matches("[0-9]+")) {

20. Příklady regulárních výrazů • Zadání: napište regulární výraz pro kontrolu, zda řetězec je desetinné číslo ve formátu z desetinnou tečkou. -?\d+\.\d+ -?[0-9]+\.[0-9]+

21. Příklady regulárních výrazů • napište regulární výraz, který bude sloužit ke kontrole formátu rodného čísla s lomítkem. [0-9]{6}/[0-9]{3,4} if (retezec.matches("[0-9]{6}/[0-9]{3,4}")) {

22. Náhrada řetězců String retezec = "vstupní řádek"; String normalizovany = retezec.replaceAll("+"," "); mezera radek = radek.replaceAll("(knihu)|(knize)"," kniha");

23. Dělení řetězce na části – metoda split() String retezec = "seber knihu"; String [] poleSlovPrikazu = retezec.split(" "); if (poleSlovPrikazu.length >0 ) { slovo1 = poleSlovPrikazu[0]; // první slovo } if (poleSlovPrikazu.length >1 ) { slovo2 = poleSlovPrikazu[1]; // druhé slovo }

24. Třídění v kolekcích

25. Kolekce - třídění • řazení (porovnávání): • rozhraní Comparable • rozhraní Comparator • algoritmus pro třídění • Collections.sort(List seznam) • Arrays.sort() ... • TreeSet Arrays Collections

26. Rozhraní Comparable<T> • přirozené řazení • předepisuje jedinou metodu int compareTo( To) • výsledek porovnání: 0 rovná se <0 menší než parametr >0 větší než parametr • mnoho tříd implementuje rozhraní Comparable

27. Implementace rozhraní Comparable ve třídě Ucet public class Ucet implements Comparable<Ucet>{ private int cisloUctu; private String vlastnik; private double stav = 0; public int compareTo(Ucet druhyUcet){ if (this.cisloUctu == druhyUcet.cisloUctu){ return 0; } else { if (this.cisloUctu < druhyUcet.cisloUctu){ return -1; } else { return 1; } } }

28. Rozhraní Comparable • Používá se při vytváření TreeMap nebo TreeSet, při třídění v polích a listech pomocí: Arrays.sort(pole) Collections.sort(seznam) • Též pro hledání maxima/minima: Collections.max( kolekce ); Arrays.min( pole ); • Je vhodné, aby pro dvě instance, pro které equals() vrací true, vracela metoda compareTo() nulu.

29. Collections.max public static T max(Collection<T> coll) { Iterator<T> i = coll.iterator(); T candidate = i.next(); while(i.hasNext()) { T next = i.next(); if (next.compareTo(candidate) > 0) candidate = next; } return candidate; } zjednodušena deklarace generických typů

30. Rozhraní Comparator • deklaruje metodu int compare ( T prvni, T druhy ); • obvykle se implementuje v pomocné třídě deklarace rozhraní: package java.util; public interface Comparator<T> { int compare(T o1, T o2); boolean equals(Object obj); }

31. import java.util.Comparator; class PorovnavaniUctuDleAbecedy implements Comparator<Ucet> { public int compare (Ucet prvni, Ucet druhy){ String vlastnikPrvni = prvni.getVlastnik(); String vlastnikDruhy = druhy.getVlastnik(); return vlastnikPrvni.compareTo(vlastnikDruhy); } } Collections.sort(seznamUctu, new PorovnavaniUctuDleAbecedy()); Set mnozinaUctu = new TreeSet( new PorovnavaniUctuDleAbecedy());

32. import java.util.Comparator; class PorovnavaniUctuDleStavu implements Comparator<Ucet> { public int compare (Ucet prvni, Ucet druhy){ if (prvni.getStav() == druhy.getStav()) { return 0; } else { if (prvni.getStav() > druhy.getStav()) { return 1; } else { return -1; } } } } Ucet ucetSNejvyssimStavem = Collections.max(seznamUctu, new PorovnavaniUctuDleStavu());

33. Vnitřní a vnořené třídy

34. Datové členy Třída public class Jmeno { Datové atributy Statické datové atributy Statické metody Konstruktory Metody Vnitřní třídy Statické vnitřní třídy (vnořené) } Funkční členy Typové členy

35. public class A class B class C public class A class B class C Více tříd v jednom zdrojovém souboru • Několik samostatných tříd uložených v jednom souboru s koncovkou java • A.class • B.class • C.class • V souboru je jedna třída obsahující další • A.class • A$B.class • A$C.class A.java A.java

36. Charakteristika • Třídy definované uvnitř jiných tříd • Mohou být potomky libovolné viditelné třídy a implementovat libovolné viditelné rozhraní • Jsou uvnitř svých vnějších tříd, a proto vidí i na jejich soukromé členy • Mohou mít nastaveny kterýkoliv modifikátor přístupu (public, protected, „package private“, private)

37. Rozdělení • Globální (na úrovni atributů a metod) • vnitřní - inner • vnořené – embendded • Lokální (uvnitř metod a bloků kódu) • pojmenované • anonymní

38. Vnořené třídy • Deklarovány s modifikátorem static • Mohou být vnořené i do rozhraní • Jsou to zcela obyčejné třídy se všemi jejich možnostmi a omezeními

39. Vnitřní třídy • Instance vnitřní třídy jsou navázány na instanci vnější třídy • Získání instance vnější třídy: Vnější.this • Nesmějí mít statické atributy a metody –nevědělo by se, jak moc jsou statické • Pouze v rámci napojené instance • V rámci celé vnější třídy

40. public class Banka{ // deklarace datových atributů ........... private class PorovnavaniUctuDleAbecedy implements Comparator<Ucet> { public int compare (Ucet prvni, Ucet druhy){ String vlastnikPrvni = prvni.getVlastnik(); String vlastnikDruhy = druhy.getVlastnik(); return vlastnikPrvni.compareTo(vlastnikDruhy); } } private class PorovnavaniUctuDleStavu implements Comparator<Ucet> { public int compare (Ucet prvni, Ucet druhy){ if (prvni.getStav() == druhy.getStav()) { return 0; } else { if (prvni.getStav() > druhy.getStav()) { return 1; } else { return -1; } } } } .......................................... Collections.sort(seznamUctu, new PorovnavaniUctuDleAbecedy()); .......................... Ucet ucetSNejvyssimStavem = Collections.max(seznamUctu, new PorovnavaniUctuDleStavu()); ............................................

41. Anonymní vnitřní třídy Collections.sort(seznamUctu, new PorovnavaniUctuDleAbecedy()); • Deklarují se uvnitř metody, většinou jako parametr volané metody. • Mají pouze implicitní konstruktor. • Překladem vznikne samostatný soubor class pojmenovaný Vnější$pořadové číslo např. Banka$1.class Collections.sort(seznamUctu, new Comparator<Ucet>(){ public int compare (Ucet prvni, Ucet druhy){ String vlastnikPrvni = prvni.getVlastnik(); String vlastnikDruhy = druhy.getVlastnik(); return vlastnikPrvni.compareTo(vlastnikDruhy); } } );