Serializacja to mechanizm, który zapisuje dane do postaci spakowanej (jako strumień bajtów). Odwrotnym procesem jest deserializacja – odczyt zapisanego strumienia danych i odtworzenie obiektów. Serializację stosuje się w przypadku, kiedy zapisane dane nie będą używane przez inne programy np: Excel, WordPad, tylko przez programy napisane w Javie. W przeciwnym razie stosuje się zapis stanu obiektu do postaci tekstowej. Dane w pliku tekstowym są rozdzielane określonymi znakami np: tabulacji, średnikami itp.
SERIALIZACJA I DESERIALIZACJA
Aby móc zastosować w klasie serializację należy zaimportować pakiet java.io i zaimplementować interfejs Serializable.
1 2 3 4 5 |
import java.io.*; public class Test implements Serializable { // ... } |
Obsługą zapisu pliku zajmuje się obiekt ObjectOutputStream , a odczytu ObjectInputStream.
1 2 |
ObjectOutputStream object = new ObjectOutputStream(new FileOutputStream("filename")); ObjectInputStream object = new ObjectInputStream(new FileInputStream("filename")); |
Przykład serializacji obiektu:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
import java.io.*; // importujemy pakiet java.io.* public class Test implements Serializable { private String test; private void setTest(String s) // ustawia dane do zapisu { test = s; } public static void main(String[] args) { Test t = new Test(); t.setTest("Ta treść będzie zapisana w pliku..."); try { // tworzy strumień do zapisu ObjectOutputStream o = new ObjectOutputStream( new FileOutputStream("C:/test.ser") ); o.writeObject(t); // zapisanie obiektu o.close(); // zamknięcie strumienia } catch (Exception ex) // zgłasza wyjątki { ex.printStackTrace(); } } } |
Deserializacja jest równie prosta:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// ... try { ObjectInputStream o = new ObjectInputStream( new FileInputStream("C:/test.ser") ); Test obj = (Test) o.readObject(); // odczyt obiektu ze strumienia o.close(); System.out.println(obj.getTest()); // wyświetlenie zawartości pliku } catch (Exception ex) { ex.printStackTrace(); } // ... |
ZAPIS DO PLIKU TEKSTOWEGO
Zapis łańcucha znaków odbywa się za pomocą strumienia FileWriter. Do odczytu stosuje się strumień FileReader , który łączy się z plikiem tekstowym oraz BufferedReader, który gromadzi dane aż do wypełnienia bufora pamięci.
Przykład zapisu:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
import java.io.*; public class Zapis { public static void main(String[] args) { try { FileWriter txt = new FileWriter("C:/tekst.txt"); txt.write("Ta treść zostanie zapisana w pliku tekstowym ..."); txt.close(); } catch (IOException ex) { ex.printStackTrace(); } } } |
Odczyt zawartości pliku:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
import java.io.*; public class Odczyt { public static void main(String[] args) { String zawartosc_pliku = null; try { File plik = new File("C:/tekst.txt"); BufferedReader odczyt = new BufferedReader(new FileReader(plik)); while ( (zawartosc_pliku = odczyt.readLine())!=null ) { System.out.println(zawartosc_pliku); } odczyt.close(); } catch (IOException ex) { ex.printStackTrace(); } } } |
Czytaj dalej: WĄTKI →