streamalism.org

1. Áttekintés

Ebben az oktatóanyagban megvizsgáljuk a fájlokba történő írás különböző módjait a Java használatával. Ki fogjuk használni BufferedWriter, PrintWriter, FileOutputStream, DataOutputStream, RandomAccessFile, FileChannel, és a Java 7 Fájlok hasznossági osztály.

Megvizsgáljuk továbbá a fájl zárolását írás közben, és megvitatjuk a fájlba történő írás néhány végső elvitelét.

Ez az oktatóanyag a Java „Vissza az alapokhoz” sorozatának része, itt, a Baeldungon.

2. Írjon vele BufferedWriter

Kezdjük egyszerűen és használja BufferedWriter írni a Húr új fájlba:

public void whenWriteStringUsingBufferedWritter_thenCorrect () dobja az IOException-t {String str = "Hello"; BufferedWriter író = new BufferedWriter (új FileWriter (fájlNév)); író.ír (str); író.zárja (); }

A fájl kimenete a következő lesz:

Helló

Akkor megtehetjük csatolja a Húr a meglévő fájlba:

@Test public void, amikorAAppendStringUsingBufferedWritter_thenOldContentShouldExistToo () dobja az IOException-t {String str = "Világ"; BufferedWriter író = new BufferedWriter (új FileWriter (fájlnév, igaz)); író.append (''); író.append (str); író.zár (); }

A fájl ekkor lesz:

Helló Világ

3. Írjon vele PrintWriter

Ezután nézzük meg, hogyan tudjuk használni PrintWriter formázott szöveget fájlba írni:

@Test public void givenWritingStringToFile_whenUsingPrintWriter_thenCorrect () dobja az IOException {FileWriter fileWriter = új FileWriter (fájlnév); PrintWriter printWriter = új PrintWriter (fileWriter); printWriter.print ("Néhány karakterlánc"); printWriter.printf ("A termék neve% s, ára% d $", "iPhone", 1000); printWriter.close (); }

A kapott fájl a következőket tartalmazza:

Néhány karakterlánc termék neve iPhone, ára 1000 $

Vegye figyelembe, hogy mi nem csak nyersen írunk Húr fájlba, de néhány formázott szöveget is a printf módszer.

Segítségével létrehozhatjuk az írót FileWriter, BufferedWriter, vagy akár System.out.

4. Írjon vele FileOutputStream

Most nézzük meg, hogyan tudjuk használni FileOutputStream nak nek bináris adatokat írjon egy fájlba.

A következő kód átalakítja a Húr bájtokba, és a bájtokat fájlba írja FileOutputStream:

@Test public void givenWritingStringToFile_whenUsingFileOutputStream_thenCorrect () dobja az IOException {String str = "Hello"; FileOutputStream outputStream = új FileOutputStream (fájlnév); bájt [] strToBytes = str.getBytes (); outputStream.write (strToBytes); outputStream.close (); }

A fájl kimenete természetesen a következő lesz:

Helló

5. Írjon vele DataOutputStream

Ezután nézzük meg, hogyan használhatjuk DataOutputStream írni a Húr fájlba:

@Test public void givenWritingToFile_whenUsingDataOutputStream_thenCorrect () dobja az IOException {String value = "Hello"; FileOutputStream fos = új FileOutputStream (fájlnév); DataOutputStream outStream = új DataOutputStream (új BufferedOutputStream (fos)); outStream.writeUTF (érték); outStream.close (); // az eredmények ellenőrzése String result; FileInputStream fis = új FileInputStream (fájlnév); DataInputStream olvasó = new DataInputStream (fis); eredmény = olvasó.readUTF (); olvasó.zárja (); assertEquals (érték, eredmény); }

6. Írjon vele RandomAccessFile

Most szemléltessük, hogyan kell írni és szerkeszteni egy létező fájl belsejében ahelyett, hogy csak egy teljesen új fájlba írna vagy egy meglévőhöz csatolna. Egyszerűen fogalmazva: Véletlenszerű hozzáférésre van szükségünk.

RandomAccessFile lehetővé teszi számunkra, hogy a fájl meghatározott pontjára írjunk, az eltolással - a fájl elejétől kezdve - bájtokban.

Ez a kód egy egész értéket ír, amelynek eltolása a fájl elejétől kezdődik:

private void writeToPosition (String fájlnév, int adatok, hosszú pozíció) dobja az IOException-t {RandomAccessFile író = új RandomAccessFile (fájlnév, "rw"); író.keresés (pozíció); író.írjaInt (adatok); író.zárja (); }

Ha akarjuk olvassa el a int meghatározott helyen tárolják, használhatjuk ezt a módszert:

private int readFromPosition (String fájlnév, hosszú pozíció) dobja az IOException-t {int eredmény = 0; RandomAccessFile olvasó = új RandomAccessFile (fájlnév, "r"); olvasó.keresés (pozíció); eredmény = olvasó.readInt (); olvasó.zárja (); visszatérési eredmény; }

Funkcióink teszteléséhez írjunk egész számot, szerkesszük és végül olvassuk vissza:

@Test public void, amikor a WritingToSpecificPositionInFile_thenCorrect () dobja az IOException-t {int data1 = 2014; int adatok2 = 1500; writeToPosition (fájlnév, adat1, 4); assertEquals (data1, readFromPosition (fájlnév, 4)); writeToPosition (fájlNév2, adat2, 4); assertEquals (data2, readFromPosition (fájlnév, 4)); }

7. Írjon vele FileChannel

Ha nagy fájlokkal van dolgunk, FileChannel gyorsabb lehet, mint a szokásos IO. A következő kód ír Húr fájlba fájl segítségével FileChannel:

@Test public void givenWritingToFile_whenUsingFileChannel_thenCorrect () dobja az IOException {RandomAccessFile stream = új RandomAccessFile (fájlnév, "rw"); FileChannel csatorna = stream.getChannel (); String value = "Hello"; bájt [] strBytes = value.getBytes (); ByteBuffer buffer = ByteBuffer.allocate (strBytes.length); buffer.put (strBytes); puffer.flip (); channel.write (puffer); stream.close (); csatorna.zár (); // ellenőrizze a RandomAccessFile olvasót = új RandomAccessFile (fájlnév, "r"); assertEquals (érték, olvasó.readLine ()); olvasó.zárja (); }

8. Írjon vele Fájlok Osztály

A Java 7 új módszert mutat be a fájlrendszerrel, valamint egy új segédprogram-osztályt: Fájlok.

Használni a Fájlok osztályban létrehozhatunk, áthelyezhetünk, másolhatunk és törölhetünk fájlokat és könyvtárakat. Fájlok olvasására és írására is használható:

@Test public void givenUsingJava7_whenWritingToFile_thenCorrect () dobja az IOException {String str = "Hello"; Elérési útvonal = Paths.get (fájlnév); bájt [] strToBytes = str.getBytes (); Files.write (elérési út, strToBytes); Karaktersorozat = Files.readAllLines (elérési út) .get (0); assertEquals (sztr, olvas); }

9. Írjon egy ideiglenes fájlba

Most próbáljunk meg ideiglenes fájlba írni. A következő kód ideiglenes fájlt hoz létre, és a Húr hozzá:

@Test public void, amikor a WRiteToTmpFile_thenCorrect () az IOException-t dobja {String toWrite = "Hello"; File tmpFile = File.createTempFile ("teszt", ".tmp"); FileWriter író = new FileWriter (tmpFile); író.ír (toWrite); író.zárja (); BufferedReader olvasó = new BufferedReader (új FileReader (tmpFile)); assertEquals (toWrite, reader.readLine ()); olvasó.zárja (); }

Mint láthatjuk, csak az ideiglenes fájl létrehozása érdekes és eltérő. Ezt követően a fájlba történő írás ugyanaz.

10. Fájl zárolása írás előtt

Végül, ha fájlba írunk, néha fokozottan meg kell győződnünk arról, hogy senki más nem ír egyszerre e fájlba. Alapvetően képesnek kell lennünk a fájl zárolására írás közben.

Használjuk ki FileChannel hogy megpróbálja lezárni a fájlt, mielőtt írna rá:

@Test public void whenTryToLockFile_thenItShouldBeLocked () IOException {RandomAccessFile stream = new RandomAccessFile (fileName, "rw") dobja; FileChannel csatorna = stream.getChannel (); FileLock zár = null; próbáld ki a {lock = channel.tryLock (); } catch (végső OverlappingFileLockException e) {stream.close (); csatorna.zár (); } stream.writeChars ("tesztzár"); lock.release (); stream.close (); csatorna.zár (); }

Vegye figyelembe, hogy ha a fájl már zárolva van, amikor megpróbáljuk megszerezni a zárat, akkor egy ÁtfedőFileLockException dobni fogják.

11. Megjegyzések

Miután megismerkedett egy fájlba történő írás sok módszerével, beszéljünk néhány fontos megjegyzésről:

• Ha nem létező fájlból próbálunk olvasni, a FileNotFoundException dobni fogják.
• Ha megpróbálunk olyan fájlba írni, amely nem létezik, akkor először a fájl jön létre, és nem vetnek ki kivételt.
• Nagyon fontos, hogy használat után bezárjuk az adatfolyamot, mivel az nincs implicit módon bezárva, hogy felszabadítsuk a hozzá kapcsolódó erőforrásokat.
• A kimeneti adatfolyamban a Bezárás() metódus hívások öblítés () az erőforrások felszabadítása előtt, ami kényszerít minden pufferelt bájtot a folyamra írásra.

A gyakori használati gyakorlatokat megnézve például azt láthatjuk PrintWriter formázott szöveg írására szolgál, FileOutputStream bináris adatok írására, DataOutputStream primitív adattípusok írására, RandomAccessFile írni egy adott pozícióba, és FileChannel gyorsabban írni nagyobb fájlokba. Ezen osztályok egyes API-jai többet is megengednek, de ez jó hely a kezdéshez.

12. Következtetés

Ez a cikk bemutatta az adatok fájlba történő írásának számos lehetőségét a Java használatával.

Ezen példák és kódrészletek megvalósítása megtalálható a GitHub-on.