Java之IO流补充

IO流例子

package com.hanqi.maya.util;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;

public class Test3 {
    public static void main(String[] args) {
        File file=new File("E:\\ceshi.txt");
        File ofile=new File("E:\\cewshi8.txt");
        
        Reader r=null;
        
        try {
            r=new FileReader(file);
            Writer w=new FileWriter(ofile,true);//true表示追加,不加则原本表示替换
            BufferedReader br=new BufferedReader(r);
            BufferedWriter bw=new BufferedWriter(w);
            String s=null;
            while((s=br.readLine())!=null){
                System.out.print(s);
                bw.write(s);
                bw.flush();//一个好的编程习惯应该在此处使用flush,写入需要用 flush 刷新流,否则会在缓冲区不写入文件
            }
            br.close();
            bw.close();//调用该方法前会自动调用 flush 
        } catch (FileNotFoundException e) {
            
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文件流(字节流, 字符流)

字节流例子

 1 //字节输入流
 2 //读取内容并输出读取多少字节
 3 package com.zijie;
 4 
 5 import java.io.FileInputStream;
 6 import java.io.FileNotFoundException;
 7 import java.io.IOException;
 8 
 9 public class TestFileInputStream
10 {
11     public static void main(String[] args) {
12         int b = 0;
13 
14         FileInputStream in = null;
15         try{
16             in = new FileInputStream("E:\\Java\\0801 流后传 线程\\线程.txt");
17         } catch(FileNotFoundException e) {
18             System.out.println("找不到指定的文件");
19             System.exit(-1);
20         }
21 
22         try{
23             long num = 0;
24             // 返回-1的话就表示已经读到了文件的结尾
25             while((b = in.read()) != -1) {
26                 System.out.print((char)b);
27                 num++;
28             }
29             in.close();
30             System.out.println("\n\n共读取了" + num + "个字节");
31         } catch(IOException e1) {
32             System.out.println("读取文件时出现异常");
33             System.exit(-1);
34         }
35     }
36 }
 1 //字节输出流
 2 //复制文件
 3 package com.zijie;
 4 
 5 import java.io.FileInputStream;
 6 import java.io.FileNotFoundException;
 7 import java.io.FileOutputStream;
 8 import java.io.IOException;
 9 
10 public class TestFileOutputStream {
11     public static void main(String[] args) {
12         int b = 0;
13         FileInputStream in = null;
14         FileOutputStream out = null;
15         try {
16             in = new FileInputStream("E:\\Java\\0801 流后传 线程\\线程.txt");
17             // OutputStream有这个文件就往这个文件里面写, 没有的话就自动创建一个
18             out = new FileOutputStream("E:\\Java\\0801 流后传 线程\\线程-ceshi.txt");
19             // 一边读, 一边写
20             while ((b = in.read()) != -1) {
21                 out.write(b);
22             }
23         } catch (FileNotFoundException e) {
24             System.out.println("找不到指定文件");
25             System.exit(-1);
26         } catch (IOException e) {
27             System.out.println("文件复制出错");
28             System.exit(-1);
29         }
30         System.out.println("文件成功复制");
31     }
32 }

字符流例子

 1 //字符输入流
 2 //读取文件内容
 3 package com.zifu;
 4 
 5 import java.io.FileNotFoundException;
 6 import java.io.FileReader;
 7 import java.io.IOException;
 8 
 9 public class TestFileReader {
10     public static void main(String[] args) {
11         FileReader fr = null;
12         int c = 0;
13         try {
14             fr = new FileReader("E:\\Java\\0801 流后传 线程\\线程.txt");
15             while ((c = fr.read()) != -1) {
16                 System.out.print((char) c);
17             }
18             fr.close();
19         } catch (FileNotFoundException e) {
20             System.out.println("文件未找到");
21             System.exit(-1);
22         } catch (IOException e) {
23             System.out.println("读取文件时出现异常");
24             System.exit(-1);
25         }
26     }
27 }
 1 //字符输入流
 2 //不断写入int型,写入为ASCII表
 3 package com.zifu;
 4 
 5 import java.io.FileWriter;
 6 import java.io.IOException;
 7 
 8 public class TestFileWriter {
 9     public static void main(String[] args) {
10         FileWriter fw = null;
11         try {
12             fw = new FileWriter("E:\\Java\\0801 流后传 线程\\线程-ceshi1.txt");
13             for (int i = 1; i <= 50000; i++) {
14                     fw.write(i);
15             }
16         } catch (IOException e) {
17             System.out.println("写入文件出错 !");
18             System.exit(-1);
19         }
20     }
21 }

缓冲流

 1 package com.buffer;
 2 
 3 import java.io.BufferedInputStream;
 4 import java.io.FileInputStream;
 5 import java.io.FileNotFoundException;
 6 import java.io.IOException;
 7 
 8 public class TestBufferStream {
 9     public static void main(String[] args) {
10 
11         byte[] bb = new byte[50];
12         try {
13             FileInputStream fis = new FileInputStream("E:\\Java\\0801 流后传 线程\\ceshi.txt");
14             BufferedInputStream bis = new BufferedInputStream(fis);//将文件字节流,转换成带缓冲的输入字节流
15             int c = 0;
16             System.out.println((char)bis.read());
17             System.out.println((char)bis.read());
18 /*            while((c = bis.read()) != -1) {
19                 System.out.print((char)c+", ");
20             }*/
21             // 标记到第30的位置再开始读数据
22             bis.mark(100);//见的总承包 mark的方法 InputStream
23             
24             for (int i = 0; i <= 10 && (c = bis.read()) != -1; i++) {
25                 System.out.print((char)c);
26             }
27             System.out.println();
28             // 回到mark标记的那个地方
29             bis.reset();//见的总承包reset的方法InputStream 。 
30             for (int i = 0; i <= 10 && (c = bis.read()) != -1; i++) {
31                 System.out.print((char)c);
32             }
33             bis.close();
34         } catch (FileNotFoundException e) {
35             e.printStackTrace();
36         } catch (IOException e) {
37             e.printStackTrace();
38         }
39         
40     }
41 }
 1 package com.buffer;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.FileNotFoundException;
 6 import java.io.FileReader;
 7 import java.io.FileWriter;
 8 import java.io.IOException;
 9 
10 public class TestBufferRW {
11     public static void main(String[] args) {
12         
13         try {
14             BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\Java\\0801 流后传 线程\\ceshi.txt"));
15             BufferedReader br = new BufferedReader(new FileReader("E:\\Java\\0801 流后传 线程\\ceshi.txt"));
16             
17             String s = null;
18             
19             for (int i = 0; i < 100; i++) {
20                 s = "" + Math.random();
21                 //bw.write(s);
22                 bw.append(s);//写入文件
23                 bw.newLine();
24             }
25             
26             bw.flush();
27             // 特别好用的方法, readLine
28             while((s = br.readLine()) != null) {//获取文件内容输出到控制台
29                 System.out.println(s);
30             }
31             br.close();
32             bw.close();
33         } catch (FileNotFoundException e) {
34             e.printStackTrace();
35         } catch (IOException e) {
36             e.printStackTrace();
37         }
38     }
39 }

转换流  convert--->字节-字符

打印当前系统的字符编码:

System.out.println(osw.getEncoding());

 1 package com.convert;
 2 
 3 import java.io.FileNotFoundException;
 4 import java.io.FileOutputStream;
 5 import java.io.IOException;
 6 import java.io.OutputStreamWriter;
 7 import java.io.UnsupportedEncodingException;
 8 
 9 public class TestTranForm1 {
10     public static void main(String[] args) {
11         OutputStreamWriter osw = null;
12         try {
13             
14             osw = new OutputStreamWriter(new FileOutputStream("E:\\Java\\0801 流后传 线程\\ceshi.txt"));
15             osw.write("山东淄博");//写入文件
16             // 默认使用当前系统的字符编码
17             System.out.println(osw.getEncoding());
18             osw.close();
19             
20             // FileOutputStream加第二个参数true表示追加内容
21             osw = new OutputStreamWriter(new FileOutputStream("E:\\Java\\0801 流后传 线程\\ceshi.txt", true), "utf-8");//更改字符编码
22             osw.write("qwerttttt");
23             System.out.println(osw.getEncoding());
24             osw.close();
25             
26         } catch (FileNotFoundException e) {
27             e.printStackTrace();
28         } catch (UnsupportedEncodingException e) { 
29             e.printStackTrace();
30         } catch (IOException e) {
31             e.printStackTrace();
32         }
33         
34     }
35 }

阻塞式方法

获取输入的内容转换成大写,如果输入的 exit 退出

 1 package com.convert;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 
 7 public class TestTranForm2 {
 8     public static void main(String[] args) {
 9         try {
10             InputStreamReader isr = new InputStreamReader(System.in);//包一层字符流
11             BufferedReader br = new BufferedReader(isr);//在包一层缓冲字符流
12             String s = null;
13             
14             s = br.readLine();//从字符流读取一行,你写入的内容
15             
16             while(s != null) {
17                 if(s.equalsIgnoreCase("exit")) {//忽略大小写的相同
18                     break;
19                 }
20                 System.out.println(s.toUpperCase());//将字符串转换成大写在控制台输出
21                 s = br.readLine();//再次获取输入的内容
22             }
23             
24             br.close();
25             
26             // 阻塞式方法(同步方法---不输入就不能干别的)
27         } catch (IOException e) {
28             e.printStackTrace();
29         }
30     }
31 }

数据流--->八大数据类型

 1 package com.data;
 2 
 3 import java.io.ByteArrayInputStream;
 4 import java.io.ByteArrayOutputStream;
 5 import java.io.DataInputStream;
 6 import java.io.DataOutputStream;
 7 import java.io.IOException;
 8 
 9 public class TestDataStream {
10     public static void main(String[] args) {
11         ByteArrayOutputStream baos = new ByteArrayOutputStream();//字节数组输出流
12         DataOutputStream dos = new DataOutputStream(baos);//数据处理流,这个流可以直接写入基础数据类型
13         try {
14             dos.writeDouble(Math.random());
15             dos.writeBoolean(true);
16             ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());//将输出流转换为字节数组
17             System.out.println(bais.available());//里面包含的所有数据的长度
18             DataInputStream dis = new DataInputStream(bais);
19             /*
20              * 先进先出---队列
21              * 先进后出---栈
22              */
23             System.out.println(dis.readDouble());//数据流可以直接读取基本数据类型
24             System.out.println(dis.readBoolean());
25             dos.close();
26             dis.close();
27         } catch (IOException e) {
28             // TODO Auto-generated catch block
29             e.printStackTrace();
30         }
31     }
32 }

print流  打印流--->System.out.println();

 1 package com.print;
 2 
 3 import java.io.FileNotFoundException;
 4 import java.io.FileOutputStream;
 5 import java.io.PrintStream;
 6 
 7 public class TestPrintStream1 {
 8     public static void main(String[] args) {
 9         PrintStream ps = null;//打印流
10         
11         try {
12             FileOutputStream fos = new FileOutputStream("e:\\go\\testprint.txt");//文件字节输出流
13             ps = new PrintStream(fos);
14         } catch (FileNotFoundException e) {
15             e.printStackTrace();
16         }
17         
18         if(ps != null) {
19             // 设置默认的输出对象
20             System.setOut(ps);
21         }
22         
23         for(char c = 0;c<=60000;c++) {//输出6万个字符
24             System.out.print(c);
25             if(c % 100 == 0) {//输出到文件,不是控制台
26                 System.out.println();
27             }
28         }
29     }
30 }

定义方法,读取并打印文件

 1 package com.print;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.FileNotFoundException;
 5 import java.io.FileReader;
 6 import java.io.IOException;
 7 import java.io.PrintStream;
 8 
 9 public class TestPrintStream2 {
10     public static void main(String[] args) {
11         String fileName = "e:\\go\\file.txt";
12         
13         list(fileName, System.out);
14     }
15 
16     private static void list(String fileName, PrintStream ps) {
17         try {
18             BufferedReader br = new BufferedReader(new FileReader(fileName));//读取文件
19             String s = null;
20             
21             while((s = br.readLine()) != null) {
22                 ps.println(s);//读取并打印
23             }
24             br.close();
25         } catch (FileNotFoundException e) {
26             e.printStackTrace();
27         } catch (IOException e) {
28             ps.println("无法读取文件 !");
29             e.printStackTrace();
30         }
31     }
32 }

模拟日志效果

输入内容,打印,并用分割线分开,最后打印当前日期

 1 package com.print;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.FileWriter;
 5 import java.io.IOException;
 6 import java.io.InputStreamReader;
 7 import java.io.PrintWriter;
 8 import java.util.Date;
 9 
10 public class TestPrintStream3 {
11 
12     public static void main(String[] args) {
13         String s = null;
14         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));//字节流转换字符流
15         
16         PrintWriter pwLog;
17         try {
18             FileWriter fw = new FileWriter("e:\\Java\\Ceshi-stream.log", true);//输出流的位置追加内容
19             pwLog = new PrintWriter(fw);
20             while((s = br.readLine()) != null) {//获取输入
21                 if(s.equalsIgnoreCase("exit")) {
22                     break;
23                 }
24                 System.out.println(s.toUpperCase());//打印到控制台大写
25                 pwLog.println("---------------------");//打印到文件分割线
26                 pwLog.println(s.toUpperCase());//打印到文件大写
27                 pwLog.flush();
28             }
29             pwLog.println("========== " + new Date() + " ===================");//结束后打印当前日期
30             pwLog.flush();
31             pwLog.close();
32         } catch (IOException e) {
33             e.printStackTrace();
34         }
35         
36         
37     }
38 
39 }

Object流

 1 package com.object;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.FileNotFoundException;
 5 import java.io.FileOutputStream;
 6 import java.io.IOException;
 7 import java.io.ObjectInputStream;
 8 import java.io.ObjectOutputStream;
 9 import java.io.Serializable;
10 
11 public class TestObjectStream {
12     public static void main(String[] args) {
13         try {
14             Test t = new Test();//实例化,自定义的类
15             t.i += 5;
16             FileOutputStream fos = new FileOutputStream("E:\\Java\\0801 流后传 线程\\ceshi.txt");//定义输出位置
17             ObjectOutputStream oos = new ObjectOutputStream(fos);//对象处理流包起来
18             oos.writeObject(t);//将对象写入到文件
19             oos.flush();
20             oos.close();
21             
22             FileInputStream fis = new FileInputStream("E:\\Java\\0801 流后传 线程\\ceshi.txt");//将文件读出来
23             ObjectInputStream ois = new ObjectInputStream(fis);
24             Test tread = (Test)ois.readObject();
25             System.out.println(tread);
26             ois.close();
27         } catch (FileNotFoundException e) {
28             e.printStackTrace();
29         } catch (ClassNotFoundException e) {
30             e.printStackTrace();
31         } catch (IOException e) {
32             e.printStackTrace();
33         }
34     }
35 }
36 
37 // Serializable--标记型接口, 没有实际的方法, 知识用来表示这个类可以被序列化
38 class Test implements Serializable {
39     
40     private static final long serialVersionUID = 1L;
41     
42     String name = "hanqi";
43     int i = 3;
44     int j = 15;
45     transient double d = 12.345; // 透明的, 表示这个属性在写入流的时候不予考虑
46         
47     
48     @Override
49     public String toString() {
50         return "Test [name=" + name + ", i=" + i + ", j=" + j + ", d=" + d + "]";
51     }
52 }

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

扫码关注云+社区

领取腾讯云代金券