Przykłady tłumaczące pliki

plik.txt

+Ala ma kota
+Ola ma psa
+Sierotka ma rysia

src/p20_pliki/CzytajPlik_BufferedReader1.java

+package p20_pliki;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class CzytajPlik_BufferedReader1 {
+
+    public static void main(String[] args) {
+        // BufferedReader działa szybciej niż Scanner, ale potrafi mniej niż Scanner
+        // Tutaj używamy starszego sposobu tworzenia obiektu BufferedReader
+        try(BufferedReader reader = new BufferedReader(new FileReader("nowy3.txt"))) {
+            while(true) {
+                String line = reader.readLine();
+                if(line == null) break; // koniec pliku
+                System.out.println(line);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

src/p20_pliki/CzytajPlik_BufferedReader2.java

+package p20_pliki;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+public class CzytajPlik_BufferedReader2 {
+
+    public static void main(String[] args) {
+        // BufferedReader działa szybciej niż Scanner, ale potrafi mniej niż Scanner
+        // Tutaj używamy nowszego sposobu tworzenia obiektu BufferedReader - za pośrednictwem klasy Files
+        // Inaczej zapiszemy też warunek pętli.
+        try(BufferedReader reader = Files.newBufferedReader(Paths.get("nowy3.txt"))) {
+            String line;
+            while((line = reader.readLine()) != null) {
+                System.out.println(line);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

src/p20_pliki/CzytajPlik_ReadAllLines.java

+package p20_pliki;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.List;
+
+// Od Java 7 istnieje klasa Files, która posiada b. dużo gotowych operacji na plikach.
+// readAllLines czyta całą treść pliku tekstowego w formie listy linii.
+// Cała treść jest wczytywana do pamięci - to jest kosztowne dla dużych plików.
+public class CzytajPlik_ReadAllLines {
+
+    public static void main(String[] args) {
+        
+        try {
+            List<String> lines = Files.readAllLines(Paths.get("plik.txt"));
+            System.out.println("Odczytanych linii: " + lines.size());
+            for (String line : lines) {
+                System.out.println(line);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+}

src/p20_pliki/CzytajPlik_Scanner.java

+package p20_pliki;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
+public class CzytajPlik_Scanner {
+// ścieżki do plików w Javie można podawać w wersji systemowej
+// wtedy na Windows używa się znaku backslash, a backslashe w Stringach Javy trzeba pisać podwójnie
+// new File("C:\\Users\\patryk\\Documents\\plik.txt")
+// ale zawsze można też podać wersję ze slashami / (także na Windows)
+// new File("C:/Users/patryk/Documents/plik.txt")
+
+    public static void main(String[] args) {
+        try(Scanner scanner = new Scanner(new File("nowy3.txt"))) {
+            while(scanner.hasNextLine()) {
+                String line = scanner.nextLine();
+                System.out.println(line);
+            }
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

src/p20_pliki/CzytajPlik_Stream.java

+package p20_pliki;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+public class CzytajPlik_Stream {
+    // Przetwarzanie strumieniowe (od Java 8).
+    // Wszystkie linie NIE SĄ wczytywane na raz, tylko są przetwarzane pojedynczo.
+    public static void main(String[] args) {
+        
+        try {
+            Files.lines(Paths.get("plik.txt"))
+                .filter(line -> !line.isBlank())
+                .forEach(line -> System.out.println(line));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

src/p20_pliki/ZapiszLiczby1.java

+package p20_pliki;
+
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+
+public class ZapiszLiczby1 {
+
+    public static void main(String[] args) {
+        try {
+            PrintWriter out = new PrintWriter("liczby1.txt");
+            for(int i = 1; i <= 10_000; i++) {
+                out.println(i);
+            }
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+
+        System.out.println("Gotowe");
+    }
+
+}

src/p20_pliki/ZapiszLiczby2.java

+package p20_pliki;
+
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+
+public class ZapiszLiczby2 {
+
+    public static void main(String[] args) {
+        try {
+            PrintWriter out = new PrintWriter("liczby2.txt");
+            for(int i = 1; i <= 9900; i++) {
+                out.println(i);
+                if(i % 1000 == 0) {
+                    out.flush(); // wyślij do pliku to, co jest zebrane w buforze
+                }
+            }
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+
+        System.out.println("Gotowe");
+    }
+
+}

src/p20_pliki/ZapiszLiczby3.java

+package p20_pliki;
+
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+
+public class ZapiszLiczby3 {
+
+    public static void main(String[] args) {
+        try {
+            PrintWriter out = new PrintWriter("liczby3.txt");
+            for(int i = 1; i <= 10_000; i++) {
+                out.println(i);
+            }
+            out.close();
+            // gdy wykonujemy close(), to nie trzeba robić flush()
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+
+        System.out.println("Gotowe");
+    }
+
+}

src/p20_pliki/ZapiszLiczby4.java

+package p20_pliki;
+
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+
+public class ZapiszLiczby4 {
+
+// Otwierając plik można ustawić autoFlush=true
+// Wszystkie dane będą zapisywane w pliku od razu (nawet gdy nie zrobimy close())
+// Ale to zmniejsza wydajność
+// Zamykanie zasobów i tak jest zalecane
+// TO NIE JEST PRZYKŁAD DO NALADOWANIA
+    public static void main(String[] args) {
+        try {
+            PrintWriter out = new PrintWriter(new FileWriter("liczby4.txt"), true);
+            for(int i = 1; i <= 10_000; i++) {
+                out.println(i);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        System.out.println("Gotowe");
+    }
+
+}

src/p20_pliki/ZapiszPlik1.java

+package p20_pliki;
+
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+
+public class ZapiszPlik1 {
+
+    public static void main(String[] args) {
+        // Najczęściej używanym sposobem zapisywania danych do plików tekstowych jest PrintWriter
+        try {
+            PrintWriter out = new PrintWriter("nowy1.txt");
+            out.println("Ala ma kota");
+            out.println("Ola ma psa");
+            // brak close() - teksty w praktyce nie zapiszą się w pliku
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+        System.out.println("Gotowe");
+    }
+
+}

src/p20_pliki/ZapiszPlik2.java

+package p20_pliki;
+
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+import java.time.LocalTime;
+
+public class ZapiszPlik2 {
+
+    public static void main(String[] args) {
+        LocalTime now = LocalTime.now();
+        System.out.println(now);
+        int cyfra = now.getSecond() % 10;
+
+        try {
+            PrintWriter out = new PrintWriter("nowy2.txt");
+            out.println("Ala ma kota");
+            out.println("Ola ma psa");
+            out.println("czas: " + now);
+            out.println("wynik dzielenia: " + (100 / cyfra));
+            out.println("Ostatnia linia");
+            out.close();
+            // close() napisany "tak po prostu" jest niepewny
+            // gdy dojdzie do wyjątu w czasie pracy z plikiem (i nie musi być to błąd dotyczący pliku)
+            // to wtedy taki close zostanie pominięty
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        } catch (ArithmeticException e) {
+            System.out.println("nie dziel przez zero!");
+        }
+        System.out.println("Gotowe");
+    }
+
+}

src/p20_pliki/ZapiszPlik3.java

+package p20_pliki;
+
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+import java.time.LocalTime;
+
+public class ZapiszPlik3 {
+
+    public static void main(String[] args) {
+        LocalTime now = LocalTime.now();
+        System.out.println(now);
+        int cyfra = now.getSecond() % 10;
+
+        // Najczęściej używanym sposobem zapisywania danych do plików tekstowych jest PrintWriter
+        // Od Java 7 istnieje konstrukcja "try-with-resources"
+        // "Zasoby" otwarte w nazwiasach okrągłych za słowem try
+        // są automatycznie zamykane w momencie opuszczania tego bloku try
+        // w każdej z sytuacji:
+        // - program normalnie dochodzi do końca try
+        // - następuje wyjątek i jest on obsłużony w catch
+        // - następuje wyjątek i nie jest on obsługiwany
+        // - gdy z bloku try wychodzimy za pomocą return, break, continue
+        try(PrintWriter out = new PrintWriter("nowy3.txt")) {
+            out.println("Ala ma kota");
+            out.println("Ola ma psa");
+            out.println("czas: " + now);
+            out.println("wynik dzielenia: " + (100 / cyfra));
+            out.println("Ostatnia linia");
+            // wewnątrz try-with-resources nie trzeba już pisać close
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        } catch (ArithmeticException e) {
+            System.out.println("nie dziel przez zero!");
+        }
+        System.out.println("Gotowe");
+    }
+
+}

src/p20_pliki/ZapiszPlik4.java

+package p20_pliki;
+
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+import java.time.LocalTime;
+
+public class ZapiszPlik4 {
+
+    public static void main(String[] args) {
+        LocalTime now = LocalTime.now();
+        System.out.println(now);
+        int cyfra = now.getSecond() % 10;
+
+        // Innym sposobem skutecznego zamykania plików i innych zasobów jest zamykanie w sekcji finally.
+        // Trzeba zadbać o zasięg zmiennej i pilnować, czy zmienna nie jest nullem.
+        PrintWriter out = null;
+        try {
+            out = new PrintWriter("nowy4.txt");
+            out.println("Ala ma kota");
+            out.println("Ola ma psa");
+            out.println("czas: " + now);
+            out.println("wynik dzielenia: " + (100 / cyfra));
+            out.println("Ostatnia linia");
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        } catch (ArithmeticException e) {
+            System.out.println("nie dziel przez zero!");
+        } finally {
+            if(out != null)
+                out.close();
+        }
+        System.out.println("Gotowe");
+    }
+
+}