Útmutató a Groovy-i I / O-hoz

1. Bemutatkozás

Bár a Groovy-ban ugyanúgy működhetünk az I / O-val, mint a Java-ban, Groovy számos segítő módszerrel bővíti a Java I / O funkcióit.

Ebben az oktatóanyagban a fájlok olvasását és írását, a fájlrendszerek bejárását és az adatok és objektumok sorosítását Groovy File kiterjesztési módszerek.

Adott esetben hivatkozunk a vonatkozó Java-cikkeinkre, hogy könnyen összehasonlíthassuk a Java-megfelelővel.

2. Fájlok olvasása

A Groovy kényelmes funkcionalitást kínál a fájlok fájlok olvasásához minden sor módszerek, módszerek a megszerzésére BufferedReaders és InputStreams, és az összes fájladat egy sor kóddal történő megszerzésének módjai.

A Java 7 és a Java 8 hasonló támogatást nyújt a Java fájlok olvasásához.

2.1. Olvasás vele minden sor

Szöveges fájlokkal foglalkozva gyakran el kell olvasnunk az egyes sorokat és azokat feldolgoznunk. A Groovy kényelmes kiterjesztést nyújt a java.io.Fájl a ... val minden sor módszer:

def lines = [] new File ('src / main / resources / ioInput.txt'). eachLine {sor -> sorok.add (sor)}

A bezárás biztosított minden sor hasznos opcionális sorszámmal is rendelkezik. Használjuk a sorszámot, hogy csak meghatározott sorokat kapjunk egy fájlból:

def lineNoRange = 2..4 def lines = [] új fájl ('src / main / resources / ioInput.txt'). eachLine {sor, lineNo -> if (lineNoRange.contains (lineNo)) {lines.add (sor )}}

Alapértelmezés szerint a sorszámozás egynél kezdődik. Megadhatunk egy értéket, amelyet első sorszámként használhatunk, ha azt első paraméterként továbbítjuk a minden sor módszer.

Kezdjük nullán a sorszámokat:

új Fájl ('src / main / resources / ioInput.txt'). eachLine (0, {line, lineNo -> if (lineNoRange.contains (lineNo)) {lines.add (line)}})

Ha kivételt dobnak be minden sor, Groovy biztosítja, hogy a fájl erőforrása bezáruljon. Hasonlóan a erőforrásokkal próbálkozzon vagy a próbálkozz végre Java-ban.

2.2. Olvasás az Olvasóval

Könnyen megkaphatjuk a BufferedReader egy Groovytól File tárgy. Tudjuk használni withReader hogy a BufferedReader a fájlobjektumhoz, és adja át bezárásnak:

def actualCount = 0 új fájl ('src / main / resources / ioInput.txt'). withReader {olvasó -> while (olvasó.readLine ()) {actualCount ++}}

Mint minden sor, a withReader metódus automatikusan bezárja az erőforrást, amikor kivételt dob.

Néha előfordulhat, hogy szeretnénk BufferedReader elérhető objektum. Tervezhetünk például egy olyan metódus meghívását, amelyik paramétert vesz fel. Használhatjuk a newReader módszer erre:

def outputPath = 'src / main / resources / ioOut.txt' def reader = new File ('src / main / resources / ioInput.txt'). newReader () new File (outputPath) .app (olvasó) reader.close ( )

Ellentétben a többi módszerrel, amit eddig megvizsgáltunk, mi vagyunk felelősek a BufferedReader erőforrás, amikor megszerezzük a PufferoltOlvasó Ily módon.

2.3. Olvasás vele InputStreams

Hasonló withReader és newReader, A Groovy módszereket is kínál a könnyű munkához InputStreams. Bár a szöveget elolvashatjuk InputStreams Groovy még funkcionalitást is ad hozzá, InputStreams leggyakrabban bináris adatokhoz használják.

Használjuk azInputStream segítségével átadni egy InputStream bezárásig és olvassa el a bájtokban:

bájt [] data = [] új fájl ("src / main / resources / binaryExample.jpg"). withInputStream {stream -> data = stream.getBytes ()}

Ha szükségünk van a InputStream objektumot, használhatunk egyet newInputStream:

def outputPath = 'src / main / resources / binaryOut.jpg' def is = new File ('src / main / resources / binaryExample.jpg'). newInputStream () new File (outputPath) .append (is) is.close ( )

Mint a BufferedReader, be kell zárnunk InputStream erőforrás magunkat, amikor használjuk newInputStream, de használatkor nem azInputStream segítségével.

2.4. Más utak olvasása

Fejezzük be az olvasás témáját néhány módszer megvizsgálásával, amellyel Groovy az összes fájladatot egy utasításban megragadja.

Ha a fájlunk sorait akarjuk a Lista, tudjuk használni gyűjt iterátorral azt átment a bezárásig:

def actualList = új fájl ('src / main / resources / ioInput.txt'). {it} gyűjtése

Ahhoz, hogy fájlunk sorait a Húrok, tudjuk használni húrként []:

def actualArray = új fájl ('src / main / resources / ioInput.txt') karakterláncként []

Rövid fájlok esetén a teljes tartalmat a Húr felhasználásával szöveg:

def actualString = új fájl ('src / main / resources / ioInput.txt'). szöveg

Ha bináris fájlokkal dolgozik, ott van bájtokat módszer:

def tartalom = új fájl ('src / main / resources / binaryExample.jpg'). bájtok

3. Fájlok írása

Mielőtt elkezdenénk írni a fájlokat, állítsuk be a kiadandó szöveget:

def outputLines = ['A kimeneti példa egyik vonala', 'A kimeneti példa második sora', 'A kimeneti példa harmadik sora']

3.1. Írás az íróval

Mint egy fájl olvasásakor, könnyen megkaphatjuk a BufferedWriter ki a File tárgy.

Használjuk withWriter hogy a BufferedWriter és adja át egy zárónak:

def outputFileName = 'src / main / resources / ioOutput.txt' új fájl (outputFileName) .wither {író -> outputLines.each {sor -> író.writeLine sor}}

Használata withReader bezárja az erőforrást, ha kivétel történik.

Groovynak van egy módszere a BufferedWriter tárgy. Vegyünk egy BufferedWriter felhasználásával newWriter:

def outputFileName = 'src / main / resources / ioOutput.txt' def író = új fájl (outputFileName) .newWriter () outputLines.forEach {sor -> író.writeLine sor} író.flush () író.zár ()

Mi vagyunk a felelősek az öblítésért és bezárásért BufferedWriter objektum, amikor használjuk newWriter.

3.2. Írás kimeneti adatfolyamokkal

Ha bináris adatokat írunk ki, kaphatunk egy OutputStream bármelyik felhasználásával withOutputStream vagy newOutputStream.

Írjunk néhány bájtot egy fájlba a withOutputStream:

bájt [] outBytes = [44, 88, 22] új fájl (outputFileName) .withOutputStream {stream -> stream.write (outBytes)}

Vegyünk egy OutputStream objektum azzal newOutputStream és használjon néhány bájtot:

byte [] outBytes = [44, 88, 22] def os = új fájl (outputFileName) .newOutputStream () os.write (outBytes) os.close ()

Hasonlóan InputStream, BufferedReader, és BufferedWriter, mi vagyunk felelősek a OutputStream önmagunkat, amikor használjuk newOutputStream.

3.3. Írás a << Operátorral

Mivel a szöveg írása fájlokba olyan általános, a << operátor közvetlenül biztosítja ezt a funkciót.

Használjuk a << operátor néhány egyszerű szövegsor megírásához:

def ln = System.getProperty ('line.separator') def outputFileName = 'src / main / resources / ioOutput.txt' new File (outputFileName) << "$ {ln} kimeneti példa egyik sora" + " kimeneti példa $ {ln} A kimeneti példa harmadik sora "

3.4. Bináris adatok írása bájtokkal

A cikkben korábban láttuk, hogy a bináris fájlból az összes bájtot egyszerűen megszerezhetjük a bájtokat terület.

Írjunk ugyanúgy bináris adatokat:

def outputFileName = 'src / main / resources / ioBinaryOutput.bin' def outputFile = új fájl (outputFileName) bájt [] outBytes = [44, 88, 22] outputFile.bytes = outBytes

4. Fájlfák bejárása

A Groovy emellett egyszerű módszereket kínál a fájlfákkal való együttműködésre. Ebben a részben ezt fogjuk megtenni mindegyikFájl, mindegyikDir és változataik és a áthalad módszer.

4.1. Fájlok felsorolása a következővel: mindegyikFájl

Soroljuk fel az összes fájlt és könyvtárat egy könyvtárba a mindegyikFájl:

új Fájl ('src / main / resources'). eachFile {fájl -> println fájl.név}

Egy másik gyakori eset a fájlokkal való munka során a fájlok szűrése a fájlnév alapján. Csak azokat a fájlokat soroljuk fel, amelyek „io” betűvel kezdődnek, és a „.txt” végződéssel végződnek eachFileMatch és egy reguláris kifejezés:

új Fájl ('src / main / resources'). eachFileMatch (~ / io. * \. txt /) {fájl -> println fájl.név}

A mindegyikFájl és eachFileMatch A metódusok csak a legfelső szintű könyvtár tartalmát sorolják fel. Groovy azt is lehetővé teszi számunkra, hogy korlátozzuk, amit a mindegyikFájl a módszerek visszatérnek a Fájltípus a módszerekhez. A lehetőségek a következők BÁRMI, FÁJLOK, és IGAZGATÓSÁGOK.

Soroljuk fel rekurzívan az összes fájlt a segítségével eachFileRecurse és annak biztosítása a Fájltípus nak,-nek FÁJLOK:

új Fájl ('src / main'). eachFileRecurse (FileType.FILES) {fájl -> println "$ file.parent $ file.name"}

A mindegyikFájl módszerek dobnak egy IllegalArgumentException ha könyvtár helyett egy fájl elérési útját adjuk meg nekik.

Groovy biztosítja a mindegyikDir módszerek csak könyvtárakkal való munkához. Tudjuk használni mindegyikDir és annak változatai ugyanazt a célt érik el, mint a használat mindegyikFájl val,-vel Fájltípus nak,-nek IGAZGATÓSÁGOK.

Rekurzívan soroljuk fel a könyvtárakat a eachFileRecurse:

új Fájl ('src / main'). eachFileRecurse (FileType.DIRECTORIES) {fájl -> println "$ file.parent $ file.name"}

Most tegyük ugyanezt eachDirRecurse:

új fájl ('src / main'). eachDirRecurse {dir -> println "$ dir.parent $ dir.name"}

4.2. Fájlok felsorolása a Traverse programmal

A bonyolultabb könyvtár-bejárási esetekhez használhatjuk a áthalad módszer. Hasonlóan működik eachFileRecurse de biztosítja a visszatérés képességét FileVisitResult objektumok a feldolgozás vezérlésére.

Használjuk áthalad miénken src / main könyvtárba, és hagyja ki a fa feldolgozását a groovy Könyvtár:

új Fájl ('src / main'). traverse {file -> if (file.directory && file.name == 'groovy') {FileVisitResult.SKIP_SUBTREE} else {println "$ file.parent - $ file.name"} }

5. Munka az adatokkal és az objektumokkal

5.1. A primitívek sorosítása

A Java-ban használhatjuk DataInputStream és DataOutputStream a primitív adatmezők sorosításához. Groovy itt is hasznos bővítéseket ad hozzá.

Állítsunk be néhány primitív adatot:

Karakterlánc-üzenet = 'Ez egy sorosított karakterlánc' int length = message.length () logikai érték érvényes = true

Most sorosítsuk adatainkat egy fájlba a segítségével withDataOutputStream:

új fájl ('src / main / resources / ioData.txt'). withDataOutputStream {out -> out.writeUTF (message) out.writeInt (length) out.writeBoolean (érvényes)}

És olvassa vissza a használat során aDataInputStream segítségével:

Karaktersorozat loadingMessage = "" int loadedLength boolean loadedValid new File ('src / main / resources / ioData.txt'). WithDataInputStream {is -> loadedMessage = is.readUTF () loadedLength = is.readInt () loadedValid = is.readBoolean ( )}

Hasonló a másikhoz val vel* mód, withDataOutputStream és aDataInputStream segítségével vigye át a patakot a zárótérbe, és győződjön meg arról, hogy megfelelően van-e bezárva.

5.2. Objektumok sorosítása

Groovy a Java-ra is épít ObjectInputStream és ObjectOutputStream hogy lehetővé tegyük számunkra a megvalósítható objektumok egyszerű sorosítását Sorosítható.

Először határozzunk meg egy osztályt, amely megvalósítja Sorosítható:

osztály Feladat végrehajtása Serializálható {karakterlánc leírás dátum kezdet dátum dátum esedékesség dátum int állapot}

Most hozzunk létre egy példányt Feladat hogy sorosíthatunk egy fájlba:

Feladatfeladat = új Feladat (leírás: 'Vegye ki a szemetet', startDate: új Dátum (), állapot: 0)

Velünk Feladat objektum a kezében, sorosítsuk egy fájlba a az ObjectOutputStream segítségével:

új fájl ('src / main / resources / ioSerializedObject.txt'). withObjectOutputStream {out -> out.writeObject (task)}

Végül olvassuk el a mi Feladat vissza a használatba az ObjectInputStream segítségével:

Olvassa el az új fájlt ('src / main / resources / ioSerializedObject.txt'). AzObjectInputStream használatával {is -> taskRead = is.readObject ()}

Az általunk alkalmazott módszerek, az ObjectOutputStream segítségével és az ObjectInputStream segítségével, adja át a folyamot egy záróhelynek, és kezelje az erőforrások megfelelő lezárását, ugyanúgy, mint a másiknál ​​látva val vel* mód.

6. Következtetés

Ebben a cikkben azt a funkciót vizsgáltuk, amelyet Groovy ad hozzá a meglévő Java File I / O osztályokhoz. Ezt a funkciót használtuk fájlok olvasására és írására, a könyvtárstruktúrák kezelésére, valamint az adatok és objektumok sorosítására.

Csak néhány segítő módszert érintettünk, ezért érdemes ásni a Groovy dokumentációját, hogy megnézzük, mi ad még hozzá a Java I / O funkcióihoz.

A példa kód elérhető a GitHubon.


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