streamalism.org

1. Áttekintés

Ebben a cikkben megtanuljuk az új I / O (NIO2) használatát Pálya API Java-ban.

A Pálya Az NIO2-ben lévő API-k jelentik az egyik legfontosabb új funkcionális területet, amelyet a Java 7-el együtt szállítottak, és kifejezetten az új fájlrendszer-API egy részhalmaza a File API-k mellett.

2. Beállítás

Az NIO2 támogatás a java.nio.file csomag. Tehát a projekt beállítása a Pálya Az API-k csupán a csomag minden importálásának kérdése:

import java.nio.file. *;

Mivel az ebben a cikkben szereplő kódminták valószínűleg különböző környezetekben fognak futni, nyerjünk egy fogantyút a felhasználó saját könyvtárában:

privát statikus karakterlánc HOME = System.getProperty ("user.home");

Ez a változó minden környezetben érvényes helyre mutat.

A Útvonalak osztály az összes művelet fő belépési pontja, amely a fájlrendszer útvonalait tartalmazza. Ez lehetővé teszi számunkra, hogy létrehozzuk és kezeljük a fájlokhoz és könyvtárakhoz vezető utakat.

Érdemes megjegyezni, hogy az útműveletek főként szintaktikai jellegűek; nincsenek hatással az alapul szolgáló fájlrendszerre, és a fájlrendszer sem befolyásolja, hogy sikerrel járnak-e vagy sem. Ez azt jelenti, hogy egy nem létező útvonal áthaladása a pályaművelet paramétereként nem befolyásolja, hogy sikerül-e vagy nem.

3. Útvonal műveletek

Ebben a szakaszban bemutatjuk az útvonal műveletekben használt fő szintaxist. Ahogy a neve is mutatja, a Pálya osztály egy fájl elérési útjának programozott ábrázolása a fájlrendszerben.

A Pálya Az objektum tartalmazza az elérési út létrehozásához használt fájlnevet és könyvtárlistát, és fájlok megvizsgálására, megkeresésére és kezelésére használják.

A segítő osztály, java.nio.file.Paths (többes számban) a létrehozás formális módja Pálya tárgyakat. Két statikus módszerrel rendelkezik a Pálya egy útvonal karakterláncból:

Path path = Paths.get ("elérési útvonal");

Függetlenül attól, hogy használunk egy előre vagy egy visszavágót az ösvényen Húr, nem számít, az API megoldja ezt a paramétert az alapul szolgáló fájlrendszer követelményeinek megfelelően.

És a java.net.URI tárgy:

Elérési útvonal = Paths.get (URI objektum);

Most előre léphetünk, és láthatjuk ezeket működés közben.

4. Út létrehozása

Nak nek hozzon létre egy Pálya objektum egy útvonal karakterláncból:

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

A kap Az API egy változó argumentum paramétert vehet fel az útvonal karakterlánc-részekről (ebben az esetben cikkeket és baeldung) az első rész mellett (ebben az esetben cikkeket).

Ha ezeket a részeket egy teljes elérési karakterlánc helyett adjuk meg, akkor azokat a Path objektum elkészítéséhez fogjuk használni, nem kell a névelválasztókat (perjeleket) belefoglalnunk a változó argumentumok részébe:

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

5. Útvonal-információk lekérése

A Path objektumról névelemként, mint szekvenciára gondolhat. Egy ösvény Húr mint például E: \ baeldung \ articles \ java három névelemből áll, azaz baeldung, cikkeket, és Jáva. A könyvtárstruktúra legmagasabb eleme a 0 indexen lenne, ebben az esetben baeldung.

A könyvtárstruktúra legalacsonyabb eleme az indexen található [n-1], hol n az útvonalban található névelemek száma. Ezt a legalacsonyabb elemet nevezzük fájl név függetlenül attól, hogy ez tényleges fájl-e vagy sem:

@Test public void givenPath_whenRetrievesFileName_thenCorrect () {Path p = Paths.get ("/ articles / baeldung / logs"); Elérési út fájlnév = p.getFileName (); assertEquals ("naplók", fileName.toString ()); }

Módszerek állnak rendelkezésre az egyes elemek index szerinti visszakeresésére:

@Test public void givenPath_whenRetrievesNameByIndex_thenCorrect () {Path p = Paths.get ("/ articles / baeldung / logs"); Útvonal neve0 = getName (0); Útvonal neve1 = getName (1); Útvonal neve2 = getName (2); assertEquals ("cikkek", név0.toString ()); assertEquals ("baeldung", név1.toString ()); assertEquals ("naplók", név2.toString ()); }

vagy az út egy részsorozata az alábbi indextartományok használatával:

@Test public void givenPath_whenCanRetrieveSubsequenceByIndex_thenCorrect () {Path p = Paths.get ("/ articles / baeldung / logs"); Path1Path1 = p.ubpath (0,1); Path2Path2 = p.subpath (0,2); assertEquals ("cikkek", subPath1.toString ()); assertEquals ("articles \ baeldung", subPath2.toString ()); assertEquals ("cikkek \ baeldung \ naplók", p.subpath (0, 3) .toString ()); assertEquals ("baeldung", p.subpath (1, 2) .toString ()); assertEquals ("baeldung \ logs", p.subpath (1, 3) .toString ()); assertEquals ("naplók", p.subpath (2, 3) .toString ()); }

Minden út egy szülő útvonalhoz vagy nulla ha az útnak nincs szülője. Az útvonal objektum szülője az útvonal gyökérösszetevőjéből, ha van ilyen, és az útvonal minden eleméből áll, a fájlnév kivételével. Példaként a /ABC van / a / b és az / a nulla:

@Test public void givenPath_whenRetrievesParent_thenCorrect () {Path p1 = Paths.get ("/ articles / baeldung / logs"); P2 útvonal = Paths.get ("/ articles / baeldung"); P3 útvonal = Paths.get ("/ articles"); P4 útvonal = Paths.get ("/"); Útvonal szülő1 = p1.getParent (); Útvonal szülő2 = p2.getParent (); Útvonal szülő3 = p3.getParent (); Útvonal szülő4 = p4.getParenth (); assertEquals ("\ articles \ baeldung", parent1.toString ()); assertEquals ("\ articles", parent2.toString ()); assertEquals ("\", parent3.toString ()); assertEquals (null, szülő4); }

Megkaphatjuk az útvonal gyökérelemét is:

@Test public void givenPath_whenRetrievesRoot_thenCorrect () {Path p1 = Paths.get ("/ articles / baeldung / logs"); P2 útvonal = Paths.get ("c: / articles / baeldung / logs"); Útvonal gyökér1 = p1.getRoot (); Útvonal gyökér = p2.getRoot (); assertEquals ("\", root1.toString ()); assertEquals ("c: \", root2.toString ()); }

6. Az út normalizálása

Sok fájlrendszer használ “.” jelölés az aktuális könyvtár és “..” a szülőkönyvtár jelölésére. Előfordulhat, hogy egy útvonal redundáns címjegyzék-információkat tartalmaz.

Vegye figyelembe például a következő útvonal-karakterláncokat:

/baeldung/./articles /baeldung/authors/../articles / baeldung / articles

Mindannyian ugyanazon a helyen tartózkodnak / baeldung / articles. Az első kettőnél elbocsátások vannak, míg az utóbbinál nincs.

Az út normalizálása magában foglalja az elbocsátások eltávolítását. A Path.normalize () művelet biztosított erre a célra.

Ennek a példának most már magától értetődőnek kell lennie:

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

Ez is:

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

7. Útváltás

Vannak műveletek az útvonal kiválasztott prezentációs formátumra konvertálására. Bármely útvonalat a böngészőből megnyitható karakterláncokká alakíthatunk a toUri módszer:

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

Konvertálhatunk egy utat is abszolút ábrázolásává. A toAbsolutePath metódus feloldja az elérési utat a fájlrendszer alapértelmezett könyvtárával szemben:

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

Ha azonban a megoldandó útvonal abszolútnak tűnik, a módszer a következő módon adja vissza:

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

Bármely utat átalakíthatunk valódi megfelelőjévé is a toRealPath módszer. Ez a módszer megpróbálja feloldani az elérési utat azáltal, hogy elemeit leképezi a fájlrendszer tényleges könyvtáraihoz és fájljaihoz.

Ideje használni a változót, amelyet létrehoztunk a Beállít szakasz, amely a bejelentkezett felhasználó otthoni helyére mutat a fájlrendszerben:

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

A fenti teszt valójában nem sokat árul el a művelet viselkedéséről. A legkézenfekvőbb eredmény az, hogy ha az elérési út nem létezik a fájlrendszerben, akkor a művelet egy IOException, Olvass tovább.

Annak hiányában, hogy jobb lenne ezt a pontot hazavezetni, vessen egy pillantást a következő tesztre, amely megpróbálja egy nem létező utat valós útra konvertálni:

@Test (várható = NoSuchFileException.class) public void givenInExistentPath_whenFailsToConvert_thenCorrect () {Path p = Paths.get ("E: \ home \ baeldung \ articles.html"); p.toRealPath (); }

A teszt akkor sikerül, ha elkapunk egy IOException. A tényleges alosztály: IOException hogy ezt a műveletet dobja az NoSuchFileException.

8. Csatlakozás az ösvényekhez

Bármely két út összekapcsolása a elhatározás módszer.

Egyszerűen fogalmazva hívhatjuk a elhatározás módszer bármelyikre Pálya és adja át a részleges út mint érv. Ez a részleges útvonal hozzá van csatolva az eredeti útvonalhoz:

@Test public void givenTwoPaths_whenJoinsAndResolves_thenCorrect () {Path p = Paths.get ("/ baeldung / articles"); Elérési út p2 = p.resolve ("java"); assertEquals ("\ baeldung \ articles \ java", p2.toString ()); }

Amikor azonban az útvonal húrja átment a elhatározás módszer nem a részleges út; nevezetesen egy abszolút elérési út, majd a beírt út visszatér:

@Test public void givenAbsolutePath_whenResolutionRetainsIt_thenCorrect () {Path p = Paths.get ("/ baeldung / articles"); Elérési út p2 = p.resolve ("C: \ baeldung \ articles \ java"); assertEquals ("C: \ baeldung \ articles \ java", p2.toString ()); }

Ugyanez történik minden olyan gyökérelemmel rendelkező útvonallal. Az útvonal húrja "Jáva" nincs gyökéreleme, míg az elérési út string "/Jáva" gyökérelemmel rendelkezik. Ezért, ha egy gyökérelemmel rendelkező útvonalon halad el, az a következő lesz:

@Test public void givenPathWithRoot_whenResolutionRetainsIt_thenCorrect2 () {Path p = Paths.get ("/ baeldung / articles"); Elérési út p2 = p.resolve ("/ java"); assertEquals ("\ java", p2.toString ()); }

9. Relativizáló Útvonalak

A kifejezés relativizáló egyszerűen azt jelenti, hogy közvetlen utat kell létrehozni két ismert út között. Például, ha van könyvtárunk / baeldung és belül két másik könyvtárunk van, olyanok / baeldung / szerzők és / baeldung / articles érvényes utak.

Az út a cikkeket viszonyítva szerzői úgy írnánk le „Lépjen egy szinttel feljebb a könyvtár hierarchiában, majd a cikkek könyvtárába” vagy .. \ cikkek:

@Test public void givenSiblingPaths_whenCreatesPathToOther_thenCorrect () {Path p1 = Paths.get ("articles"); P2 útvonal = Paths.get ("szerzők"); Elérési út p1_rel_p2 = p1.relativizálás (p2); Elérési út p2_rel_p1 = p2.relativizálás (p1); assertEquals (".. \ szerzők", p1_rel_p2.toString ()); assertEquals (".. \ cikkek", p2_rel_p1.toString ()); }

Feltéve, hogy mozgatjuk a cikkeket könyvtárba szerzői mappa olyan, hogy már nem testvérek. A következő relativizáló műveletek között létre kell hozni egy utat baeldung és cikkeket és fordítva:

@Test public void givenNonSiblingPaths_whenCreatesPathToOther_thenCorrect () {Path p1 = Paths.get ("/ baeldung"); P2 útvonal = Paths.get ("/ baeldung / szerzők / cikkek"); Elérési út p1_rel_p2 = p1.relativizálás (p2); Elérési út p2_rel_p1 = p2.relativizálás (p1); assertEquals ("szerzők \ cikkek", p1_rel_p2.toString ()); assertEquals (".. \ ..", p2_rel_p1.toString ()); }

10. Útvonalak összehasonlítása

A Pálya osztály intuitív módon megvalósítja a egyenlő módszer, amely lehetővé teszi az egyenlőség két útjának összehasonlítását:

@Test public void givenTwoPaths_whenTestsEquality_thenCorrect () {Path p1 = Paths.get ("/ baeldung / articles"); P2 útvonal = Paths.get ("/ baeldung / articles"); P3 útvonal = Paths.get ("/ baeldung / szerzők"); assertTrue (p1.egyenlő (p2)); assertFalse (p1.egyenlő (p3)); }

Azt is ellenőrizheti, hogy egy útvonal egy adott karakterlánccal kezdődik-e:

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

Vagy valamilyen más húrral végződik:

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

11. Következtetés

Ebben a cikkben bemutattuk az Útvonal műveleteket az új fájlrendszer API-ban (NIO2), amelyet a Java 7 részeként szállítottak, és amelyek többségét működés közben látták.

Az ebben a cikkben használt kódminták a cikk Github projektjében találhatók.