Java IO Handledning

Inledning

Hantering av in- och utdata (IO) är en väsentlig komponent i nästan alla Java-applikationer. Java IO-hantering tillhandahåller de verktyg som behövs för att läsa in och skriva ut data från skilda platser, som filer, nätverk och enheter. Den här detaljerade guiden utforskar Java IO-hanteringsmetoderna i detalj och ger praktiska exempel på hur man på ett effektivt sätt läser, skriver, lagrar och bearbetar information.

Läsa från Filer

Följande steg används för att läsa data från en fil i Java:

• Öppna filen: Använd klassen java.io.File för att skapa ett filobjekt som identifierar filen och klassen java.io.FileReader för att initiera en FileReader mot filen.
• Hämta information: Använd FileReader för att överföra data från filen till en BufferedReader. BufferedReader ger metoder som readLine() och read() för att läsa information radvis eller teckenvis.
• Stäng filen: När läsningen är klar, stäng BufferedReader och FileReader för att frigöra systemresurser.

Exempel på Filinläsning

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

Nedan följer stegen för att skriva data till en fil i Java:

• Öppna filen: Använd java.io.File för att skapa ett File-objekt för filen och java.io.FileWriter för att öppna en FileWriter mot filen.
• Skriv information: Använd FileWriter och metoder som write() och writeLine() för att skriva till filen.
• Stäng filen: Stäng FileWriter efter skrivningen för att tömma buffertar och frigöra resurser.

Exempel på Filskrivning

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.write("Detta är en annan testrad" + System.lineSeparator());

            // Stäng filen
            fileWriter.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Filhantering

Java IO-hantering ger även klasser för att manipulera filer och kataloger:

• java.io.File: Representerar en fil eller mapp 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 verktygslåda för att hantera filer och kataloger.

Exempel på Filmanipulation

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();
        if (files != null) {
            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);
        if(files != null) {
            for (File file : files) {
            System.out.println(file.getName());
            }
        }
    }
}

Strömmar

Strömmar är en central del av Java IO-hantering. De ger ett abstrakt lager för att läsa och skriva data från olika källor. Java IO-biblioteket tillhandahåller dessa strömtyper:

• Byteströmmar: För att hantera råa bytes.
• Teckenströmmar: För att hantera tecken.
• Objektströmmar: För att hantera Java-objekt.

Exempel på Strömmar

Byteströmmar:

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

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 (IOException e) {
            e.printStackTrace();
        }
    }
}

Teckenströmmar:

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

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.newLine();
            bw.write("Detta är en annan testrad");
            bw.close();
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Objektströmmar:

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.io.IOException;

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();
          // Använd person2 här
           System.out.println(person2);

        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    public static class Person implements Serializable {
        private String förnamn;
        private String efternamn;

        public Person(String förnamn, String efternamn) {
            this.förnamn = förnamn;
            this.efternamn = efternamn;
        }
        @Override
        public String toString() {
           return "Namn: "+ förnamn + " " + efternamn;
        }
        // Getters och setters
    }
}

Sammanfattning

Java IO-hantering erbjuder en kraftfull uppsättning klasser och gränssnitt för att hantera in- och utdata. Genom att förstå hur man läser, skriver, lagrar och manipulerar data kan Java-utvecklare skapa robusta och effektiva applikationer som interagerar på ett pålitligt sätt med olika datakällor. Java IO-hantering är centralt för Java-utveckling och kan användas för många uppgifter, från att hantera enkla textfiler till att hantera komplexa datastrukturer och objekt.

Vanliga Frågor

1. Vad är skillnaden mellan läsare och skrivare i Java IO?

   Läsare används för att läsa data, medan skrivare används för att skriva data.

2. Hur hanteras mappar i Java IO?

   Mappar hanteras via java.io.File och java.nio.file.