# Řetězce a práce s nimi

- Třída ```String```
	- Jedna z nejpoužívanějších tříd z Java Core API
	- Řetězcové konstanty (literály – texty uzavřené do uvozovek, např. "Ahoj") používáme od začátku předmětu KIV/PPA1

### Specifické vlastnosti třídy String

- ```String``` je třída, jednotlivé řetězce (tj. texty) jsou její instance uložené na haldě (na heapu)
- Z praktických důvodů má však některé vlastnosti, které u jiných tříd nejsou

#### Vytvoření řetězce bez operátoru new

- Jak bylo vidět ve všech příkladech, které dosud vypisovaly text, instance třídy ```String``` může vzniknout i bez operátoru ```new```
	- Vznikne zápisem literálu (nepojmenované konstanty)
		- Např. ```String pozdrav = "Ahoj!";```
		- Např. ```System.out.println("Nazdar!");```
	- Tento postup jsme používali dosud (aniž jsme věděli o tom, že vznikají instance třídy ```String```)
	- Tento postup se používá běžně
- Je možné i přímo vytvořit novou instanci třídy String operátorem ```new```
	- Třída ```String``` obsahuje několik konstruktorů umožňující vytvořit řetězec z pole znaků, pole bytů, atd.
	- Je možné i vytvořit nový řetězec z jiného řetězce
		- Např. ```String pozdrav = new String("Ahoj!");```
		- Tento zápis NEPOUŽÍVAT
		- Protože samotný zápis literálu "```Ahoj```" způsobí vytvoření nové instance třídy ```String```, volání new ```String()``` zbytečně vytvoří další instanci

#### Konstantnost řetězce

- Řetězce v Javě (tj. instance třídy ```String```) jsou konstantní, neměnné (immutable)
	- Nelze do nich přidávat text, mazat, nebo měnit jednotlivé znaky
	- Veškeré metody zdánlivě upravující řetězec ve skutečnosti vytvoří novou instanci třídy ```String``` a text v původní instanci zůstane nedotčen
- Existují třídy pro práci s měnitelným řetězcem
	- Třída StringBuilder
	- Třída StringBuffer
	- Přesto si ve většině případů vystačíme s třídou ```String```
		- To, že při změně obsahu řetězce dojde k vytvoření nové instance a původní zůstane nezměněná, nám nevadí (v podstatě si toho nevšimneme)

#### Spojení řetězců pomocí operátoru „+“ (zřetězení)

- Od začátku jsme běžně používali
	- Především v metodě ```System.out.println()```
- Operátor „+“ spojí dva řetězce (operandy) a vytvoří novou instanci obsahující texty obou řetězců (operandů)
- Operátor „+“ také umožňuje připojit k řetězci libovolný datový typ
	- Hodnota daného typu se převede na řetězec
	- Alespoň jeden operand musí být řetězec, pokud ne, má operátor „+“ význam sčítání
		- Pro přehlednost je lepší začínat řetězcem, pokud nechceme začínat uvozujícím textem, lze použít prázdný řetězec
	- Časté je použití přímo v metodě ```System.out.println()```

### Práce s řetězci

- Metody pro práci s řetězci jsou převážně **metody instance třídy String**
- Proto se volají nad referenční proměnnou ukazující na instanci řetězce
	- ```referenčníProměnná.názevMetody(parametry);```
	- Např. ```pozdrav.charAt(0);```
	- Stejné jako u jiných objektů
- Protože instance řetězce vznikne pouhým zapsáním literálu, lze nad ním rovnou volat metody bez nutnosti použití referenční proměnné
	- Např. ```"Ahoj".charAt(0); //Funkcni ale nepouzivat```
	- NEPOUŽÍVAT!

#### Práce s jednotlivými znaky a délka řetězce

- Řetězec si lze představit jako speciální konstantní pole znaků
	- Ale jedná se o instanci třídy, nelze s ní pracovat jako s polem – tj. přistupovat k jednotlivým znakům pomocí hranatých závorek „[“ a „]“
	- Pole znaků (tj. ```char[]```) je uvnitř řetězce skutečně obsaženo
- Pro následující příklady předpokládejte deklaraci
	- ```String pozdrav = "Nazdar";```
- Délka řetězce
	- Metoda ```length()```
		- POZOR! – Je to metoda, nikoliv proměnná, jako u polí (tj. musí se uvést závorky)
		- Vrací počet znaků řetězce (včetně bílých znaků)
	- ```int delka = pozdrav.length(); //delka bude 6```
- Znak na zadané pozici
	- Metoda ```charAt(indexZnaku)```
	- Znaky mají index podobně jako prvky pole číslované od 0 do délka řetězce - 1
	- ```char znak = pozdrav.charAt(0); //znak bude 'N'```
- Index prvního výskytu znaku/podřetězce
	- Metoda ```indexOf(znak/podřetězec)```
	- Vrátí index prvního výskytu znaku (podřetězce) v řetězci, nebo -1, pokud znak (podřetězec) není nalezen
	- ```int index1 = pozdrav.indexOf('a'); //index1 bude 1```
	- ```int index2 = pozdrav.indexOf("zd"); //index2 bude 2```
	- ```int index3 = pozdrav.indexOf("j"); //index3 bude -1```
- Index posledního výskytu znaku/podřetězce
	- Metoda ```lastIndexOf```(```znak/podřetězec```)
	- Vrátí index posledního výskytu znaku (podřetězce) v řetězci, nebo -1, pokud znak (podřetězec) není nalezen
	- ``int li1 = pozdrav.lastIndexOf('a'); //li1 bude 4``
	- ```int li2 = pozdrav.lastIndexOf("Na "); //li2 bude 0 ```
- Náhrada všech výskytů znaku v řetězci
	- Metoda ```replace(puvodníZnak, novýZnak)```
	- ```String s2 = pozdrav.replace('a', 'e'); //"Nezder"```

#### Porovnání řetězců

- Řetězce jsou instance třídy ```String```
- Porovnání pomocí operátoru „```==```“, pouze zjistí, zda se jedná o stejné instance **nepoužívat**
- **Porovnání podle obsahů** (důsledně včetně velikosti písmen) – **shodné/rozdílné**
	- Metoda ```equals```(```jinýŘetězec```)
	- Výsledek ```true``` (řetězce jsou shodné) nebo ```false``` (řetězce jsou rozdílné)
- Porovnání podle obsahů **bez ohledu na velikost písmen** – **shodné/rozdílné**
	- Metoda ```equalsIgnoreCase```(```jinýŘetězec```)
	- Výsledek ```true``` (řetězce jsou shodné bez ohledu na velikost písmen) nebo ```false``` (řetězce jsou rozdílné bez ohledu na velikost písmen) 
- Porovnání podle obsahů (**důsledně včetně velikosti písmen**) – **větší/menší/stejný**
	- Metoda ```compareTo```(```jinýŘetězec```)
	- Výsledek 0 (řetězce jsou shodné), nebo záporné číslo (první řetězec je „menší“ než druhý – tj. je blíže začátku abecedy), nebo kladné číslo (první řetězec je „větší“ než druhý – tj. je dále od začátku abecedy)
	- Výsledek 0 (řetězce jsou shodné), nebo záporné číslo (první řetězec je „menší“ než druhý – tj. je blíže začátku abecedy), nebo kladné číslo (první řetězec je „větší“ než druhý – tj. je blíže konci abecedy)
- POZOR! – Návratové hodnoty metod ```compareTo…()```
	- Vrácené záporné a kladné číslo (když řetězce nejsou shodné) nemusí být (a není) jen -1 nebo 1
	- Návratovou hodnotu metody je třeba porovnávat pomocí operátorů „>“ a „<“, nikoliv porovnáním operátorem „==“ s -1 či 1 
- **Test začátku a konce řetězce**
	- Výsledek ```true```, pokud řetězec začíná/končí zadaným podřetězcem, jinak vrací ```false```
	- Metoda ```startsWith(prefix)```
	- Metoda ```endsWith(postFix)```
	- Metoda ```startsWithIgnoreCase(prefix)```
	- Metoda ```endsWithIgnoreCase(postFix)```

#### Získání podřetězce z řetězce

- Stále předpokládáme deklaraci ```String pozdrav = "Nazdar";```
- Získání podřetězce od zadaného indexu (**včetně**) do konce
	- Metoda ```substring(indexOd)```
	- ```String p1 = pozdrav.substring(2); //p1 bude "zdar"```
- Získání podřetězce od zadaného indexu (**včetně**) do zadaného indexu (**vyjma**)
	- Metoda ```substring(indexOd, indexDo)```
	- ```String p2 = pozdrav.substring(0, 2); //p2 bude "Na"```
- Odstranění bílých znaků ze začátku a konce řetězce
	- Metoda ```trim()```
	- Uvažujme deklaraci ```String bz = "\r\n \tahoj \t\n\r";```
	- ```String oriznuty = bz.trim(); //oriznuty bude "ahoj"```

### Konverze řetězce na jiné datové typy a obráceně

- Relativně časté operace
	- **Převod řetězce na číselný datový typ**
		- Typicky při vstupu (když nepoužíváme Scanner, nebo je vstup komplikovanější, nebo v GUI)
		- Číselný datový typ je potřeba, abychom mohli provádět aritmetické operace
		- ```Např. "1" + "2" je řetězec "12", ale 1 + 2 je 3```
	- **Převod čísla na řetězec**
		- Implicitně se provádí při každém výstupu
		- Explicitně, když chceme využít operace nad řetězci např. pro čísla (např. zjištění počtu znaků (tj. číslic), zřetězení s řetězcem)
	- **Převod instance (objektu) na řetězec**
		- Pokud chceme instanci vypsat

#### Konverze řetězce na jiné datové typy

- Pro základní datové typy se používá metoda ```Typ.parseTyp(řetězec)``` z příslušné obalovací třídy základního datového typu 
	- Jedná se o metody třídy, volá se s názvem třídy, není potřeba vytvářet instanci
		- Např. ```int i = Integer.parseInt("42");```
		- Např. ```long l = Long.parseLong("2444111333");```
		- Např. ```double d = Double.parseDouble("5.972E24");```
		- Např. ```boolean b = Boolean.parseBoolean("false");```
	- Pro objekty
		- Není žádný standardní a obecný postup pro převod řetězce na instanci jiné třídy 

#### Konverze jiných datových typů na řetězec

- Běžně se využívá schopnost operátoru zřetězení „+“ převádět jiné datové typy (základní datové typy a instance tříd) na řetězec
	- Pro základní datové typy funguje přímočaře
	- Pro objekty také – objekt se převede na řetězec implicitním voláním metody ```toString()```
		- Pokud je metoda ```toString()``` překryta, funguje dobře
- Pro pole je potřeba použít metodu třídy ```Arrays.toString(pole)```
	- Pokud se použije pouze operátor „+“, použije se implicitní textová reprezentace pole (např. ```[I@15db9742```)
- Pro základní datové typy existuje další možnost – metoda ```Typ.toString (hodnota)``` z příslušné obalovací třídy základního datového typu
	- Např. ```String s = Integer.toString(42); //s bude "42"```
- Pro základní datové typy a pro instance tříd existuje další možnost – metoda třídy ```valueOf(hodnota)``` třídy ```String```
	- Metoda je překrytá pro všechny základní datové typy a objekty
	- Např. ```String s = String.valueOf(42) //s bude "42"```

### Rozdělení řetězce na podřetězce

- Často je potřeba **rozdělit řetězec na několik podřetězců** podle oddělovače (mezer, bílých znaků, čárek, teček, pomlček či jiné interpunkce či jiného znaku)
	- Metoda instance ```split(regulárníVýraz)``` ve třídě ```String```
	- Metoda má jako parametr regulární výraz
		- Regulární výraz
			- Řetězec popisující celou množinu řetězců => mnohé znaky tak mají speciální význam 
		- Parametrem tedy není jen znak, podle kterého se má řetězec rozdělit 
		- Některé znaky (např. mezera) nemají speciální význam a lze je tak použít bez problémů (tj. ```split(" ")```)
		- Některé znaky mají speciální význam a je třeba použít tzv. „escape“ sekvenci
			- Zpětné lomítko „\“ před znak, který chceme použít => zruší se tím speciální význam znaku
			- Protože však zpětné lomítko má speciální význam i v řetězcových a znakových literálech (umožňuje napsat speciální znaky, např. konec řádky „\n“), je třeba napsat zpětná lomítka
	- Metoda vrací pole řetězců, délka pole záleží na počtu podřetězců dvě „\\“

### Proměnný řetězec

- V některých případech (ač jich není mnoho) opravdu potřebujeme, aby se při každé změně textu řetězce nevytvářela nová instance => je potřeba měnitelný (mutable) řetězec
	- Pokud provádíme v řetězci mnoho změn a použili bychom třídu ```String```, **vytvářelo by se mnoho instancí** – pro každou změnu se vytvoří nová, což zbytečně zabírá paměť a zpomaluje program (vytvoření instance nějakou dobu trvá)
	- Pokud by šel **řetězec měnit**, vystačíme si s jednou instancí

#### Třída StringBuilder

- **Proměnný/měnitelný řetězec** (sekvence znaků)
- Vytvoření instance třídy ```StringBuilder```
	- Lze zadat řetězec, nebo kapacitu 
		- Kapacita se udává kvůli efektivitě – pokud je dostatečná, nemusí se během práce s řetězcem (při jeho prodloužení) kapacita navyšovat
		- Je však možné do instance třídy ```StringBuilder``` vložit/přidat řetězec nebo jiný datový typ (viz níže) a překročit aktuální kapacitu kapacita se automaticky navýší
	- Např. ```StringBuilder sb1 = new StringBuilder("Ahoj");```
	- Např. ```StringBuilder sb2 = new StringBuilder(100);```
- Práce se znaky
	- Zjištění konkrétního znaku
		- Metoda ```charAt(index)```
		- Vrátí znak na zadaném indexu
		- Např. ```int i = sb1.charAt(3); //'o'```
	- Nastavení konkrétného znaku
		- Metoda ```setCharAt(index, znak)```
		- Nastaví znak na zadaném indexu na zadaný znak
		- Např. ```sb1.setCharAt(0, 'E'); //"Ehoj"```
- Délka řetězce
	- Zjištění délky uloženého řetězce
		- Metoda ```getLength()```
		- Vrátí délku řetězce
		- Např. ```int d1 = sb1.getLength(); //4```
		- Např. ```int d2 = sb2.getLength(); //0```
- Nastavení délky řetězce
	- Metoda ```setLength(délka)```
	- Nastaví délku řetězce
	- Pokud se řetězec prodlužuje, přidané znaky budou mít hodnotu 0
	- Pokud se řetězec zkracuje, znaky nad zadanou délku se oříznou
	- Např. ```sb2.setLength(10); //10 znaků hodnoty 0```
	- Např. ```sb2.setLength(0); //Prazdny retezec```
- Převrácení řetězce 
	- Metoda ```reverse()```
	- Převrátí pořadí znaků
	- Např. ```sb1.reverse(); //"johE"```
- Přidání/vložení libovolného datového typu
	- Přidání libovolného datového typu
		- Metoda ```append(hodnota)```
		- Metoda překryta pro všechny základní datové typy, ```Object```, ```String``` a ```StringBuilder```
		- Např. ```sb2.append(true); //"true"```
		- Např. ```sb1.append(sb2); //"johEtrue"```
	- Vložení libovolného datového typu
		- Metoda ```insert(index, hodnota)```
		- Metoda překryta pro všechny základní datové typy, ```Object``` a ```String```
		- Znaky na pozici ```index``` a dále se odsunou o počet vložených znaků
		- Např. ```sb1.insert(3, 42); //"joh42Etrue"```
	- Smazání podřetězce či znaku
		- Smazání podřetězce
			- Metoda ```delete(začátek, konec);```
			- Smaže podřetězec začínající na pozici začátek a končící před pozicí ```konec```
			- Např. ```sb1.delete(2, 5); //"joEtrue"```
		- Smazání znaku
			- Metoda ```deleteCharAt(index)```
			- Smaže znak na zadaném indexu
			- Např. ```sb1.deleteCharAt(2); //"jotrue"```

#### Třída StringBuffer

- Proměnný/měnitelný řetězec (sekvence znaků), která má téměř stejné metody a téměř stejné použití jako třída ```StringBuilder```
	- Starší a pomalejší
	- Vhodný, pokud má s proměnným řetězcem pracovat více vláken (viz předmět KIV/PGS)

### Třída Character

- Obalovací třída pro základní datový typ ```char```
- Obsahuje mnoho konstant důležitých pro práci s různými speciálními znaky (např. z jiných abeced než latinky)
- Obsahuje mj. metody pro určení typu znaku

#### Určení typu znaku

- Metody pro určení typu znaku třídy ```Character```
	- Jedná se o metody třídy, volají se nad názvem třídy, vrací ```true```, pokud znak je daného typu (podle názvu metody), jinak vrací ```false```
	- Metody pracují správně i pro speciální znaky (které např. nejsou z latinky)
	- Metoda ```isDigit(znak)```
		- Zjistí, jestli je zadaný znak číslice
		- Např. ```Character.isDigit('3'); //true```
		- Např. ```Characet.isDigit('A'); //false```
	- Metoda ```isLetter(znak)```
		- Zjistí, jestli je zadaný znak písmeno
		- Např. ```Character.isLetter('3'); //false```
		- Např. ```Character.isLetter('A'); //true```
	- Metoda ```isLetterOrDigit(znak)```
		- Zjistí, jestli je zadaný znak písmeno nebo číslice
		- Např. ```Character.isLetterOrDigit('3'); //true```
		- Např. ```Character.isLetterOrDigit('A'); //true```
	- Metoda ```isWhitespace(znak)```
		- Zjistí, jestli je zadaný znak bílý znak
		- POZOR! – druhé „```s```“ v názvu metody je také malé
		- Např. ```Character.isWhitespace(' '); //true```
		- Např. ```Character.isWhitespace('\n'); //true```
	- Metoda ```isLowerCase(znak)```
		- Zjistí, jestli je zadaný znak malé písmeno
		- Např. ```Character.isLowerCase('a'); //true```
		- Např. ```Character.isLowerCase('A'); //false```
		- Např. ```Character.isLowerCase('3'); //false```
	- Metoda ```isUpperCase(znak)```
		- Zjistí, jestli je zadaný znak velké písmeno
		- Např. ```Character.isUpperCase('a'); //false```
		- Např. ```Character.isUpperCase('A'); //true```
		- Např. ```Character.isUpperCase('3'); //false```