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

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

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);

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

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,

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)

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); }

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(); }

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

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

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)

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

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

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,

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

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]+"

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"))

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+")) {

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]+")) {

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]+

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}")) {

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

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 }

Třídění v kolekcích

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

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

Implementace rozhraní Comparable ve třídě Ucet public class Ucet implements Comparable { 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; }

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.

Collections.max public static T max(Collection coll) { Iterator 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ů

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 { int compare(T o1, T o2); boolean equals(Object obj); }

import java.util.Comparator; class PorovnavaniUctuDleAbecedy implements Comparator { 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());

import java.util.Comparator; class PorovnavaniUctuDleStavu implements Comparator { 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());

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

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

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 public class A class B class C public class A class B class C A.java

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)

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í

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

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

public class Banka{ // deklarace datových atributů private class PorovnavaniUctuDleAbecedy implements Comparator { public int compare (Ucet prvni, Ucet druhy){ String vlastnikPrvni = prvni.getVlastnik(); String vlastnikDruhy = druhy.getVlastnik(); return vlastnikPrvni.compareTo(vlastnikDruhy); } private class PorovnavaniUctuDleStavu implements Comparator { 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());

Anonymní vnitřní třídy 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 PorovnavaniUctuDleAbecedy()); Collections.sort(seznamUctu, new Comparator (){ public int compare (Ucet prvni, Ucet druhy){ String vlastnikPrvni = prvni.getVlastnik(); String vlastnikDruhy = druhy.getVlastnik(); return vlastnikPrvni.compareTo(vlastnikDruhy); } } );