Mehrere Möglichkeiten zum Lesen von Dateien in Java 1. Lesen Sie Dateiinhalte auf verschiedene Arten.
1. Dateiinhalt byteweise lesen
2. Lesen Sie den Dateiinhalt zeichenweise
3. Lesen Sie den Dateiinhalt Zeile für Zeile
4. Dateiinhalte nach dem Zufallsprinzip lesen
*/
import java.io.BufferedReader;
java.io.File importieren;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
java.io.Reader importieren;
öffentliche Klasse ReadFromFile {
/**
* Lesen Sie Dateien in Bytes. Wird häufig zum Lesen von Binärdateien wie Bildern, Tönen, Bildern usw. verwendet.
* @param fileName Der Name der Datei
*/
public static void readFileByBytes(String fileName){
Datei file = new File(fileName);
InputStream in = null;
versuchen {
System.out.println("Lesen Sie den Dateiinhalt in Bytes, ein Byte nach dem anderen:");
//Lesen Sie jeweils ein Byte
in = new FileInputStream(file);
int tempbyte;
while((tempbyte=in.read()) != -1){
System.out.write(tempbyte);
}
in.close();
} Catch (IOException e) {
e.printStackTrace();
zurückkehren;
}
versuchen {
System.out.println("Lesen Sie den Dateiinhalt in Bytes, mehrere Bytes gleichzeitig:");
//Mehrere Bytes gleichzeitig lesen
byte[] tempbytes = neues byte[100];
int byteread = 0;
in = new FileInputStream(fileName);
ReadFromFile.showAvailableBytes(in);
// Mehrere Bytes in das Byte-Array lesen. Byteread ist die Anzahl der gleichzeitig gelesenen Bytes
while ((byteread = in.read(tempbytes)) != -1){
System.out.write(tempbytes, 0, byteread);
}
} Catch (Ausnahme e1) {
e1.printStackTrace();
} Endlich {
if (in != null){
versuchen {
in.close();
} Catch (IOException e1) {
}
}
}
}
/**
* Lesen Sie Dateien in Zeicheneinheiten, die häufig zum Lesen von Text, Zahlen und anderen Dateitypen verwendet werden
* @param fileName Dateiname
*/
public static void readFileByChars(String fileName){
Datei file = new File(fileName);
Leser-Leser = null;
versuchen {
System.out.println("Lesen Sie den Dateiinhalt in Zeicheneinheiten, jeweils ein Byte:");
//Lesen Sie jeweils ein Zeichen
reader = new InputStreamReader(new FileInputStream(file));
int tempchar;
while ((tempchar = reader.read()) != -1){
//Unter Windows stellen die beiden Zeichen rn, wenn sie zusammen sind, eine neue Zeile dar.
//Wenn diese beiden Zeichen jedoch separat angezeigt werden, werden die Zeilen zweimal geändert.
//Deshalb Schild r oder Schild n. Andernfalls entstehen viele Leerzeilen.
if (((char)tempchar) != 'r'){
System.out.print((char)tempchar);
}
}
reader.close();
} Catch (Ausnahme e) {
e.printStackTrace();
}
versuchen {
System.out.println("Lesen Sie den Dateiinhalt in Zeicheneinheiten, mehrere Bytes gleichzeitig:");
//Mehrere Zeichen gleichzeitig lesen
char[] tempchars = new char[30];
int charread = 0;
reader = new InputStreamReader(new FileInputStream(fileName));
// Mehrere Zeichen in das Zeichenarray einlesen, charread ist die Anzahl der gleichzeitig gelesenen Zeichen
while ((charread = reader.read(tempchars))!=-1){
//In ähnlicher Weise r vor der Anzeige schützen
if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != 'r')){
System.out.print(tempchars);
}anders{
for (int i=0; i<charread; i++){
if(tempchars[i] == 'r'){
weitermachen;
}anders{
System.out.print(tempchars[i]);
}
}
}
}
} Catch (Ausnahme e1) {
e1.printStackTrace();
}Endlich {
if (reader != null){
versuchen {
reader.close();
} Catch (IOException e1) {
}
}
}
}
/**
* Lesen Sie Dateien in Zeileneinheiten, die häufig zum Lesen zeilenorientiert formatierter Dateien verwendet werden
* @param fileName Dateiname
*/
public static void readFileByLines(String fileName){
Datei file = new File(fileName);
BufferedReader-Reader = null;
versuchen {
System.out.println("Lesen Sie den Dateiinhalt in Zeileneinheiten und lesen Sie jeweils eine ganze Zeile:");
reader = new BufferedReader(new FileReader(file));
String tempString = null;
int Zeile = 1;
//Eine Zeile nach der anderen lesen, bis null als Ende der Datei gelesen wird
while ((tempString = reader.readLine()) != null){
//Zeilennummer anzeigen
System.out.println("line " + line + ": " + tempString);
Zeile++;
}
reader.close();
} Catch (IOException e) {
e.printStackTrace();
} Endlich {
if (reader != null){
versuchen {
reader.close();
} Catch (IOException e1) {
}
}
}
}
/**
* Dateiinhalte nach dem Zufallsprinzip lesen
* @param fileName Dateiname
*/
public static void readFileByRandomAccess(String fileName){
RandomAccessFile randomFile = null;
versuchen {
System.out.println("Zufälligen Dateiinhalt lesen:");
// Öffnen Sie einen Dateistream mit wahlfreiem Zugriff im schreibgeschützten Modus
randomFile = new RandomAccessFile(fileName, "r");
//Dateilänge, Anzahl Bytes
long fileLength = randomFile.length();
//Lesen Sie die Startposition der Datei
int beginIndex = (fileLength > 4) 4 : 0;
//Verschiebe die Startposition der gelesenen Datei an die beginIndex-Position.
randomFile.seek(beginIndex);
byte[] bytes = neues byte[10];
int byteread = 0;
//Lesen Sie jeweils 10 Bytes. Wenn der Dateiinhalt weniger als 10 Bytes beträgt, lesen Sie die verbleibenden Bytes.
// Weisen Sie byteread die Anzahl der gleichzeitig gelesenen Bytes zu
while ((byteread = randomFile.read(bytes)) != -1){
System.out.write(bytes, 0, byteread);
}
} Catch (IOException e){
e.printStackTrace();
} Endlich {
if (randomFile != null){
versuchen {
randomFile.close();
} Catch (IOException e1) {
}
}
}
}
/**
* Zeigt die Anzahl der im Eingabestream verbleibenden Bytes an
* @param in
*/
private static void showAvailableBytes(InputStream in){
versuchen {
System.out.println("Die Anzahl der Bytes im aktuellen Byte-Eingabestream beträgt:" + in.available());
} Catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String fileName = "C:/temp/newTemp.txt";
ReadFromFile.readFileByBytes(fileName);
ReadFromFile.readFileByChars(fileName);
ReadFromFile.readFileByLines(fileName);
ReadFromFile.readFileByRandomAccess(fileName);
}
}
2. Hängen Sie den Inhalt am Ende der Datei an
import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
* Hängen Sie den Inhalt am Ende der Datei an
*/
öffentliche Klasse AppendToFile {
/**
*Eine Methode zum Anhängen von Dateien: Verwenden Sie RandomAccessFile
* @param fileName Dateiname
* @param content zusätzlicher Inhalt
*/
public static void appendMethodA(String fileName,
String-Inhalt){
versuchen {
// Öffnen Sie einen Dateistream mit wahlfreiem Zugriff im Lese- und Schreibmodus
RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
//Dateilänge, Anzahl Bytes
long fileLength = randomFile.length();
//Bewegen Sie den Schreibdateizeiger an das Ende der Datei.
randomFile.seek(fileLength);
randomFile.writeBytes(content);
randomFile.close();
} Catch (IOException e){
e.printStackTrace();
}
}
/**
* Methode B zum Anhängen von Dateien: Verwenden Sie FileWriter
* @param Dateiname
* @param-Inhalt
*/
public static void appendMethodB(String fileName, String content){
versuchen {
//Öffne einen Datei-Writer. Der zweite Parameter true im Konstruktor bedeutet, dass die Datei in Anhängeform geschrieben wird.
FileWriterwriter = new FileWriter(fileName, true);
Writer.write(content);
Writer.close();
} Catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String fileName = "C:/temp/newTemp.txt";
String-Inhalt = „neues Anhängen!“;
//Dateien gemäß Methode A anhängen
AppendToFile.appendMethodA(fileName, content);
AppendToFile.appendMethodA(fileName, "append end. n");
//Dateiinhalt anzeigen
ReadFromFile.readFileByLines(fileName);
//Dateien gemäß Methode B anhängen
AppendToFile.appendMethodB(fileName, content);
AppendToFile.appendMethodB(fileName, "append end. n");
//Dateiinhalt anzeigen
ReadFromFile.readFileByLines(fileName);
}
}