8 måder at skrive til fil i Java

Vi vil se på mange metoder til at skrive til en fil i Java. Disse inkluderer BufferedWriter, PrintWriter, FileOutputStream, DataOutputStream, RandomAccessFile, FileChannel og hjælpeklassen Java 7 Files, der bruges i dette eksempel. Vi vil også diskutere låsning af filen under skrivning og flere andre aspekter ved at skrive til fil.

Skriv med PrintWriter

Eksemplet nedenfor ser på, hvordan man bruger PrintWriter til at gemme formateret tekst til en fil:

@Test
public void writeWithPrintWriter()
  throws IOException {
    FileWriter fWriter = new FileWriter(fileName);
    PrintWriter pWriter = new PrintWriter(fWriter);
    pWriter.print("Some String");
    pWriter.printf("The grocery name is %s and its price is %d $", "Tomatoes", 250);
    pWriter.close();
}

Med printf-metoden udgiver vi en rå streng til en fil og noget forberedt tekst. Vi kan bruge FileWriter, BufferedWriter eller endda System.out til at generere forfatteren.

Sådan skriver man med FileChannel

FileChannel kan være hurtigere end almindelig IO, når det drejer sig om store filer. Ved at bruge FileChannel skriver følgende kode String til en fil:

@Test
public void writeUsingFileChannel()
  throws IOException {
    RandomAccessFile raStream = new RandomAccessFile(fileName, "rw");
    FileChannel fileChannel = raStream.getChannel();
    String strVal = "Codeunderscored";
    byte[] stringBytes = strVal.getBytes();
    ByteBuffer byteBuffer = ByteBuffer.allocate(stringBytes .length);
    byteBuffer.put(stringBytes);
    byteBuffer.flip();
    fileChannel.write(byteBuffer);
    raStream.close();
    fileChannel.close();

    // verification
    RandomAccessFile raFile = new RandomAccessFile(fileName, "r");
    assertEquals(strVal, raFile.readLine());
    raFile.close();
}

Sådan skriver man med FileOutputStream

Lad os nu se på, hvordan vi kan sende binære data til en fil ved hjælp af FileOutputStream. Følgende kode transformerer en streng til bytes og bruger FileOutputStream til at skrive bytes til en fil:

@Test
public void writeUsingFileOutputStream()
  throws IOException {
    String strVar = "Codeunderscored";
    FileOutputStream outputStream = new FileOutputStream(fileName);
    byte[] strBytes = strVar.getBytes();
    outputStream.write(strBytes);

    outputStream.close();
}

Sådan skriver man med DataOutputStream

Lad os derefter se på, hvordan man skriver en streng til en fil ved hjælp af DataOutputStream.

@Test
public void writeUsingDataOutputStream()
  throws IOException {
    String value = "Codeundersocred";
    FileOutputStream foStream = new FileOutputStream(fileName);
    DataOutputStream doStream = new DataOutputStream(new BufferedOutputStream(foStream));
    doStream.writeUTF(value);
    doStream.close();

    // results verification
    String result;
    FileInputStream fiStream = new FileInputStream(fileName);
    DataInputStream diStream = new DataInputStream(fiStream);
    result = diStream.readUTF();
    diStream.close();

    assertEquals(value, result);
}

Sådan skriver man med BufferedWriter

Lad os starte let ved at skrive en streng til en ny fil med BufferedWriter:

public void WriteUsingBufferedWritter()
  throws IOException {
    String strVar = "Codeunderscored";
    BufferedWriter bfWriter = new BufferedWriter(new FileWriter(fileName));
    bfWriter.write(strVar);
    
    bfWriter.close();
}

Efterfølgende kan vi tilføje en streng til den eksisterende fil som følger:

@Test
public void appendStringUsingBufferedWritter()
  throws IOException {
    String strVar = "underscored";
    BufferedWriter brWriter = new BufferedWriter(new FileWriter(fileName, true));
    brWriter.append(' ');
    brWriter.append(strVar );
    
    writer.close();
}

Sådan skriver man til en midlertidig fil

Lad os prøve at skrive til en midlertidig fil nu. Koden nedenfor laver en midlertidig fil og skriver en streng til den:

@Test
public void writeToTemporaryFile() throws IOException {
    String strWrite = "Codeunderscored";
    File temporaryFile = File.createTempFile("trial", ".tmp");
    FileWriter fWriter = new FileWriter(temporaryFile);
    fWriter.write(strWrite);
    fWriter.close();

    BufferedReader bReader = new BufferedReader(new FileReader(temporaryFile));
    assertEquals(strWrite, bReader.readLine());
    bReader.close();
}

Som vi kan se, er den spændende og unikke del genereringen af ​​den midlertidige fil. Derefter skriver vi til filen på samme måde som før.

Sådan skriver man med RandomAccessFile

Lad os se på at skrive og redigere i en eksisterende fil i stedet for at oprette en ny eller tilføje til en, der allerede eksisterer. , kræver vi ubegrænset adgang. RandomAccessFile giver os mulighed for at skrive til en bestemt placering i en fil baseret på bytes offset fra filens begyndelse. Denne kode opretter en heltalsværdi med en offset fra filens start:

private void writeToPosition(String fname, int data, long pos)
  throws IOException {
    RandomAccessFile  raFile = new RandomAccessFile(fname, "rw");
    raFile.seek(pos);
    raFile.writeInt(data);
    raFile.close();
}

Denne metode bruges til at læse den int, der er gemt på et givet sted:

private int readFromPosition(String fname, long pos)
  throws IOException {
    int result = 0;
    RandomAccessFile raFile = new RandomAccessFile(fname, "r");
    raFile.seek(pos);
    resultVals = reader.readInt();
    raFile.close();
    return resultVals;
}

Lad os skrive et heltal, ændre det og derefter læse det tilbage for at se, hvor godt vores funktioner fungerer:

@Test
public void writingToSpecificFilePosition()
  throws IOException {
    int yearData = 2022;
    int countData = 4000;
    
    writeToPosition(fileName, yearData, 10);
    assertEquals(yearData, readFromPosition(fileName, 10));
    
    writeToPosition(fileName2, countData, 10);
    assertEquals(countData, readFromPosition(fileName, 10));
}

Sådan skriver man med Files Class

En ny hjælpeklasse i Java 7, Files, giver grænseflade til filsystemet. Vi kan oprette, flytte, kopiere og fjerne filer og mapper ved hjælp af klassen Filer. Den kan også læse og skrive data til en fil:

@Test
public void writeWithFileClass()

  throws IOException {
    String strVal = "Codeunderscored";

    Path fetchPath = Paths.get(fileName);
    byte[] strBytes = strVal.getBytes();

    Files.write(fetchPath, strBytes);

    String readString = Files.readAllLines(fetchPath).get(0);
    assertEquals(strVal, readString);
}

Sådan låser du fil før skrivning

Til sidst, når vi skriver til en fil, skal vi lejlighedsvis dobbelttjekke, at ingen andre gør det samtidigt. Grundlæggende skal vi låse filen, mens den bliver skrevet. Lad os bruge FileChannel til at se, om vi kan låse filen, før vi skriver til den:

@Test
public void LockFileBeforeWriting()
  throws IOException {
    RandomAccessFile raFile = new RandomAccessFile(fileName, "rw");
    FileChannel fChannel = raFile.getChannel();

    FileLock fileLock = null;
    try {
        lock = fChannel.tryLock();
    } catch (final OverlappingFileLockException e) {
        raFile.close();
        fChannel.close();
    }
    stream.writeChars("Test drive lock");
    fileLock.release();

    raFile.close();
    fChannel.close();
}

En OverlappingFileLockException vil blive udløst, hvis filen allerede er låst, når vi forsøger at hente låsen.

Konklusion

Denne artikel har vist, hvordan man skriver data til en fil i Java ved hjælp af forskellige metoder. Men det følgende er de vigtigste ting fra os.

En FileNotFoundException vil blive udstedt, hvis vi forsøger at læse fra en fil, der ikke eksisterer. Derudover, hvis vi forsøger at skrive til en tom fil, oprettes filen først, og der udstedes ingen undtagelse. Da strømmen ikke er lukket implicit, er det afgørende at afslutte den efter hver brug for at afgive tilknyttede ressourcer. Inden ressourcerne i outputstrømmen opgives, kalder funktionen close() flush(), som tvinger alle bufferbytes til at blive sendt til strømmen.

Selvom flere af disse klassers API'er tillader mere, er dette et glimrende sted at starte. PrintWriter bruges til at skrive formateret tekst, FileOutputStream bruges til at skrive binære data, mens DataOutputStream bruges til at skrive grundlæggende datatyper. Derudover bruges RandomAccessFile til at skrive til et bestemt punkt, og FileChannel bruges til at skrive hurtigere i større filer.