note: Classes discussed in this chapter are located in java.io.
FileReader reader = new FileReader ("input.txt"); int next = reader.read() char c; if (next != -1) c = (char)next(); ... reader.close()
FileWriter writer = new FileWriter("output.txt");
...
char c='';
...
writer.write(c); ...
write.close();
FileInputStream inputStream = new FileInputStream("input.dat"); int next = inputStream.read(); byte b; if (next != -1) b = (byte)next; ... inputStream.close();
FileOutputStream output = new FileOutputStream("output.txt");
... byte b = 0;
...
output.write(b); ...
write.close();
FileWriter writer = new FileWriter("output.txt"); PrintWriter out = new PrintWriter(writer);
out.println(29.95); out.println(new Rectangle(5,10,15,25)); out.println("Hello, World!");
FileReader reader = new FileReader ("input.txt"); BufferedReader in = new BufferedReader(reader); String inputLine = in.ReadLine(); double x = Double.parseDouble(inputLine);
File inputFile = new File("input.txt");
delete
renameTo
exists
FileReader reader = new FileReader(inputFile) ;
JFileChooser chooser new JFileChooser(); FileReader in = null; if (chooser.showOpenDialog(null) == JFileChooser.APPROVE_OPTION) { File selectedFile = chooser.getSelectedFile(); in = new FileReader(selectedFile); }
note: JFileChooser is in java.io
To encrypt a file means to scramble it so that it is readable only to those who know the encryption method and the secret keyword.
To use Caesar cipherint next - in.read(); if (next == -1) done = true; else { byte b = (byte)next; byte c = encrypt(b); //call the method to encrypt the byte out.write(c) }
1 | import java.io.File; |
2 | import java.io.FileInputStream; |
3 | import java.io.FileOutputStream; |
4 | import java.io.InputStream; |
5 | import java.io.OutputStream; |
6 | import java.io.IOException; |
7 | |
8 | /** |
9 | An encryptor encrypts files using the Caesar cipher. |
10 | For decryption, use an encryptor whose key is the |
11 | negative of the encryption key. |
12 | */ |
13 | public class Encryptor |
14 | { |
15 | /** |
16 | Constructs an encryptor. |
17 | @param aKey the encryption key |
18 | */ |
19 | public Encryptor(int aKey) |
20 | { |
21 | key = aKey; |
22 | } |
23 | |
24 | /** |
25 | Encrypts the contents of a file. |
26 | @param inFile the input file |
27 | @param outFile the output file |
28 | */ |
29 | public void encryptFile(File inFile, File outFile) |
30 | throws IOException |
31 | { |
32 | InputStream in = null; |
33 | OutputStream out = null; |
34 | |
35 | try |
36 | { |
37 | in = new FileInputStream(inFile); |
38 | out = new FileOutputStream(outFile); |
39 | encryptStream(in, out); |
40 | } |
41 | finally |
42 | { |
43 | if (in != null) in.close(); |
44 | if (out != null) out.close(); |
45 | } |
46 | } |
47 | |
48 | /** |
49 | Encrypts the contents of a stream. |
50 | @param in the input stream |
51 | @param out the output stream |
52 | */ |
53 | public void encryptStream(InputStream in, OutputStream out) |
54 | throws IOException |
55 | { |
56 | boolean done = false; |
57 | while (!done) |
58 | { |
59 | int next = in.read(); |
60 | if (next == -1) done = true; |
61 | else |
62 | { |
63 | byte b = (byte)next; |
64 | byte c = encrypt(b); |
65 | out.write(c); |
66 | } |
67 | } |
68 | } |
69 | |
70 | /** |
71 | Encrypts a byte. |
72 | @param b the byte to encrypt |
73 | @return the encrypted byte |
74 | */ |
75 | public byte encrypt(byte b) |
76 | { |
77 | return (byte)(b + key); |
78 | } |
79 | |
80 | private int key; |
81 | } |
1 | import java.io.File; |
2 | import java.io.IOException; |
3 | import javax.swing.JFileChooser; |
4 | import javax.swing.JOptionPane; |
5 | |
6 | /** |
7 | A program to test the Caesar cipher encryptor. |
8 | */ |
9 | public class EncryptorTest |
10 | { |
11 | public static void main(String[] args) |
12 | { |
13 | try |
14 | { |
15 | JFileChooser chooser = new JFileChooser(); |
16 | if (chooser.showOpenDialog(null) != JFileChooser.APPROVE_OPTION) System.exit(0); |
17 | |
18 | File inFile = chooser.getSelectedFile(); |
19 | if (chooser.showSaveDialog(null) != JFileChooser.APPROVE_OPTION) System.exit(0); |
20 | File outFile = chooser.getSelectedFile(); |
21 | String input = JOptionPane.showInputDialog("Key"); |
22 | int key = Integer.parseInt(input); |
23 | Encryptor crypt = new Encryptor(key); |
24 | crypt.encryptFile(inFile, outFile); |
25 | } |
26 | catch (NumberFormatException exception) |
27 | { |
28 | System.out.println("Key must be an integer: " + exception); |
29 | } |
30 | catch (IOException exception) |
31 | { |
32 | System.out.println("Error processing file: " + exception); |
33 | } |
34 | System.exit(0); |
35 | } |
36 | } |
class MyProgram { public static void main(String[] args) { ... } }
args[0] | "-d" |
args[1] | "file.txt" |
1 | import java.io.File; |
2 | import java.io.IOException; |
3 | |
4 | /** |
5 | A program to run the Caesar cipher encryptor with |
6 | command line arguments. |
7 | */ |
8 | public class Crypt |
9 | { |
10 | public static void main(String[] args) |
11 | { |
12 | boolean decrypt = false; |
13 | int key = DEFAULT_KEY; |
14 | File inFile = null; |
15 | File outFile = null; |
16 | |
17 | if (args.length < 2 || args.length > 4) usage(); |
18 | |
19 | try |
20 | { |
21 | for (int i = 0; i < args.length; i++) |
22 | { |
23 | if (args[i].charAt(0) == '-';) |
24 | { |
25 | // it is a command line option |
26 | char option = args[i].charAt(1); |
27 | if (option == 'd') |
28 | decrypt = true; |
29 | else if (option == 'k') |
30 | key = Integer.parseInt(args[i].substring(2)); |
31 | } |
32 | else |
33 | { |
34 | // it is a file name |
35 | if (inFile == null) |
36 | inFile = new File(args[i]); |
37 | else if (outFile == null) |
38 | outFile = new File(args[i]); |
39 | else usage(); |
40 | } |
41 | } |
42 | if (decrypt) key = -key; |
43 | Encryptor crypt = new Encryptor(key); |
44 | crypt.encryptFile(inFile, outFile); |
45 | } |
46 | catch (NumberFormatException exception) |
47 | { |
48 | System.out.println("Key must be an integer: " + exception); |
49 | } |
50 | catch (IOException exception) |
51 | { |
52 | System.out.println("Error processing file: " + exception); |
53 | } |
54 | } |
55 | |
56 | /** |
57 | Prints a message describing proper usage and exits. |
58 | */ |
59 | public static void usage() |
60 | { |
61 | System.out.println |
62 | ("Usage: java Crypt [-d] [-kn] infile outfile"); |
63 | System.exit(1); |
64 | } |
65 | |
66 | public static final int DEFAULT_KEY = 3; |
67 | } |
Coin c = ...; ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("coins.dat")); out.writeObject(c);
ObjectInputStream in = new ObjectInputStream(new FilInputStream("coins.dat")); Coin c = (Coin)in.readObject();
ReadArrayList a = new ArrayList(); //add many objects to the array list out.writeObject(a);
ArrayList a = (ArrayList)in.readObject();
class Coin implements Serializable { ... }
1 | import java.io.File; |
2 | import java.io.IOException; |
3 | import java.io.FileInputStream; |
4 | import java.io.FileOutputStream; |
5 | import java.io.ObjectInputStream; |
6 | import java.io.ObjectOutputStream; |
7 | import javax.swing.JOptionPane; |
8 | |
9 | /** |
10 | This program tests serialization of a Purse object. |
11 | If a file with serialized purse data exists, then it is |
12 | loaded. Otherwise the program starts with a new purse. |
13 | More coins are added to the purse. Then the purse data |
14 | are saved. |
15 | */ |
16 | public class PurseTest |
17 | { |
18 | public static void main(String[] args) |
19 | throws IOException, ClassNotFoundException |
20 | { |
21 | Purse myPurse; |
22 | |
23 | File f = new File("purse.dat"); |
24 | if (f.exists()) |
25 | { |
26 | ObjectInputStream in = new ObjectInputStream |
27 | (new FileInputStream(f)); |
28 | myPurse = (Purse)in.readObject(); |
29 | in.close(); |
30 | } |
31 | else myPurse = new Purse(); |
32 | |
33 | // add coins to the purse |
34 | myPurse.add(new Coin(NICKEL_VALUE, "nickel")); |
35 | myPurse.add(new Coin(DIME_VALUE, "dime")); |
36 | myPurse.add(new Coin(QUARTER_VALUE, "quarter")); |
37 | |
38 | double totalValue = myPurse.getTotal(); |
39 | System.out.println("The total is " + totalValue); |
40 | |
41 | ObjectOutputStream out = new ObjectOutputStream |
42 | (new FileOutputStream(f)); |
43 | out.writeObject(myPurse); |
44 | out.close(); |
45 | } |
46 | |
47 | private static double NICKEL_VALUE = 0.05; |
48 | private static double DIME_VALUE = 0.1; |
49 | private static double QUARTER_VALUE = 0.25; |
50 | } |
In sequential file access, a file is processed a byte at a time.
Random access allows access at arbitrary locations in the file
RandomAccessFile f = new RandomAcessFile("bank.dat","rw");
f.seek(n);
long n = f.getFilePointer();
long fileLength = f.length();
1 | import java.io.IOException; |
2 | import java.io.RandomAccessFile; |
3 | import javax.swing.JOptionPane; |
4 | |
5 | /** |
6 | This program tests random access. You can access existing |
7 | accounts and add interest, or create a new accounts. The |
8 | accounts are saved in a random access file. |
9 | */ |
10 | public class BankDataTest |
11 | { |
12 | public static void main(String[] args) |
13 | throws IOException |
14 | { |
15 | BankData data = new BankData(); |
16 | try |
17 | { |
18 | data.open("bank.dat"); |
19 | |
20 | boolean done = false; |
21 | while (!done) |
22 | { |
23 | String input = JOptionPane.showInputDialog( |
24 | "Account number or " + data.size() |
25 | + " for new account"); |
26 | if (input == null) done = true; |
27 | else |
28 | { |
29 | int pos = Integer.parseInt(input); |
30 | |
31 | if (0 <= POs && POs < data.size()) // add interest |
32 | { |
33 | SavingsAccount account = data.read(POs); |
34 | System.out.println("balance=" |
35 | + account.getBalance() + ",interest rate=" |
36 | + account.getInterestRate()); |
37 | account.addInterest(); |
38 | data.write(POs, account); |
39 | } |
40 | else // add account |
41 | { |
42 | input = JOptionPane.showInputDialog("Balance"); |
43 | double balance = Double.parseDouble(input); |
44 | input = JOptionPane.showInputDialog("Interest Rate"); |
45 | double interestRate = Double.parseDouble(input); |
46 | SavingsAccount account |
47 | = new SavingsAccount(interestRate); |
48 | account.deposit(balance); |
49 | data.write(data.size(), account); |
50 | } |
51 | } |
52 | } |
53 | } |
54 | finally |
55 | { |
56 | data.close(); |
57 | System.exit(0); |
58 | } |
59 | } |
60 | } |
1 | import java.io.IOException; |
2 | import java.io.RandomAccessFile; |
3 | |
4 | /** |
5 | This class is a conduit to a random access file |
6 | containing savings account data. |
7 | */ |
8 | public class BankData |
9 | { |
10 | /** |
11 | Constructs a BankData object that is not associated |
12 | with a file. |
13 | */ |
14 | public BankData() |
15 | { |
16 | file = null; |
17 | } |
18 | |
19 | /** |
20 | Opens the data file. |
21 | @param filename the name of the file containing savings |
22 | account information. |
23 | */ |
24 | public void open(String filename) |
25 | throws IOException |
26 | { |
27 | if (file != null) file.close(); |
28 | file = new RandomAccessFile(filename, "rw");; |
29 | } |
30 | |
31 | /** |
32 | Gets the number of accounts in the file. |
33 | @return the number of accounts. |
34 | */ |
35 | public int size() |
36 | throws IOException |
37 | { |
38 | return (int)(file.length() / RECORD_SIZE); |
39 | } |
40 | |
41 | /** |
42 | Closes the data file. |
43 | */ |
44 | public void close() |
45 | throws IOException |
46 | { |
47 | if (file != null) file.close(); |
48 | file = null; |
49 | } |
50 | |
51 | /** |
52 | Reads a savings account record. |
53 | @param n the index of the account in the data file |
54 | @return a savings account object initialized with the file data |
55 | */ |
56 | public SavingsAccount read(int n) |
57 | throws IOException |
58 | { |
59 | file.seek(n * RECORD_SIZE); |
60 | double balance = file.readDouble(); |
61 | double interestRate = file.readDouble(); |
62 | SavingsAccount account = new SavingsAccount(interestRate); |
63 | account.deposit(balance); |
64 | return account; |
65 | } |
66 | |
67 | /** |
68 | Writes a savings account record to the data file |
69 | @param n the index of the account in the data file |
70 | @param account the account to write |
71 | */ |
72 | public void write(int n, SavingsAccount account) |
73 | throws IOException |
74 | { |
75 | file.seek(n * RECORD_SIZE); |
76 | file.writeDouble(account.getBalance()); |
77 | file.writeDouble(account.getInterestRate()); |
78 | } |
79 | |
80 | private RandomAccessFile file; |
81 | |
82 | public static final int DOUBLE_SIZE = 8; |
83 | public static final int RECORD_SIZE |
84 | = 2 * DOUBLE_SIZE; |
85 | } |