Textdatei in Java

Programmierer verwenden Textdateien in Java, während sie mit Java-Anwendungen arbeiten, die das Lesen und Schreiben einer Datei erfordern. Textdateien sind universelle Möglichkeiten zum Speichern von Informationen, Code oder anderen Daten. Eine Textdatei wird als horizontal angeordnete Zeichenfolge betrachtet. Die Textdateien in Java haben Erweiterungen wie .java, die Java-Codes enthalten. Java bietet verschiedene Dienstprogramme, mit denen Sie mit einfachen Textdateien umgehen können, indem Sie entweder aus ihnen lesen oder in sie schreiben. Sie können je nach Ihrem Verständnis ein beliebiges Lese-/Schreibdienstprogramm auswählen.

Wichtige Highlights

• Eine Textdatei besteht aus verschiedenen Zeichen, in denen man mit java.io.package Lese- und Schreibvorgänge ausführen kann.
• Zum Lesen können Sie die Reader-Klasse oder die Utility-Klasse verwenden. Einige Dienstprogrammklassen sind die File-Klasse, FileReader, BufferedReader und die Scanner-Klasse.
• Um in eine Datei in Java zu schreiben, können Sie Java 7 Files, FileWriter, BufferedWriter und FileOutputStream verwenden.
• Mit verschiedenen Methoden können Sie Textdateien in Java effizient umgehen.

Wie liest man Textdateien in Java?

• In Textdateien besteht jede Zeile aus einfachen Zeichen und jede Zeile ist durch ein unsichtbares „Zeilenende“-Symbol markiert, das das Ende dieser bestimmten Zeile darstellt.
• Zum Lesen von Textdateien in Java stehen verschiedene Dienstprogramme zur Verfügung. Jedes Dienstprogramm hat seine eigene Art, aus der Textdatei zu lesen und bietet einige Funktionen, die sich von anderen Alternativen unterscheiden.
• Hier erklären wir verschiedene Methoden anhand eines guten Beispiels zum besseren Verständnis.

Bevor wir mit den Methoden beginnen, betrachten wir eine Textdatei „test.txt“ im Pfad „/Users/praashibansal/Desktop/Data/test.txt“ mit dem Inhalt „Hallo, da“.

WERBUNG Beliebter Kurs in dieser Kategorie JAVA MASTERY - Spezialisierung | 78 Kursreihe | 15 Probetests

Methode 1 – Verwenden der BufferedReader-Klasse

• Mit dieser Methode können Sie Text aus dem Zeicheneingabestream lesen. Sie können die Standardpuffergröße (8 KB) verwenden oder Ihre eigene angeben. Es unterstützt die Kodierung.
• Jede Anfrage verfügt über einen Reader, der eine Leseanforderung aus dem zugrunde liegenden Zeichenstrom oder Bytestrom erstellt.
• Daher empfehlen viele Entwickler, einen BufferedReader mithilfe seiner read()-Operationen um jeden Reader zu wickeln.
• Es eignet sich gut für die Verarbeitung großer Dateien. Diese Methode ist synchronisiert und kann daher von mehreren Threads aus verwendet werden.

Code:

import java.io.*;
 public class BReader {
       public static void main(String[] args) throws Exception
    {
              File f = new File(
            "https://cdn.educba.com/Users/praashibansal/Desktop/Data/test.txt");
             // Creating an object
        BufferedReader b
            = new BufferedReader(new FileReader(f));
        // Declaring a string variable
        String s;
        // Condition holds till
        // there is a character in a string
        while ((s = b.readLine()) != null)
            // Print the string
            System.out.println(s);
    }
}

Ausgabe:

Methode 2 – Verwenden der FileReader-Klasse

• Sie können FileReader verwenden, um den BufferedReader abzurufen und mit dem Lesen der Datei zu beginnen.
• Im Gegensatz zu BufferedReader unterstützt es keine Kodierung und verwendet stattdessen die Standardkodierung des Systems.
• Es ist nur eine einfache Art, Zeichen zu lesen.
• Diese Klasse verwendet drei Konstruktoren.
• FileReader (Dateidatei): Erstellt einen neuen FileReader. Die Datei ist die Datei, aus der Sie den Inhalt lesen.
• FileReader(FileDescriptor fd): Erstellt einen neuen FileReader, der aus der als FileDescriptor angegebenen Datei liest.
• FileReader(String fileName): Erstellt einen neuen FileReader, der aus der Datei namens fileName liest.

Code:

import java.io.*;
public class RFile {
     public static void main(String[] args) throws Exception
    {
        // Passing the file’s path 
        FileReader f = new FileReader(
            "https://cdn.educba.com/Users/praashibansal/Desktop/Data/test.txt");
        // declaring loop variable
        int i;
             while ((i = f.read()) != -1)
            // Print the content of a file
            System.out.print((char)i);
    }
}

Ausgabe:

Methode 3 – Verwendung der Scannerklasse

• Es handelt sich um einen einfachen Textscanner, der primitive Typen und Zeichenfolgen über reguläre Ausdrücke analysieren kann.
• Es unterteilt die Eingabe über ein Trennzeichenmuster in Token. Standardmäßig ist das Trennzeichen das Leerzeichen.
• Dann wird der Token in verschiedene Arten von Werten umgewandelt.

Code:

import java.io.File;
import java.util.Scanner;
public class ReadScan
{
  public static void main(String[] args) throws Exception
  {
    // passing the file’s path
    File file = new File("https://cdn.educba.com/Users/praashibansal/Desktop/Data/test.txt");
    Scanner s = new Scanner(file);
    while (s.hasNextLine())
      System.out.println(s.nextLine());
  }
}

Ausgabe:

Methode 4 – Verwenden der Dateiklassenmethode

• Die Dateiklasse VERWENDET die folgenden Methoden zum Lesen der Datei.
• readAllBytes(Pfadpfad): Liest alle Bytes aus der Datei und gibt das Byte-Array zurück, das die Bytes aus der Datei enthält.
• readAllLines(Path path, Charsetcs): liest alle Zeilen aus der Datei und gibt die Liste mit den Zeilen aus der Datei zurück.

Code:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class FCExample {
	public static void main(String[] args) {
		Path path = Paths.get("https://cdn.educba.com/Users/praashibansal/Desktop/Data/test.txt");
		try {
			byte[] b = Files.readAllBytes(path);
			System.out.println("Read bytes: \n"+new String(b));
		} catch (IOException e) {
		}
	}

}

Ausgabe:

How to Write a Text File in Java?

• Writing a text file in Java is also a simple process. Java offers different utilities to help write the lines to the file.
• Now for this process, we are assuming a file at the location- C:\\Users\\Data\\Desktop\\write.txt to which we are writing.

Method 1 – Using FileWriter Method

• This all-in-one method allows you to write int, byte array, and String to the File.
• It allows you to write directly into Files and is used in case of the less writes.
• Using the FileWriter method, you can write part of the String or byte array.

Code:

import java.io.FileWriter; 
 public class FWFile { 
 public static void main(String args[]){ 
 try{ 
 FileWriter f=new FileWriter("https://cdn.educba.com/Users/praashibansal/Desktop/Data/test.txt"); 
 f.write("Hello"); 
 f.close(); 
 }
catch(Exception e)
{
System.out.println(e);
} 
 System.out.println("Hello"); 
 } 
 }

Output:

Method 2 – Using BufferedWriter Method

• BufferedWriter is similar to FileWriter, but BufferedWriter uses an internal buffer to write data into File.
• It works well if you need to do more write operations and to ensure performance.

Code:

import java.io.FileWriter;
import java.io.BufferedWriter;
import java.io.IOException;

public class BRExample {
  public static void main(String args[]) {
    String data = "data for output file";
    try {
      // Creates a FileWriter
      FileWriter file = new FileWriter("https://cdn.educba.com/Users/praashibansal/Desktop/Data/test.txt");
        try ( // Creates a BufferedWriter
                var o = new BufferedWriter(file)) {
            // Writes the string to the file
            o.write(data);
        }
    }
    catch (IOException e) {
      e.getStackTrace();
    }
  }
}

Output:

Method 3 – Using FileOutputStream Method

• For writing text to the file, you can simply use FileWriter and BufferedWriter.
• But, if you want the raw stream data to be written directly into a file, it is recommended to use the FileOutputStream utility.
• With this method, you must create the class object with the specific filename to write data into a file.
• The following example converts the string content into the byte array we will write into the file using the write() method.

Code:

import java.io.FileOutputStream;
import java.io.IOException;
public class GFG {
       public static void main(String[] args)
    {
        String f = "Hello";
        FileOutputStream o = null;
        // starting Try block 
        try {
            // creating an object of FileOutputStream
            o = new FileOutputStream("https://cdn.educba.com/Users/praashibansal/Desktop/Data/test.txt");
            // storing byte content from string
            byte[] str = f.getBytes();
            // writing into the file
            o.write(str);
            // printing success message 
            System.out.print(
                "data added successfully.");
        }
        // Catch block for exception handling
        catch (IOException e) {
                     System.out.print(e.getMessage());
        }
        finally {
            // closing the object
            if (o != null) {
                // checking if the file is closed 
                       try {
                                                       o.close();
                }
                catch (IOException e) {
                    // showing exception message
                    System.out.print(e.getMessage());
                }
            }
        }
    }
}

Output:

Method 4 – Using Files Class

• In Java 7, you will get another utility, Files class, allowing you to write to a text file using its write function.
• Internally, this class uses the OutputStream utility to write a byte array into the file.

Code:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
/**
 * Java Files write file example
 * 
 * @author pankaj
 *
 */
public class FCExample {
	public static void main(String[] args) {
		Path path = Paths.get("https://cdn.educba.com/Users/praashibansal/Desktop/Data/test.txt");
		try {
			String str = "Example";
			byte[] bs = str.getBytes();
			Path w = Files.write(path, bs);
			System.out.println("Written content in file:\n"+ new String(Files.readAllBytes(w)));
		} catch (IOException e) {
		}
	}
}

Output:

Conclusion

Reading and writing a file in Java is a straightforward process. With the availability of different methods and utilities in Java, you can choose a specific way to read from and write to a file. Each utility has its functionality that makes it different from others.

FAQs

Q1. What are the different methods to read a text file in Java?

Answer: To read, you can use Reader Class or utility class. Some utility classes are- File Class, FileReader, BufferedReader, and Scanner class.

Q2. What are the different methods for writing a text file in Java?

Answer: To write a file in Java, you can use FileWriter, BufferedWriter, java 7 Files, FileOutputStream, and many other methods.

Q3. What package to use for handling files in Java?

Answer: You can easily import the File class from the java.io package to work with files.

Das obige ist der detaillierte Inhalt vonTextdatei in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!