07. Třída String a regulární výrazy

Report
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:
d
x, h
f
g
t
b
s
celé číslo v dekadickém tvaru
celé číslo hex,
desetinné číslo
desetinné číslo, u velkých čísel vědecký formát
formátování datumu a času
boolean
text, výsledek toString(), popř. null
0
+
,
zarovnání vlevo
vypíše se úvodní nula
u čísel i znaménko +
vloží se oddělovač řádů dle národního prostředí
příznaky
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:
x
\\
\0n
377)
\xhh
\uhhhh
\t
\n
\r
\e
konkrétní znak
zpětné lomítko (jeden znak)
znak zadaný pomocí oktalové soustavy (0znak zadaný pomocí hexadecimální soustavy
znak z Unicode zadaný pomocí hexadecimální
soustavy
tabelátor
znak LF (linefeed, newline)
znak CR (carriage-return)
znak 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]
\D
nečíslice, tj. [^0-9]
\s
“netisknutelné” znaky, tj mezera, tabelátor,
znaky konce řádku a konce stránky,
\S
opak \s
Syntaxe regulárních výrazů
• označení hranic
^
$
\b
začátek řetězce
konec řetězce
hranice 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
XY
X|Y
(X)
\n
znaky X a Y musí být vedle sebe,
buď znak X nebo znak Y,
označení skupiny,
obsah 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(" +"," ");
mezera
radek = radek.replaceAll(" (knihu)|(knize) "," kniha ");
Dělení řetězce na části –
metoda split()
String retezec = "seber knihu";
String [] poleSlovPrikazu = retezec.split(" ");
if (poleSlovPrikazu.length >0 ) {
slovo1 = poleSlovPrikazu[0];
}
if (poleSlovPrikazu.length >1 ) {
slovo2 = poleSlovPrikazu[1];
}
// první slovo
// 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
Arrays
Collections
<<interface>>
Collection
<<interface>>
<<interface>>
List
Set
ArrayList
LinkedList
HashSet
TreeSet
Rozhraní Comparable<T>
• přirozené řazení
• předepisuje jedinou metodu
int compareTo ( T o )
• výsledek porovnání:
0
<0
>0
rovná se
menší než parametr
větší než parametr
• mnoho tříd implementuje rozhraní Comparable
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;
}
}
}
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<T> coll) {
Iterator<T> i = coll.iterator();
<<interface>>
Collections
List
Comparable
T candidate = i.next();
while(i.hasNext()) {
T next = i.next();
if (next.compareTo(candidate)
> 0) Ucet
ArrayList
candidate = next;
}
return candidate;
}
zjednodušena deklarace generických typů
Rozhraní Comparator
• deklaruje metodu
int compare ( T prvni, T druhy );
deklarace rozhraní:
• obvykle se implementuje v pomocné
package java.util;
třídě
public interface Comparator<T> {
int compare(T o1, T o2);
boolean equals(Object obj);
}
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());
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());
Vnitřní a vnořené třídy
Třída
Datové členy
public class Jmeno {
Datové atributy
Statické datové atributy
Statické metody
Konstruktory
Metody
Funkční členy
Vnitřní třídy
Statické vnitřní třídy (vnořené)
}
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
• public
A.class
class A
• B.class
class B
• C.class
class C
A.java
• V souboru je jedna třída obsahující
další
•public
A.class
class A
class B
• A$B.class
• A$C.class
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<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;
Anonymní vnitřní třídy
Collections.sort(seznamUctu, new PorovnavaniUctuDleAbecedy());
• Deklarují se uvnitř metody, většinou
jako parametr volané metody.
Collections.sort(seznamUctu, new Comparator<Ucet>(){
• Mají
implicitní
konstruktor.
publicpouze
int compare
(Ucet prvni,
Ucet druhy){
String vlastnikPrvni
= prvni.getVlastnik();
• Překladem
vznikne samostatný
soubor
String vlastnikDruhy = druhy.getVlastnik();
class pojmenovaný
Vnější$pořadové
return vlastnikPrvni.compareTo(vlastnikDruhy);
}
číslo
např. Banka$1.class
} );

similar documents