Często podczas pracy programu chcielibyśmy wczytać dane lub zapisać wynik jego działania. Dotychczas wszystkie informacje potrzebne do działania aplikacji wprowadzaliśmy ręcznie lub umieszczaliśmy na stałe w programie. Język Java pozwala operować na plikach – tworzyć nowe pliki  i zapisywać do nich informacje; odczytać dane.

Naszym zadaniem na dziś będzie utworzenie pliku tekstowego, w skład którego będzie wchodzić 5 wierszy. W każdym wierszu zapiszemy dwie liczby całkowite oddzielone spacją. Liczby wczytamy do tablicy liczb całkowitych. Do pliku wynikowego zapiszemy sumę każdej pary wejściowej. 

Materiał nasza prezentuje pomijalny krok wczytywania danych do tablic liczb całkowitych. Operacja ta nie jest konieczna, gdy zadaniem aplikacji byłoby wyłącznie wygenerowanie pliku wynikowego z sumą każdej z par liczb. Na potrzeby naszego rozwiązania problemu przyjmijmy, że plik będzie składać się z pięciu par liczb. 
Pisanie naszego programu zaczniemy od zdefiniowania naszego pliku tekstowego w module Package Explorer. Plik do_odczytu.txt uzupełniamy zgodnie z założeniem pięcioma wierszami składającymi się z par liczb oddzielonych spacją:
1.	 23 12 
2.	 54 34
3.	 76 45
4.	  4 3
5.	  6 9


Implementację kodu zaczniemy od umieszczenia odpowiednich bibliotek które pozwolą nam zarządzać plikami. Dodajmy obsługę Scannera narzędzia służącego do pobierania danych od użytkownika oraz odczytu pliku. Przed użyciem musi zostać zaimportowana z java.utils.Scanner. Klasa File posłuży nam do zarządzania plikami. Pozwoli nam to sprawdzić, czy plik istnieje usunąć go, sprawdzić, czy mamy prawo do zapisu lub odczytu.

1 import java.util.Scanner;
2 import java.io.File;
3
4 public class Zadanie {
5    public static void main(String args[]) throws Exception {
6	    File plikOdczyt = new File("src/do_odczytu.txt");
7           Scanner scanner = new Scanner(plikOdczyt);
8
9           String wiersz="";
10
11		while(scanner.hasNextLine()) {
12			wiersz = scanner.nextInt();
13			System.out.println(wiersz);     
14             }
15
16             scanner.close();
17    }
18 }  

Po uruchomieniu naszego programu na konsoli powinna nam się wyświetlić zawartość naszego pliku do_odczytu.txt.

Poznaliśmy już podstawy i możemy już wczytać liczby do tablicy. Zaczniemy od przygotowania dodatkowych zmiennych. 

W miejsce wiersza dziewiątego i dziesiątego wpisujemy 

9               int liczby[][] = new int[5][2];
10		int iterator = 0;

Chcemy aby nasze liczby lądowały bezpośrednio do tablicy. Usuwamy wiersz 13 zawierający informację o przepisaniu linii z pliku do zmiennej wiersz. W jej miejsce zapiszemy dwie bliźniacze instrukcje. W wierszu 15 zmienimy instrukcję wyświetlania liczb na konsoli tak, aby zostały odczytane z liczby. Pamiętamy o zwiększeniu wartości iteratora w wierszu 16

1 import java.util.Scanner;
2 import java.io.File;
3
4 public class Zadanie {
5    public static void main(String args[]) throws Exception {
6	    File plikOdczyt = new File("src/do_odczytu.txt");
7           Scanner scanner = new Scanner(plikOdczyt);
8
9               int liczby[][] = new int[5][2];
10		int iterator = 0;
11
12		while(scanner.hasNextLine()) {
13		    liczby[iterator][0] = scanner.nextInt();
14		    liczby[iterator][1] = scanner.nextInt();
15		    SSystem.out.println(liczby[iterator][0] + " " + liczby[iterator][1]);
16                  iterator++; 
17             }
18
19             scanner.close();
20    }
21 } 

Zauważyliśmy, że po uruchomieniu konsoli zobaczyliśmy dokładnie ten sam wydruk co wcześniej więc aplikacja nasza działa poprawnie.
Udało się nam odczytać dane więc spróbujmy je zapisać do pliku. 
W wierszu 3 zapisujemy import klasy która odpowiada za tekstowy zapis danych do pliku:

3 import java.io.FileWriter;

W wierszu 22 i 23  tworzymy nowy obiekt:

22     FileWriter plikZapis = new FileWriter("src/do_zapisu.txt");
23     for(int i = 0; i < 5; i++)

W wierszu 25 plik zapis: 

25. plikZapis.write((liczby[i][0] + liczby[i][1] + " " );

W wierszu 28 poza pętlą zamykamy uchwyt do pliku"

28 plikZapis.close();

Na kod po zmianach wygląda tak oto:

1 import java.util.Scanner;
2 import java.io.File;
3 import java.io.FileWriter;
4
5 public class Zadanie {
6    public static void main(String args[]) throws Exception {
7	    File plikOdczyt = new File("src/do_odczytu.txt");
8		Scanner scanner = new Scanner(plikOdczyt);
9		
10		int liczby[][] = new int[5][2];
11		int iterator = 0;
12		
13		while(scanner.hasNextLine()) {
14		    liczby[iterator][0] = scanner.nextInt();
15		    liczby[iterator][1] = scanner.nextInt();
16		    System.out.println(liczby[iterator][0] + " " + liczby[iterator][1]);
17	            iterator++;
18		}
19
20      scanner.close();
21
22        FileWriter plikZapis = new FileWriter("src/do_zapisu.txt");
23        for(int i = 0; i < 5; i++)
24        {
25            plikZapis.write((liczby[i][0] + liczby[i][1] + " " );
26        }
27
28        plikZapis.close();
29    }
30 }	

Po uruchomieniu naszego programu wewnątrz naszego folderu src powinniśmy zauważyć nowy plik przechowujący sumę każdej pory wejściowej. 

W języku Java do kompletnego obsłużenia pliku tekstowego wykorzystujemy dwie klasy:
- typu Scanner (odczyt danych),
- typu FileWriter (zapis danych). 
Pojedynczą linię odczytujemy przy pomocy funkcji scanner.nextLine() która zwraca napis, do którego zostanie odczytana kolejna pojedyncza linia z pliku. 
Scanner potrafi odczytać fragmenty linii: wykorzystujemy w tym celu odpowiednią funkcję o prefiksie next (nextInt, nextDouble...). Pojedynczy odczyt kończy się, gdy scanner natrafi na spację lub tabulację.
Dane do pliku możemy zapisać przy pomocy obiektu klasy FileWriter, na którym wywołujmy metodą write(napisDoZapisania).
Po zakończeniu pracy z plikami musimy zamknąć do nich uchwyty poprzez wywołanie na obiektach typu Scanner i FileWriter metody close().