# Práce se soubory a složkami (adresáři)

- Se soubory se dá pracovat jako s nedělitelnými jednotkami, kdy je lze přesouvat, kopírovat, mazat atd.
- Obsah souboru se rovněž dá číst a zapisovat

### Základní pojmy

- Některé základní pojmy již byly zmíněny, zde budou uvedeny systematicky

#### Soubor a složka (adresář)

- Soubor (file)
	- Základní jednotka uspořádání dat na disku (z pohledu uživatele i z pohledu programátora)
	- Obsahuje data v závislosti na typu souboru
	- Název souboru
		- Např. ```data.txt, TBBT.s10.e13.avi```
		- Jednoznačná identifikace souboru v rámci jedné složky
			- V jedné složce nemůžou být dva soubory se stejným jménem
			- POZOR!
				- Linux je „case-sensitive“ (citlivý na velikost písmen), jména ```soubor.txt``` a ```Soubor.txt``` jsou tedy různá a mohou být v jedné složce (ale není to rozumné)
				- Windows není „case-sensittive“, jména ```soubor.txt``` a ```Soubor.txt``` jsou tedy stejná a nemohou být v jedné složce
		- Délka názvu je omezena (např. ve Windows na 255 znaků), ale je dostačující
		- Název může obsahovat většinu běžných znaků s několika výjimkami (např. lomítko „/“ a zpětné lomítko „\“)
	- Přípona souboru 
		- Vše od poslední tečky do konce názvu souboru (tj. je součástí názvu)
		- Typicky udává typ souboru
		- Většina souborů příponu má, ale mít ji nemusí
	- Složka/adresář (folder/directory)
		- Složky mají hierarchickou strukturu
		- Název složky (adresáře)
			- Platí stejná pravidla a omezení jako pro soubory
		- Přípona složky
			- Složky příponu většinou nemají
			- Ale mohou ji mít 
		- Každá složka (adresář) může obsahovat další soubory a složky (adresáře) 
		- Ve skutečnosti se jedná o speciální soubor, který má v sobě (v nějaké formě) uložený seznam souborů a složek, které obsahuje
			- Podrobněji viz předmět KIV/ZOS

#### Cesta a související pojmy

- Cesta (ke složce či k souboru)
	- Posloupnost názvů složek, které jsou oddělené lomítkem „/“ (Linux i Windows) nebo zpětným lomítkem „\“ (Windows)
- Důležité složky (adresáře) se speciálním označením 
	- Kořenová složka (adresář) – root folder (directory)
		- Složka, která je v hierarchii nejvýše (sama v žádné složce neleží)
		- Označuje se lomítkem „/“ (v Linuxu i ve Windows) nebo zpětným lomítkem „\“ (ve Windows)
		- Ve Windows je kořenová složka na každém logickém disku (označeném písmenem)
		- V Linuxu je jen jedna kořenová složka a další disky se připojují do hierarchické struktury složek
			- Lze i ve Windows, ale příliš často se to nepoužívá 
	- Aktuální složka (adresář) – current folder (directory)
		- Složka, ve které se právě nacházíme (typicky složka, ze které je spuštěn náš program)
		- Označuje se jednou tečkou „.“
		- Tato speciální složka ukazuje sama na sebe a nachází se v každé složce
	- Nadřazená složka (adresář) – parent folder (directory)
		- Složka, která je v hierarchii bezprostředně nad aktuální složkou
		- Označuje se dvěma tečkami „..“
		- Tato speciální složka odkazující na nadřazenou složku aktuální složky (tj. ve které se aktuální složka nachází) se nachází v každé složce
		- V kořenové složce ukazuje stejně jako „.“ sama na sebe
- Absolutní cesta
	- Začíná v kořenové složce, začíná lomítkem
	- Např. /home/skola/ppa1
	- Např. D:\Users\tpotuzak\Skola\PPA1
	- Ve Windows má každý logický disk (označený písmenem) svou kořenovou složku, proto je písmeno (D:) součástí absolutní cesty – v rámci jednoho disku začíná absolutní cesta „\“
	- Při použití absolutní cesty je jedno, jaká je aktuální složka
	- Z každé aktuální složky ukazuje na stejný objekt (složku nebo soubor)
- Relativní cesta
	- Je relativní k aktuální složce – k jednomu objektu jsou relativní cesty z různých aktuálních složek různé
	- Může začínat
		- Aktuální složkou „.“ (v Linuxu často nutné, ve Windows není nutné) nebo názvem podřazené složky (ve Windows)
		- Nadřazenou složkou „..“
		- Např. ```./skola/ppa1```
- Úplné jméno souboru (či složky)
	- Jednoznačná identifikace souboru (či složky) v rámci celého souborového systému
	- Absolutní cesta včetně názvu souboru (či složky) 
	- Např. ```D:\Users\tpotuzak\Skola\PPA1\data.txt```

### Rozhraní Path a třídy Paths a Files

- Pro práci se soubory jako s celky se dají využít třídy ```Paths, Files``` a rozhraní ```Path``` z balíku ```java.nio.file```
	- Rozhraní ```Path``` reprezentuje cestu, tj. soubor nebo adresář (složku)
		- Podrobně o rozhraní viz předmět KIV/OOP 
		- V dalším textu se budeme k rozhraní ```Path``` chovat, jako by to byla třída 
	- Třída ```Files``` obsahuje mnoho statických metod pro práci se soubory 
		- Kromě práce se souborem jako celkem umožňuje i práci s obsahem souboru
- Lze pracovat se soubory i složkami
	- V názvech metod se používá se výhradně název „adresář“ („directory“), název „složka“ („folder“) se nepoužívá
	- S adresáři lze provádět téměř stejné operace jako se soubory (mazání, přesun, kopírování, atd.), proto existuje jedna třída pro práci jak se soubory tak s adresáři

#### Zajištění nezávislosti na operačním systému 

- Protože různé operační systémy používají různé oddělovače složek v cestě, je ve třídě ```File``` definována proměnná (řetězec) s oddělovačem, která je nastavená podle operačního systému, na kterém je program spuštěn
	- ```File.separator```
	- Tato proměnná by se měla používat, pokud vytváříme cestu z jednotlivých jmen adresářů
	- V Linuxu je její hodnota "/", ve Windows je její hodnota "\\"
	- Např. ```String jmeno = File.separator + "ppa1" + File.separator + " data.txt";```
	- Třída File je z balíku java.io a původně se používala pro práci se soubory jako s celky (místo ```Path```, ```Paths```, a ```Files```)
- Pokud místo této proměnné použijeme přímo jedno z lomítek, pak je lepší použít obyčejné lomítko „/“, protože funguje na Linuxu i na Windows
- Zpětné lomítko se navíc v Javě používá pro zápis speciálních znaků (např. „\\n“ pro konec řádky) a je tedy nutné ho zdvojovat „\\\\“ 

#### Základní operace s cestou

- Rozhraní ```Path```
	- Používá se jako parametr v mnoha metodách třídy ```Files``` (jako parametr určující soubor či složku, se kterou bude metoda pracovat)
	- Soubor či adresář (složka) reprezentovaný instancí ```Path``` může, ale nemusí existovat
	- Obsahuje pouze operace pro práce s cestou samotnou
- Vytvoření nové instance
	- Nová instance se nevytváří konstruktorem, ale s využitím metody třídy ```get()``` pomocné třídy ```Paths```
		- POZOR!
			- Jedná se o jinou třídu než je rozhraní ```Path```
			- Její metoda třídy ```get()``` vrací instanci rozhraní ```Path```
	- ```Path cesta = Paths.get(retezecSCestou);```
	- Např. ```Path soubor = Paths.get("data.txt");```
	- Např. ```Path soubor = Paths.get("D:\\ppa1\\data.txt");```
	- Je vhodné používat ```File.sepearator``` pro oddělení jednotlivých názvů adresářů
- Absolutní cesta
	- Metoda ```toAbsolutePath()```
	- Vrátí novou instanci ```Path``` reprezentující soubor nebo složku jako absolutní cestu
		- Pokud už současná instance je absolutní cesta, vrátí stejnou instanci
		- Pokud je současná instance relativní cesta, vytvoří z ní absolutní doplněním aktuálního adresáře (složky)
- Zjištění jména souboru či adresáře (složky)
	- Metoda ```getFileName()```
	- Vrátí poslední položku cesty (za posledním oddělovačem)
		- Pokud je cesta ukončena oddělovačem, nevadí to, metoda stejně vrátí poslední položku cesty, nikoliv prázdný řetězec
- Převod na ```File``` (dříve používáno místo ```Path```) a obráceně 
	- Metoda instance ```Path.toFile()```
		- Převede instanci ```Path``` na instanci ```File```
	- Metoda instance ```File.toPath()```
		- Převede instanci ```File``` na instanci ```Path```
	- Převod na řetězec
		- Standardní metoda ```toString()```

#### Práce se souborem nebo adresářem pomocí třídy Files

- Třída ```Files``` obsahuje mj. metody pro práci se souborem či adresářem jako celkem
	- Jedná se o metody třídy a jako parametr mají instanci rozhraní ```Path``` určující, s jakým souborem mají pracovat
	- Metody třídy ```Files``` pro práci se soubory a adresáři jako s celkem obecně vyhazují konkrétní výjimku odvozenou typicky od ```IOException```, podle toho, k jakému problému dojde
- Zjištění existence souboru
	- Metoda ```Files.exists(soubor)```
		- Vrátí ```true```, pokud zadaný soubor nebo adresář (instance ```Path```) fyzicky existuje na disku, jinak vrátí ```false```
- Zjištění, zda se jedná o adresář
	- Metoda ```Files.isDirectory(soubor)```
		- Vrací ```true```, pokud je zadaný souboru (instance ```Path```) adresář
		- Pokud objekt neexistuje, nebo je to soubor, vrací ```false```
- Zjištění informací o souboru nebo adresáři 
	- Metoda ```Files.getLastModifiedTime(soubor)```
		- Vrátí datum a čas poslední modifikace zadaného souboru nebo adresáře jako instanci třídy ```FileTime```
			- Metoda ```toString()``` této třídy vrací datum a čas v čitelném formátu
		- Pro neexistující soubory nebo adresáře vyhodí výjimku
	- Metoda ```Files.size(soubor)```
		- Vrátí velikost souboru v bytech
		- Pro neexistující soubor vyhodí výjimku
		- Pro adresář vrátí 0 
- Smazání souboru či adresáře 
	- Metoda ```Files.delete(soubor```
		- Smaže soubor nebo adresář
		- Pokud soubor nebo adresář neexistuje, nebo adresář není prázdný, vyhodí výjimku
- Přejmenování/přesunutí souboru či adresáře
	- Metoda ```Files.move(původníSoubor, cílovýSoubor)```
		- Přejmenuje nebo přesune soubor nebo adresář
		- Při neúspěchu (např. cílový soubor již existuje) vyhodí výjimku
- Kopírování souboru či adresáře
	- Metoda ```Files.copy(původníSoubor, cílovýSoubor)```
		- Překopíruje soubor nebo adresář
		- Pokud se jedná o adresář, nezkopíruje se jeho obsah
		- Při neúspěchu vyhodí výjimku
- Vytvoření adresáře
	- Metoda ```createDirectories(adresář)```
		- Vytvoří adresář (v případě nutnosti všechny dosud neexistující adresáře v cestě)
		- Při neúspěchu vyhodí výjimku