Cesta Java NIO2 Path

1. Prehľad

V tomto článku sa dozvieme, ako používať nové I / O (NIO2) Cesta API v Jave.

The Cesta API v NIO2 tvoria jednu z hlavných nových funkčných oblastí dodávaných s jazykom Java 7 a konkrétne subset nového API systému súborov spolu s File API.

2. Inštalácia

Podpora NIO2 je súčasťou balíka java.nio.file balíček. Takže nastavovanie vášho projektu na používanie Cesta API je len otázkou importu všetkého v tomto balíku:

import java.nio.file. *;

Pretože ukážky kódu v tomto článku budú pravdepodobne spustené v rôznych prostrediach, poďme si poradiť s domovským adresárom používateľa:

private static String HOME = System.getProperty ("user.home");

Táto premenná bude ukazovať na platné umiestnenie v akomkoľvek prostredí.

The Cesty trieda je hlavným vstupným bodom pre všetky operácie zahŕňajúce cesty súborového systému. Umožňuje nám vytvárať a manipulovať s cestami k súborom a adresárom.

Stojí za zmienku, že operácie s dráhami majú väčšinou syntaktický charakter; nemajú žiadny vplyv na základný súborový systém a ani systém súborov nemá žiadny vplyv na to, či uspejú alebo zlyhajú. To znamená, že odovzdanie neexistujúcej cesty ako parametra operácie cesty nemá žiadny vplyv na to, či je úspešná alebo zlyhá.

3. Cestné operácie

V tejto časti si predstavíme hlavnú syntax použitú pri operáciách s cestami. Ako už z jeho názvu vyplýva, Cesta trieda je programové znázornenie cesty v súborovom systéme.

A Cesta objekt obsahuje názov súboru a zoznam adresárov použitých na vytvorenie cesty a používa sa na skúmanie, lokalizáciu a manipuláciu so súbormi.

Pomocná trieda, cesty java.nio.file (v množnom čísle) je formálny spôsob tvorby Cesta predmety. Má dve statické metódy na vytvorenie a Cesta z reťazca cesty:

Path path = Paths.get ("reťazec cesty");

Či už v ceste použijeme doprednú alebo spätnú lomku Reťazec, na tom nezáleží, API rieši tento parameter podľa požiadaviek základného súborového systému.

A z a java.net.URI objekt:

Path path = Paths.get (objekt URI);

Teraz ich môžeme vidieť v akcii.

4. Vytvorenie cesty

To Vytvor Cesta objekt z reťazca cesty:

@Test public void givenPathString_whenCreatesPathObject_thenCorrect () {Path p = Paths.get ("/ articles / baeldung"); assertEquals ("\ articles \ baeldung", p.toString ()); }

The dostať API môže prijať parameter premenných argumentov častí reťazca cesty (v tomto prípade článkov a baeldung) okrem prvej časti (v tomto prípade článkov).

Ak poskytneme tieto časti namiesto úplného reťazca cesty, použijú sa na vytvorenie objektu Path, nemusíme do časti premenných argumentov zahrňovať oddeľovače mien (lomítka):

@Test public void givenPathParts_whenCreatesPathObject_thenCorrect () {Path p = Paths.get ("/ articles", "baeldung"); assertEquals ("\ articles \ baeldung", p.toString ()); }

5. Načítanie informácií o ceste

Objekt Path si môžete predstaviť ako pomenovacie prvky ako postupnosť. Chodník String ako napr E: \ baeldung \ articles \ java sa skladá z troch prvkov mena t.j. baeldung, článkova java. Najvyšší prvok v adresárovej štruktúre by sa nachádzal na indexe 0, v tomto prípade baeldung.

Najnižší prvok v adresárovej štruktúre by bol umiestnený na indexe [n-1], kde n je počet prvkov názvu v ceste. Tento najnižší prvok sa nazýva názov súboru bez ohľadu na to, či ide o skutočný súbor alebo nie:

@Test public void givenPath_whenRetrievesFileName_thenCorrect () {Cesta p = Cesta.get ("/ articles / baeldung / logs"); Cesta fileName = p.getFileName (); assertEquals ("logy", nazov suboru.toString ()); }

K dispozícii sú metódy na načítanie jednotlivých prvkov pomocou indexu:

@Test public void givenPath_whenRetrievesNameByIndex_thenCorrect () {Cesta p = Cesta.get ("/ articles / baeldung / logs"); Názov cesty0 = getName (0); Názov cesty1 = getName (1); Názov cesty2 = getName (2); assertEquals ("articles", name0.toString ()); assertEquals ("baeldung", name1.toString ()); assertEquals ("logy", name2.toString ()); }

alebo podsekvencia cesty s použitím týchto rozsahov indexov:

@Test public void givenPath_whenCanRetrieveSubsequenceByIndex_thenCorrect () {Cesta p = Cesta.get ("/ articles / baeldung / logs"); Cesta subPath1 = p.subpath (0,1); Cesta subPath2 = p.subpath (0,2); assertEquals ("články", subPath1.toString ()); assertEquals ("articles \ baeldung", subPath2.toString ()); assertEquals ("articles \ baeldung \ logs", p.subpath (0, 3) .toString ()); assertEquals ("baeldung", p.subpath (1, 2) .toString ()); assertEquals ("baeldung \ logs", p.subpath (1, 3) .toString ()); assertEquals ("logy", p.subpath (2, 3) .toString ()); }

Každá cesta je spojená s nadradenou cestou alebo nulový ak cesta nemá rodiča. Rodičovský objekt cesty sa skladá z koreňového komponentu cesty, ak existuje, a z každého prvku v ceste okrem názvu súboru. Napríklad rodičovská cesta k / a / b / c je / a / b a to z / a je null:

@Test public void givenPath_whenRetrievesParent_thenCorrect () {Path p1 = Paths.get ("/ articles / baeldung / logs"); Cesta p2 = Paths.get ("/ articles / baeldung"); Cesta p3 = Cesta.get ("/ články"); Cesta p4 = Cesta.get ("/"); Cesta parent1 = p1.getParent (); Cesta parent2 = p2.getParent (); Cesta parent3 = p3.getParent (); Cesta parent4 = p4.getParenth (); assertEquals ("\ articles \ baeldung", parent1.toString ()); assertEquals ("\ articles", parent2.toString ()); assertEquals ("\", parent3.toString ()); assertEquals (null, parent4); }

Môžeme tiež získať koreňový prvok cesty:

@Test public void givenPath_whenRetrievesRoot_thenCorrect () {Path p1 = Paths.get ("/ articles / baeldung / logs"); Cesta p2 = Paths.get ("c: / articles / baeldung / logs"); Root cesty1 = p1.getRoot (); Root cesty2 = p2.getRoot (); assertEquals ("\", root1.toString ()); assertEquals ("c: \", root2.toString ()); }

6. Normalizácia cesty

Používa veľa súborových systémov “.” zápis označujúci aktuálny adresár a “..” na označenie nadradeného adresára. Môže sa vyskytnúť situácia, že cesta bude obsahovať nadbytočné informácie o adresári.

Zvážte napríklad nasledujúce reťazce cesty:

/baeldung/./articles /baeldung/authors/../articles / baeldung / články

Všetci sa rozhodli pre to isté miesto / baeldung / články. Prvé dva prepúšťajú, zatiaľ čo posledné nie.

Normalizácia trasy zahŕňa odstránenie nadbytočnosti. The Path.normalize () prevádzka sa poskytuje na tento účel.

Tento príklad by teraz mal byť samozrejmý:

@Test public void givenPath_whenRemovesRedundancies_thenCorrect1 () {Path p = Paths.get ("/ home /./ baeldung / articles"); Cesta cleanPath = p.normalize (); assertEquals ("\ home \ baeldung \ articles", cleanPath.toString ()); }

Aj tento:

@Test public void givenPath_whenRemovesRedundancies_thenCorrect2 () {Path p = Paths.get ("/ home / baeldung /../ articles"); Cesta cleanPath = p.normalize (); assertEquals ("\ home \ articles", cleanPath.toString ()); }

7. Konverzia cesty

Existujú operácie na prevod cesty do zvoleného formátu prezentácie. Na prevedenie ľubovoľnej cesty na reťazec, ktorý je možné otvoriť v prehliadači, použijeme znak toUri metóda:

@Test public void givenPath_whenConvertsToBrowseablePath_thenCorrect () {Path p = Paths.get ("/ home / baeldung / articles.html"); URI uri = p.toUri (); assertEquals ("súbor: /// E: /home/baeldung/articles.html", uri.toString ()); }

Cestu môžeme tiež previesť na jej absolútne zastúpenie. The toAbsolutePath metóda rieši cestu oproti predvolenému adresáru súborového systému:

@Test public void givenPath_whenConvertsToAbsolutePath_thenCorrect () {Path p = Paths.get ("/ home / baeldung / articles.html"); Cesta absPath = p.toAbsolutePath (); assertEquals ("E: \ home \ baeldung \ articles.html", absPath.toString ()); }

Keď sa však zistí, že cesta, ktorá sa má vyriešiť, je už absolútna, metóda ju vráti tak, ako je:

@Test public void givenAbsolutePath_whenRetainsAsAbsolute_thenCorrect () {Path p = Paths.get ("E: \ home \ baeldung \ articles.html"); Cesta absPath = p.toAbsolutePath (); assertEquals ("E: \ home \ baeldung \ articles.html", absPath.toString ()); }

Môžeme tiež konvertovať ľubovoľnú cestu na jej skutočný ekvivalent volaním súboru toRealPath metóda. Táto metóda sa pokúša vyriešiť cestu mapovaním jej prvkov do skutočných adresárov a súborov v súborovom systéme.

Čas použiť premennú, ktorú sme vytvorili v Nastaviť časť, ktorá ukazuje na domovské umiestnenie prihláseného používateľa v súborovom systéme:

@Test public void givenExistingPath_whenGetsRealPathToFile_thenCorrect () {Cesta p = Cesta.get (HOME); Cesta realPath = p.toRealPath (); assertEquals (HOME, realPath.toString ()); }

Vyššie uvedený test nám v skutočnosti veľa nehovorí o správaní sa tejto operácie. Najviditeľnejším výsledkom je, že ak cesta v súborovom systéme neexistuje, operácia vloží znak Výnimka IO, pokračuj v čítaní.

Pretože neexistuje lepší spôsob, ako tento bod priviesť domov, pozrite sa na ďalší test, ktorý sa pokúša previesť neexistujúcu cestu na skutočnú:

@Test (očakáva sa = NoSuchFileException.class) public void givenInExistentPath_whenFailsToConvert_thenCorrect () {Path p = Paths.get ("E: \ home \ baeldung \ articles.html"); p.toRealPath (); }

Test je úspešný, keď chytíme Výnimka IO. Skutočná podtrieda Výnimka IO že táto operácia hodí je NoSuchFileException.

8. Spojenie ciest

Spojenie ľubovoľných dvoch ciest je možné dosiahnuť pomocou vyriešiť metóda.

Zjednodušene môžeme nazvať vyriešiť metóda na ľubovoľnom Cesta a odovzdať a čiastočná cesta ako argument. Táto čiastočná cesta je pripojená k pôvodnej ceste:

@Test public void givenTwoPaths_whenJoinsAndResolves_thenCorrect () {Cesta p = Cesta.get ("/ baeldung / articles"); Cesta p2 = p.resolve ("java"); assertEquals ("\ baeldung \ articles \ java", p2.toString ()); }

Keď však reťazec cesty prešiel na vyriešiť metóda nie je a čiastočná cesta; predovšetkým absolútna cesta, potom sa vráti odovzdaná cesta:

@Test public void givenAbsolutePath_whenResolutionRetainsIt_thenCorrect () {Cesta p = Cesta.get ("/ baeldung / articles"); Cesta p2 = p.resolve ("C: \ baeldung \ articles \ java"); assertEquals ("C: \ baeldung \ articles \ java", p2.toString ()); }

To isté sa deje s každou cestou, ktorá má koreňový prvok. Reťazec cesty „Java“ nemá počas koreňovej cesty žiadny koreňový prvok „/ Java“ má koreňový prvok. Preto keď prejdete cestu s koreňovým prvkom, vráti sa ako:

@Test public void givenPathWithRoot_whenResolutionRetainsIt_thenCorrect2 () {Cesta p = Cesta.get ("/ baeldung / articles"); Cesta p2 = p.resolve ("/ java"); assertEquals ("\ java", p2.toString ()); }

9. Relativizujúce Cesty

Termín relativizujúci jednoducho znamená vytvorenie priamej cesty medzi dvoma známymi cestami. Napríklad, ak máme adresár / baeldung a v jeho vnútri máme ďalšie dva adresáre, ako je tento / baeldung / autori a / baeldung / články sú platné cesty.

Cesta k článkov vzhľadom k autorov by sa dalo opísať ako „Posunúť sa o jednu úroveň vyššie v hierarchii adresárov a potom do adresára článkov“ alebo .. \ články:

@Test public void givenSiblingPaths_whenCreatesPathToOther_thenCorrect () {Cesta p1 = Paths.get ("články"); Cesta p2 = Cesta.get ("autori"); Cesta p1_rel_p2 = p1.relativize (p2); Cesta p2_rel_p1 = p2.relativize (p1); assertEquals (".. \ autori", p1_rel_p2.toString ()); assertEquals (".. \ articles", p2_rel_p1.toString ()); }

Za predpokladu, že presunieme článkov adresár do autorov priečinok taký, že už nie sú súrodenci. Nasledujúce relativizačné operácie zahŕňajú vytvorenie cesty medzi baeldung a článkov a naopak:

@Test public void givenNonSiblingPaths_whenCreatesPathToOther_thenCorrect () {Cesta p1 = Paths.get ("/ baeldung"); Cesta p2 = Cesta.get ("/ baeldung / autori / články"); Cesta p1_rel_p2 = p1.relativize (p2); Cesta p2_rel_p1 = p2.relativize (p1); assertEquals ("autori \ články", p1_rel_p2.toString ()); assertEquals (".. \ ..", p2_rel_p1.toString ()); }

10. Porovnávanie ciest

The Cesta trieda má intuitívnu implementáciu rovná sa metóda, ktorá nám umožňuje porovnať dve cesty rovnosti:

@Test public void givenTwoPaths_whenTestsEquality_thenCorrect () {Cesta p1 = Cesta.get ("/ baeldung / articles"); Cesta p2 = Paths.get ("/ baeldung / articles"); Cesta p3 = Cesta.get ("/ baeldung / autori"); assertTrue (p1.equals (p2)); assertFalse (p1.equals (p3)); }

Môžete tiež skontrolovať, či cesta začína daným reťazcom:

@Test public void givenPath_whenInspectsStart_thenCorrect () {Path p1 = Paths.get ("/ baeldung / articles"); assertTrue (p1.startsWith ("/ baeldung")); }

Alebo končí iným reťazcom:

@Test public void givenPath_whenInspectsEnd_thenCorrect () {Path p1 = Paths.get ("/ baeldung / articles"); assertTrue (p1.endsWith ("články")); }

11. Záver

V tomto článku sme si ukázali operácie cesty v novom API systému súborov (NIO2), ktoré sa dodávali ako súčasť Java 7, a väčšinu z nich sme videli v akcii.

Ukážky kódu použité v tomto článku nájdete v projekte Github tohto článku.


$config[zx-auto] not found$config[zx-overlay] not found