1 import java.io.FileReader;
 2 import java.io.FileWriter;
 3 import java.io.IOException;
 4 
 5 public class CopyFile {
 6     public static void main(String[] args) throws IOException {
 7         //创建输入流对象
 8         FileReader fr=new FileReader("C:\\Test\\copyfrom.txt");//文件不存在会抛出java.io.FileNotFoundException
 9         //创建输出流对象
10         FileWriter fw=new FileWriter("C:\\Test\\copyto.txt");
11         /*创建输出流做的工作：
12          *         1、调用系统资源创建了一个文件
13          *         2、创建输出流对象
14          *         3、把输出流对象指向文件        
15          * */
16         //文本文件复制，一次读一个字符
17         method1(fr, fw);
18         //文本文件复制，一次读一个字符数组
19         method2(fr, fw);
20         
21         fr.close();
22         fw.close();
23     }
24 
25     public static void method1(FileReader fr, FileWriter fw) throws IOException {
26         int ch;
27         while((ch=fr.read())!=-1) {//读数据
28             fw.write(ch);//写数据
29         }
30         fw.flush();
31     }
32 
33     public static void method2(FileReader fr, FileWriter fw) throws IOException {
34         char chs[]=new char[1024];
35         int len=0;
36         while((len=fr.read(chs))!=-1) {//读数据
37             fw.write(chs,0,len);//写数据
38         }
39         fw.flush();
40     }
41 }

 1 import java.io.BufferedReader;
 2 import java.io.BufferedWriter;
 3 import java.io.FileReader;
 4 import java.io.FileWriter;
 5 import java.io.IOException;
 6 
 7 public class CopyFile2 {
 8     public static void main(String[] args) throws IOException {
 9         //创建输入流对象
10         BufferedReader br=new BufferedReader(new FileReader("C:\\Test\\copyfrom.txt"));//文件不存在会抛出java.io.FileNotFoundException
11         //创建输出流对象
12         BufferedWriter bw=new BufferedWriter(new FileWriter("C:\\Test\\copyto.txt"));
13         //文本文件复制
14         char [] chs=new char[1024];
15         int len=0;
16         while((len=br.read(chs))!=-1) {
17             bw.write(chs, 0, len);
18         }
19         //释放资源
20         br.close();
21         bw.close();
22     }
23 }

 1 import java.io.BufferedReader;
 2 import java.io.FileWriter;
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5 import java.io.InputStreamReader;
 6 import java.io.Reader;
 7 
 8 /**
 9  * 使用标准输入流，读取键盘录入的数据，存储到项目根目录下的a.txt中
10  * 将字节输入流转换成字符输入流，InputStreamReader
11  */
12 public class InputStreamReaderDemo {
13     public static void main(String[] args) throws IOException {
14         //创建输入流对象
15         BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
16         //创建输出流对象
17         FileWriter fw=new FileWriter("a.txt");
18         //读写数据
19         char[] chs=new char[1024];
20         int len;
21         while((len=r.read(chs))!=-1) {
22             fw.write(chs,0,len);
23             fw.flush();
24         }
25         //释放资源
26         r.close();
27         fw.close();
28 
29     }
30 
31     public static void method2() throws IOException {
32         //创建输入流对象
33         InputStream is=System.in;
34         Reader r=new InputStreamReader(is);
35         //创建输出流对象
36         FileWriter fw=new FileWriter("a.txt");
37 
38         //读写数据
39         char[] chs=new char[1024];
40         int len;
41         while((len=r.read(chs))!=-1) {
42             fw.write(chs,0,len);
43             fw.flush();
44         }
45         //释放资源
46         is.close();
47         fw.close();
48     }
49 
50     public static void method1() throws IOException {
51         //创建输入流对象
52         InputStream is=System.in;
53         //创建输出流对象
54         FileWriter fw=new FileWriter("a.txt");
55         
56         //读写数据
57         byte[] bys=new byte[1024];
58         int len;
59         while((len=is.read(bys))!=-1) {
60             fw.write(new String(bys,0,len));
61             fw.flush();
62         }
63         //释放资源
64         is.close();
65         fw.close();
66     }    
67 }

 1 import java.io.BufferedReader;
 2 import java.io.BufferedWriter;
 3 import java.io.FileNotFoundException;
 4 import java.io.FileReader;
 5 import java.io.IOException;
 6 import java.io.OutputStream;
 7 import java.io.OutputStreamWriter;
 8 import java.io.Writer;
 9 
10 /**
11  * 读取项目目录下的文件copy.java,并输出到命令行
12  * 由于标准输出流是字节输出流，所以只能输出字节或者字节数组，但是我们读取到的数据是字符串，如果想进行输出，
13  * 还需要转换成字节数组(method1)。
14  * 要想通过标准输出流输出字符串，把标准输出流转换成一种字符输出流即可(method2)。
15  */
16 public class OutputStreamWriterDemo {
17     public static void main(String[] args) throws IOException {
18         //创建输入流
19         BufferedReader br=new BufferedReader(new FileReader("copy.java"));
20         //创建输出流
21         BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
22         String line;//用于接收读到的数据
23         while((line=br.readLine())!=null) {
24             bw.write(line);
25             bw.write("\r\n");
26         }
27         br.close();
28         bw.close();
29     }
30 
31     public static void method2() throws FileNotFoundException, IOException {
32         //创建输入流
33         BufferedReader br=new BufferedReader(new FileReader("copy.java"));
34         //创建输出流
35         //OutputStream os=System.out;
36         Writer w=new OutputStreamWriter(System.out);//多态，父类引用指向子类对象
37         String line;//用于接收读到的数据
38         while((line=br.readLine())!=null) {
39             w.write(line);
40             w.write("\r\n");
41         }
42         br.close();
43         w.close();
44     }
45 
46     public static void method1() throws FileNotFoundException, IOException {
47         //创建输入流
48         BufferedReader br=new BufferedReader(new FileReader("copy.java"));
49         //创建输出流
50         OutputStream os=System.out;
51         String line;//用于接收读到的数据
52         while((line=br.readLine())!=null) {
53             os.write(line.getBytes());
54             os.write("\r\n".getBytes());
55         }
56         br.close();
57         os.close();
58     }
59 }

 1 import java.io.BufferedReader;
 2 import java.io.FileReader;
 3 import java.io.FileWriter;
 4 import java.io.IOException;
 5 import java.io.PrintWriter;
 6 /**
 7  * 使用打印流复制文本文件
 8  */
 9 public class PrintWriterDemo {
10     public static void main(String[] args) throws IOException {
11         BufferedReader br=new BufferedReader(new FileReader("copy.java"));
12         PrintWriter pw=new PrintWriter("printcopy.java");
13         String line;
14         while((line=br.readLine())!=null) {
15             pw.println(line);
16         }
17         br.close();
18         pw.close();
19     }
20 }

 1 import java.io.BufferedReader;
 2 import java.io.FileReader;
 3 import java.io.IOException;
 4 import java.io.PrintStream;
 5 
 6 public class PrintStreamDemo {
 7     public static void main(String[] args) throws IOException {
 8         BufferedReader br=new BufferedReader(new FileReader("copy.java"));
 9         PrintStream ps=new PrintStream("printcopy2.java");
10         String line;
11         while((line=br.readLine())!=null) {
12             ps.println(line);
13         }
14         br.close();
15         ps.close();
16     }
17 }

 1 import java.io.Serializable;
 2 //学生类
 3 public class Student implements Serializable{
 4     private static final long serialVersionUID = -8942780382144699003L;
 5     String name;
 6     int age;
 7     public Student(String name,int age){
 8         this.name=name;
 9         this.age=age;
10     }
11     @Override
12     public String toString() {
13         return "Student [name=" + name + ", age=" + age + "]";
14     }    
15 }

 1 import java.io.EOFException;
 2 import java.io.FileInputStream;
 3 import java.io.FileNotFoundException;
 4 import java.io.FileOutputStream;
 5 import java.io.IOException;
 6 import java.io.ObjectInputStream;
 7 import java.io.ObjectOutputStream;
 8 
 9 /**
10  * 使用对象输出流写对象和对象输入流读对象
11  *注意：如果Student没有序列化，会抛出java.io.NotSerializableException
12  *Serializable：序列号，是一个标识接口，只起标识作用，没有方法
13  *当一个类的对象需要IO流进行读写的时候，这个类必须实现接口
14  */
15 public class ObjectOperate {
16     public static void main(String[] args) throws IOException, ClassNotFoundException {
17         writeObject();
18         //创建对象输入流的对象
19         ObjectInputStream ois=new ObjectInputStream(new FileInputStream("a.txt"));
20         //读取对象
21         try {
22             while(true){
23                 Object obj=ois.readObject();
24                 System.out.println(obj);
25             }
26         }catch(EOFException e){
27             System.out.println("读到了文件末尾");
28         }
29         
30         //释放资源
31         ois.close();
32         
33     }
34 
35     public static void writeObject() throws FileNotFoundException, IOException {
36         //创建对象输出流的对象
37         FileOutputStream fos=new FileOutputStream("a.txt");
38         ObjectOutputStream oos=new ObjectOutputStream(fos);
39         //创建学生对象
40         Student s1=new Student("张三",20);
41         Student s2=new Student("李四",30);
42         Student s3=new Student("王五",10);    
43         //写出学生对象
44         oos.writeObject(s1);
45         oos.writeObject(s2);
46         oos.writeObject(s3);
47         //释放资源
48     }
49 }

 1 import java.io.FileInputStream;
 2 import java.io.FileNotFoundException;
 3 import java.io.FileOutputStream;
 4 import java.io.IOException;
 5 import java.io.ObjectInputStream;
 6 import java.io.ObjectOutputStream;
 7 import java.util.ArrayList;
 8 /**
 9  * 使用对象输出流写对象和对象输入流读对象
10  *解决读取对象出现异常的问题,使用集合类
11  */
12 public class ObjectOperate2 {
13     public static void main(String[] args) throws IOException, ClassNotFoundException {
14         listMethod();
15         //创建对象输入流对象
16         ObjectInputStream ois=new ObjectInputStream(new FileInputStream("b.txt"));
17         //读取数据
18         Object obj=ois.readObject();
19         //System.out.println(obj);
20         //向下转型
21         ArrayList<Student> list=(ArrayList<Student>) obj;
22         for(Student s:list) {
23             System.out.println(s);
24         }
25         //释放资源
26         ois.close();
27     }
28 
29     public static void listMethod() throws IOException, FileNotFoundException {
30         //创建对象输出流的对象
31         ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("b.txt"));
32         //创建集合类
33         ArrayList<Student> list=new ArrayList<Student>();
34         //添加学生对象
35         list.add(new Student("zhangsan",20));
36         list.add(new Student("lisi",30));
37         //写出集合对象
38         oos.writeObject(list);
39         //释放资源
40         oos.close();
41     }
42 
43 }