Programowanie obiektowe /Java/
Laboratorium nr 11
1 Klasa File
Klasa F ile służy do reprezentacji plików oraz katalogów.
Przykład wyświetlający plików o podanym rozszerzeniu:
1 package pl.kielce.tu.lab11;
2
3 import java.io.File;
4 import java.io.FilenameFilter;
5 import java.util.Arrays;
6
7 import javax.swing.JOptionPane;
8
9 public class ListFiles {
10 public static void main(String[] args) throws Exception {
11 File f = new File("tmp.txt");
12 f.createNewFile();
13 System.out.print(f.isDirectory() ? "d" : "");
14 System.out.print(f.isFile() ? "f" : "");
15 System.out.print(f.canRead() ? "r" : "-");
16 System.out.print(f.canWrite() ? "w" : "-");
17 System.out.print(f.canExecute() ? "x" : "-");
18 System.out.print(f.isHidden() ? "h" : "-");
19 System.out.print("\t" + f.getAbsolutePath() + "\n");
20 f = new File(".");
21 final String s = JOptionPane.showInputDialog(null, "Select extension", "java");
22 System.out.println(Arrays.toString(f.list(new FilenameFilter() {
23 public boolean accept(File dir, String name) {
24 if (s == null)
25 return true;
26 if (name.endsWith(s))
27 return true;
28 return false;
29 }
30 })));
31 }
32 }
Przykład 1: src/pl/kielce/tu/lab11/ListFiles.java{link}
Przykład wyświetlający informacje o głównych katalogach systemu plików:
1 package pl.kielce.tu.lab11;
2
3 import java.io.File;
4
5 public class ListRoots {
6 public static void main(String[] args) throws Exception {
7 File[] roots = File.listRoots();
8 for (File root : roots) {
9 System.out.print(root.getAbsolutePath());
10 System.out.printf(" Total: %6d MB ",
11 root.getTotalSpace() / 1024 / 1024);
12 System.out.printf(" Free : %6d MB \n",
13 root.getFreeSpace() / 1024 / 1024);
14 }
15 }
1
16 }
Przykład 2: src/pl/kielce/tu/lab11/ListRoots.java{link}
2 InputStream i OutputStream
Abstrakcyjna klasa InputStream jest klasą bazową wszystkich klas reprezentujących wejściowy strumień
bajtów.
java.lang.Object
- java.io.InputStream
- java.io.ByteArrayInputStream
- java.io.FileInputStream
- java.io.FilterInputStream
- java.io.ObjectInputStream
- java.io.PipedInputStream
- java.io.SequenceInputStream
Abstrakcyjna klasa OutputStream jest klasą bazową wszystkich klas reprezentujących wyjściowy strumień
bajtów.
java.lang.Object
- java.io.OutputStream
- java.io.ByteArrayOutputStream
- java.io.FileOutputStream
- java.io.FilterOutputStream
- java.io.ObjectOutputStream
- java.io.PipedOutputStream
Przykład zapisu i odczytu danych z tablicy:
1 package pl.kielce.tu.lab11;
2
3 import java.io.ByteArrayInputStream;
4 import java.io.ByteArrayOutputStream;
5
6 public class TestArrays {
7 public static void main(String[] args) throws Exception {
8 ByteArrayOutputStream o1 = new ByteArrayOutputStream();
9 String t1 = "Ala ma kota, a kot ma Ale";
10 byte[] b1 = t1.getBytes();
11 o1.write(b1);
12 byte[] b2 = new byte[] {  ; ,  . ,  : };
13 o1.write(b2, 1, 1);
14 byte[] b3 = o1.toByteArray();
15 o1.close();
16 ByteArrayInputStream i1 = new ByteArrayInputStream(b3);
17 int i = 0;
18 while (i1.available() > 0)
19 System.out.print(i++ + ":" + (char) i1.read() + " ");
20 i1.close();
21 System.out.println();
22
23 }
24 }
Przykład 3: src/pl/kielce/tu/lab11/TestArrays.java{link}
Przykład zapisu i odczytu danych z pliku:
2
1 package pl.kielce.tu.lab11;
2
3 import java.io.DataInputStream;
4 import java.io.DataOutputStream;
5 import java.io.File;
6 import java.io.FileInputStream;
7 import java.io.FileOutputStream;
8 import java.util.Random;
9
10 public class TestFiles {
11 public static void main(String[] args) throws Exception {
12 File f1 = new File("tmp.txt");
13 FileOutputStream o2 = new FileOutputStream(f1);
14 DataOutputStream o3 = new DataOutputStream(o2);
15 int i = 0;
16 for (Random r = new Random(); i < 5; i++) {
17 int tmp = r.nextInt();
18 o3.writeInt(tmp);
19 System.out.print(i + ">>:" + tmp + " ");
20 }
21 o3.close();
22 o2.close();
23 System.out.println();
24 FileInputStream i2 = new FileInputStream(f1);
25 DataInputStream i3 = new DataInputStream(i2);
26 i = 0;
27 while (i3.available() > 0)
28 System.out.print(i++ + "<<:" + i3.readInt() + " ");
29 i3.close();
30 i2.close();
31 System.out.println();
32 }
33 }
Przykład 4: src/pl/kielce/tu/lab11/TestFiles.java{link}
3 Reader i Writer
Abstrakcyjna klasa Reader odpowiadająca za odczyt strumienia znaków (Unicode).
java.lang.Object
-java.io.Reader
-java.io.BufferedReader
-java.io.CharArrayReader
-java.io.FilterReader
-java.io.InputStreamReader
-java.io.FileReader
-java.io.PipedReader
-java.io.StringReader
Abstrakcyjna klasa Writer odpowiadająca za zapis strumienia znaków (Unicode).
java.lang.Object
-java.io.Writer
-java.io.BufferedWriter
-java.io.CharArrayWriter
-java.io.FilterWriter
-java.io.OutputStreamWriter
-java.io.FileWriter
-java.io.PipedWriter
3
-java.io.PrintWriter
-java.io.StringWriter
Przykład wczytywania danych z klawiatury i zapis do pliku, aż do wprowadzenia wiersza o zerowej długości:
1 package pl.kielce.tu.lab11;
2
3 import java.io.BufferedReader;
4 import java.io.File;
5 import java.io.FileWriter;
6 import java.io.InputStreamReader;
7
8 public class TestKeyboard {
9 public static void main(String[] args) throws Exception {
10 String newLine = System.getProperty("line.separator");
11 File f = new File("test.txt");
12 FileWriter w = new FileWriter(f);
13 BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
14 String line = null;
15 while ((line = in.readLine()) != null && line.length() > 0) {
16 System.out.println(">>>" + line);
17 w.write(">>>" + line + newLine);
18 }
19 System.out.println(">-<");
20 w.write(">-<");
21 in.close();
22 w.close();
23 }
24 }
Przykład 5: src/pl/kielce/tu/lab11/TestKeyboard.java{link}
Dane mogą zostać wczytane z klawiatury także przy pomocy klasy Scanner.
1 package pl.kielce.tu.lab11;
2
3 import java.util.Scanner;
4
5 public class TestScanner {
6 public static void main(String[] args) throws Exception {
7 Scanner sc = new Scanner(System.in);
8 System.out.println("Scanner.nextLine() = " + sc.nextLine());
9 }
10 }
Przykład 6: src/pl/kielce/tu/lab11/TestScanner.java{link}
4 Serializacja
Serializacja umożliwia konwersję obiektu do strumienia bajtów, tak aby póz
niej było możliwe jego wier-
ne odtworzenie. Tylko obiekty klasy implementującej interfejs znacznikowy java.io.Serializable mogą być
serializowane. Zserializowany obiekt może zostać np:
- zapisany na dysku,
- przesłany przez sieć.
Serializacja jest wykorzystywana między innymi przez:
- RMI (Remote Method Invocation),
- JavaBeans.
4
Jednym z wariantów serializacji jest serializacja XML.
Metody związane z serializacją:
private void writeObject(java.io.ObjectOutputStream out) throws IOException
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException;
private void readObjectNoData() throws ObjectStreamException;
Interfejs java.io.Externalizable:
void writeExternal(ObjectOutput out) throws IOException;
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
Domyślnie podczas serializacji nie są zapisywane pola typu: static oraz transient.
Przykład zapisu oraz odczytu obiektu klasy MyClass z pliku:
1 package pl.kielce.tu.lab11;
2
3 import java.io.File;
4 import java.io.FileInputStream;
5 import java.io.FileOutputStream;
6 import java.io.ObjectInputStream;
7 import java.io.ObjectOutputStream;
8 import java.io.Serializable;
9
10 class MyClass implements Serializable {
11 private static final long serialVersionUID = 1L;
12 private final String a;
13 private final int b;
14
15 MyClass(final String a, final int b) {
16 this.a = a;
17 this.b = b;
18 }
19
20 public String toString() {
21 return super.toString() + " a = " + a + " b = " + b;
22 }
23 }
24
25 public class TestSerialization {
26 public static void main(String[] args) throws Exception {
27 File f2 = new File("tmp2.txt");
28 FileOutputStream o4 = new FileOutputStream(f2);
29 ObjectOutputStream o5 = new ObjectOutputStream(o4);
30 Object o = new MyClass("Tmp", 1);
31 System.out.println(">>:" + o);
32 o5.writeObject(o);
33 o5.close();
34 o4.close();
35 FileInputStream i4 = new FileInputStream(f2);
36 ObjectInputStream i5 = new ObjectInputStream(i4);
37 System.out.println("<<:" + i5.readObject() + " ");
38 i5.close();
39 i4.close();
40 }
41 }
Przykład 7: src/pl/kielce/tu/lab11/TestSerialization.java{link}
5
5 Konsola
Przykład wprowadzania hasła. Uwaga !!! Program do poprawnego działania może wymagać uruchomienia
z wiersza poleceń np. java Test.
1 package pl.kielce.tu.lab11;
2
3 import java.io.Console;
4
5 public class TestConsole {
6 public static void main(String[] args) throws Exception {
7 Console c = System.console();
8 if (c == null) {
9 System.out.println("Console error");
10 System.exit(1);
11 }
12 String login = c.readLine("Login: ");
13 char[] password = c.readPassword("Password:");
14 System.out.println("Login: " + login + " Password: "
15 + new String(password));
16 }
17 }
Przykład 8: src/pl/kielce/tu/lab11/TestConsole.java{link}
6 Przekierowanie standardowych strumieni
Przekierowanie strumieni:
- standardowego wejście  System.setIn(?),
- standardowego wyjście  System.setOut(?),
- standardowego wyjście błędów  System.setErr(?).
7 Wskaz
nik postępu
Wskaz
nik postępu wczytywania pliku. Uwaga !!! Należy podać pełną ścieżkę do pliku. Dla małych plików
wskaz
nik postępu prawdopodobnie nie pojawi się.
1 package pl.kielce.tu.lab11;
2
3 import java.io.BufferedInputStream;
4 import java.io.BufferedReader;
5 import java.io.FileInputStream;
6 import java.io.IOException;
7 import java.io.InputStream;
8 import java.io.InputStreamReader;
9 import javax.swing.JOptionPane;
10 import javax.swing.ProgressMonitorInputStream;
11
12 public class TestProgress {
13 public static void main(String[] args) throws IOException {
14 String fileName = JOptionPane.showInputDialog(null, "Enter file name");
15 if (fileName != null) {
16 InputStream in = new BufferedInputStream(
17 new ProgressMonitorInputStream(null, "Reading from file: "
18 + fileName, new FileInputStream(fileName)));
19 BufferedReader reader = new BufferedReader(
20 new InputStreamReader(in));
6
21 String line = null;
22 while ((line = reader.readLine()) != null)
23 System.out.println(line);
24 }
25 }
26 }
Przykład 9: src/pl/kielce/tu/lab11/TestProgress.java{link}
8 Przykładowa treść laboratorium
1. Proszę wczytać dane z pliku, konsoli, tablicy, następnie przetworzyć dane (np. zamienić wielkość liter
w co drugim wierszy, wyrazie itp.), a na koniec zapisać do pliku, konsoli, tablicy.
2. Proszę wyświetlić rekurencyjnie wszystkie katalogi i pliki, które spełniają określony warunek (np. pliki,
których nazwa zaczyna się od litery X).
3. Proszę zserializować obiekt podanej klasy do tablicy bajtów. Długość tablicy oraz fragmenty tablicy
zapisać w kilku plikach. Następnie odtworzyć obiekt.
7