Java IO Hantering
Introduktion
Input- och outputhantering (IO) är en grundläggande del av nästan alla Java-applikationer. Java IO-hantering tillhandahåller medel för att läsa och skriva data till och från olika källor, inklusive filer, nätverk och enheter. I den här omfattande guiden kommer vi att utforska Java IO-hanteringsmekanismerna i detalj och ge praktiska exempel på hur man effektivt läser, skriver, lagrar och manipulerar data.
Läsning från filer
För att läsa data från en fil i Java använder vi följande steg:
* Öppna filen: Använd java.io.File-klassen för att skapa ett File-objekt som representerar filen och java.io.FileReader-klassen för att öppna en FileReader till filen.
* Läs data: Använd FileReader för att läsa data från filen till en BufferedReader. BufferedReader tillhandahåller metoder som readLine() och read() för att läsa data rad för rad eller tecken för tecken.
* Stäng filen: När du är klar med att läsa data, stäng BufferedReader och FileReader för att frigöra resurser.
Exempel:
java
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
public class LäsFil {
public static void main(String[] args) {
try {
// Öppna filen
File file = new File("fil.txt");
FileReader fileReader = new FileReader(file);
BufferedReader bufferedReader = new BufferedReader(fileReader);
// Läs data från filen
String line;
while ((line = bufferedReader.readLine()) != null) {
System.out.println(line);
}
// Stäng filen
bufferedReader.close();
fileReader.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Skriva till filer
För att skriva data till en fil i Java använder vi följande steg:
* Öppna filen: Använd java.io.File-klassen för att skapa ett File-objekt som representerar filen och java.io.FileWriter-klassen för att öppna en FileWriter till filen.
* Skriv data: Använd FileWriter för att skriva data till filen med hjälp av metoder som write() och writeLine().
* Stäng filen: När du är klar med att skriva data, stäng FileWriter för att spola buffertar och frigöra resurser.
Exempel:
java
import java.io.File;
import java.io.FileWriter;
public class SkrivFil {
public static void main(String[] args) {
try {
// Öppna filen
File file = new File("fil.txt");
FileWriter fileWriter = new FileWriter(file);
// Skriv data till filen
fileWriter.write("Detta är en testrad");
fileWriter.writeLine("Detta är en annan testrad");
// Stäng filen
fileWriter.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Filhantering
Java IO-hantering tillhandahåller också klasser för att hantera filer och kataloger:
* java.io.File: Representerar en fil eller katalog i filsystemet.
* java.io.FileFilter: Ett gränssnitt för att filtrera filer och kataloger.
* java.io.FilenameFilter: Ett gränssnitt för att filtrera filnamn.
* java.nio.file.Files: En uppsättning verktyg för att hantera filer och kataloger.
Exempel:
java
import java.io.File;
import java.io.FileFilter;
public class FilHantering {
public static void main(String[] args) {
// Lista alla filer i en katalog
File dir = new File(".");
File[] files = dir.listFiles();
for (File file : files) {
System.out.println(file.getName());
}
// Filtrera filer efter namn
FileFilter filter = new FileFilter() {
@Override
public boolean accept(File file) {
return file.getName().endsWith(".txt");
}
};
files = dir.listFiles(filter);
for (File file : files) {
System.out.println(file.getName());
}
}
}
Strömmar
Strömmar är en annan viktig del av Java IO-hantering. Strömmar tillhandahåller ett abstrakt lager för att läsa och skriva data från olika källor. Java IO-biblioteket tillhandahåller följande typer av strömmar:
* Byte-strömmar: Används för att läsa och skriva råa bytes.
* Teckenströmmar: Används för att läsa och skriva tecken.
* Objektströmmar: Används för att läsa och skriva Java-objekt.
Exempel:
Byte-strömmar:
java
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class ByteStröm {
public static void main(String[] args) {
try {
// Läs en fil
FileInputStream fis = new FileInputStream("fil.txt");
byte[] data = fis.readAllBytes();
fis.close();
// Skriv till en fil
FileOutputStream fos = new FileOutputStream("nyfil.txt");
fos.write(data);
fos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Teckenströmmar:
java
import java.io.FileReader;
import java.io.FileWriter;
public class TeckenStröm {
public static void main(String[] args) {
try {
// Läs en fil
FileReader fr = new FileReader("fil.txt");
BufferedReader br = new BufferedReader(fr);
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
br.close();
fr.close();
// Skriv till en fil
FileWriter fw = new FileWriter("nyfil.txt");
BufferedWriter bw = new BufferedWriter(fw);
bw.write("Detta är en testrad");
bw.writeLine("Detta är en annan testrad");
bw.close();
fw.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Objektströmmar:
java
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class ObjektStröm {
public static void main(String[] args) {
try {
// Serialisera ett objekt
Person person = new Person("John", "Doe");
FileOutputStream fos = new FileOutputStream("person.ser");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(person);
oos.close();
fos.close();
// Deserialisera ett objekt
FileInputStream fis = new FileInputStream("person.ser");
ObjectInputStream ois = new ObjectInputStream(fis);
Person person2 = (Person) ois.readObject();
ois.close();
fis.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static class Person implements Serializable {
private String förnamn;
private String efternamn;
// Getters och setters
}
}
Slutsats
Java IO-hantering tillhandahåller en kraftfull uppsättning klasser och gränssnitt för att hantera datainmatning och utmatning. Genom att förstå mekanismerna för att läsa, skriva, lagra och manipulera data kan Java-utvecklare skapa robusta och effektiva applikationer som kan interagera med olika datakällor på ett pålitligt sätt. Java IO-hantering är en väsentlig del av Java-utveckling och kan användas för ett brett spektrum av uppgifter, från hantering enkla textfiler till att hantera komplexa datastrukturer och objekt.
Vanliga frågor
1. Vilken är skillnaden mellan läsare och författare i Java IO?
* Läsare används för att läsa data från en datakälla, medan författare används för att skriva data till en datakälla.
2. Hur hanterar jag kataloger i Java IO?
* Använd java.io.File och `java.nio.file.