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();
        }
    }
}

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

字节流例子

 //字节输入流
 //读取内容并输出读取多少字节
 package com.zijie;

 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;

 public class TestFileInputStream
 {
     public static void main(String[] args) {
         int b = 0;

         FileInputStream in = null;
         try{
             in = new FileInputStream("E:\\Java\\0801 流后传 线程\\线程.txt");
         } catch(FileNotFoundException e) {
             System.out.println("找不到指定的文件");
             System.exit(-1);
         }

         try{
             long num = 0;
             // 返回-1的话就表示已经读到了文件的结尾
             while((b = in.read()) != -1) {
                 System.out.print((char)b);
                 num++;
             }
             in.close();
             System.out.println("\n\n共读取了" + num + "个字节");
         } catch(IOException e1) {
             System.out.println("读取文件时出现异常");
             System.exit(-1);
         }
     }
 }

 //字节输出流
 //复制文件
 package com.zijie;

 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;

 public class TestFileOutputStream {
     public static void main(String[] args) {
         int b = 0;
         FileInputStream in = null;
         FileOutputStream out = null;
         try {
             in = new FileInputStream("E:\\Java\\0801 流后传 线程\\线程.txt");
             // OutputStream有这个文件就往这个文件里面写, 没有的话就自动创建一个
             out = new FileOutputStream("E:\\Java\\0801 流后传 线程\\线程-ceshi.txt");
             // 一边读, 一边写
             while ((b = in.read()) != -1) {
                 out.write(b);
             }
         } catch (FileNotFoundException e) {
             System.out.println("找不到指定文件");
             System.exit(-1);
         } catch (IOException e) {
             System.out.println("文件复制出错");
             System.exit(-1);
         }
         System.out.println("文件成功复制");
     }
 }

字符流例子

 //字符输入流
 //读取文件内容
 package com.zifu;

 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;

 public class TestFileReader {
     public static void main(String[] args) {
         FileReader fr = null;
         int c = 0;
         try {
             fr = new FileReader("E:\\Java\\0801 流后传 线程\\线程.txt");
             while ((c = fr.read()) != -1) {
                 System.out.print((char) c);
             }
             fr.close();
         } catch (FileNotFoundException e) {
             System.out.println("文件未找到");
             System.exit(-1);
         } catch (IOException e) {
             System.out.println("读取文件时出现异常");
             System.exit(-1);
         }
     }
 }

 //字符输入流
 //不断写入int型，写入为ASCII表
 package com.zifu;

 import java.io.FileWriter;
 import java.io.IOException;

 public class TestFileWriter {
     public static void main(String[] args) {
         FileWriter fw = null;
         try {
             fw = new FileWriter("E:\\Java\\0801 流后传 线程\\线程-ceshi1.txt");
             for (int i = 1; i <= 50000; i++) {
                     fw.write(i);
             }
         } catch (IOException e) {
             System.out.println("写入文件出错 !");
             System.exit(-1);
         }
     }
 }

缓冲流

 package com.buffer;

 import java.io.BufferedInputStream;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;

 public class TestBufferStream {
     public static void main(String[] args) {

         byte[] bb = new byte[50];
         try {
             FileInputStream fis = new FileInputStream("E:\\Java\\0801 流后传 线程\\ceshi.txt");
             BufferedInputStream bis = new BufferedInputStream(fis);//将文件字节流，转换成带缓冲的输入字节流
             int c = 0;
             System.out.println((char)bis.read());
             System.out.println((char)bis.read());
 /*            while((c = bis.read()) != -1) {
                 System.out.print((char)c+", ");
             }*/
             // 标记到第30的位置再开始读数据
             bis.mark(100);//见的总承包 mark的方法 InputStream

             for (int i = 0; i <= 10 && (c = bis.read()) != -1; i++) {
                 System.out.print((char)c);
             }
             System.out.println();
             // 回到mark标记的那个地方
             bis.reset();//见的总承包reset的方法InputStream 。
             for (int i = 0; i <= 10 && (c = bis.read()) != -1; i++) {
                 System.out.print((char)c);
             }
             bis.close();
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }

     }
 }

 package com.buffer;

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;

 public class TestBufferRW {
     public static void main(String[] args) {

         try {
             BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\Java\\0801 流后传 线程\\ceshi.txt"));
             BufferedReader br = new BufferedReader(new FileReader("E:\\Java\\0801 流后传 线程\\ceshi.txt"));

             String s = null;

             for (int i = 0; i < 100; i++) {
                 s = "" + Math.random();
                 //bw.write(s);
                 bw.append(s);//写入文件
                 bw.newLine();
             }

             bw.flush();
             // 特别好用的方法, readLine
             while((s = br.readLine()) != null) {//获取文件内容输出到控制台
                 System.out.println(s);
             }
             br.close();
             bw.close();
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }

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

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

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

 package com.convert;

 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.OutputStreamWriter;
 import java.io.UnsupportedEncodingException;

 public class TestTranForm1 {
     public static void main(String[] args) {
         OutputStreamWriter osw = null;
         try {

             osw = new OutputStreamWriter(new FileOutputStream("E:\\Java\\0801 流后传 线程\\ceshi.txt"));
             osw.write("山东淄博");//写入文件
             // 默认使用当前系统的字符编码
             System.out.println(osw.getEncoding());
             osw.close();

             // FileOutputStream加第二个参数true表示追加内容
             osw = new OutputStreamWriter(new FileOutputStream("E:\\Java\\0801 流后传 线程\\ceshi.txt", true), "utf-8");//更改字符编码
             osw.write("qwerttttt");
             System.out.println(osw.getEncoding());
             osw.close();

         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (UnsupportedEncodingException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }

     }
 }

阻塞式方法

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

 package com.convert;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;

 public class TestTranForm2 {
     public static void main(String[] args) {
         try {
             InputStreamReader isr = new InputStreamReader(System.in);//包一层字符流
             BufferedReader br = new BufferedReader(isr);//在包一层缓冲字符流
             String s = null;

             s = br.readLine();//从字符流读取一行，你写入的内容

             while(s != null) {
                 if(s.equalsIgnoreCase("exit")) {//忽略大小写的相同
                     break;
                 }
                 System.out.println(s.toUpperCase());//将字符串转换成大写在控制台输出
                 s = br.readLine();//再次获取输入的内容
             }

             br.close();

             // 阻塞式方法(同步方法---不输入就不能干别的)
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }

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

 package com.data;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;

 public class TestDataStream {
     public static void main(String[] args) {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();//字节数组输出流
         DataOutputStream dos = new DataOutputStream(baos);//数据处理流，这个流可以直接写入基础数据类型
         try {
             dos.writeDouble(Math.random());
             dos.writeBoolean(true);
             ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());//将输出流转换为字节数组
             System.out.println(bais.available());//里面包含的所有数据的长度
             DataInputStream dis = new DataInputStream(bais);
             /*
              * 先进先出---队列
              * 先进后出---栈
              */
             System.out.println(dis.readDouble());//数据流可以直接读取基本数据类型
             System.out.println(dis.readBoolean());
             dos.close();
             dis.close();
         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }
 }

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

 package com.print;

 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.PrintStream;

 public class TestPrintStream1 {
     public static void main(String[] args) {
         PrintStream ps = null;//打印流

         try {
             FileOutputStream fos = new FileOutputStream("e:\\go\\testprint.txt");//文件字节输出流
             ps = new PrintStream(fos);
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         }

         if(ps != null) {
             // 设置默认的输出对象
             System.setOut(ps);
         }

         for(char c = 0;c<=60000;c++) {//输出6万个字符
             System.out.print(c);
             if(c % 100 == 0) {//输出到文件，不是控制台
                 System.out.println();
             }
         }
     }
 }

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

 package com.print;

 import java.io.BufferedReader;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 import java.io.PrintStream;

 public class TestPrintStream2 {
     public static void main(String[] args) {
         String fileName = "e:\\go\\file.txt";

         list(fileName, System.out);
     }

     private static void list(String fileName, PrintStream ps) {
         try {
             BufferedReader br = new BufferedReader(new FileReader(fileName));//读取文件
             String s = null;

             while((s = br.readLine()) != null) {
                 ps.println(s);//读取并打印
             }
             br.close();
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             ps.println("无法读取文件 !");
             e.printStackTrace();
         }
     }
 }

模拟日志效果

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

 package com.print;

 import java.io.BufferedReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.PrintWriter;
 import java.util.Date;

 public class TestPrintStream3 {

     public static void main(String[] args) {
         String s = null;
         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));//字节流转换字符流

         PrintWriter pwLog;
         try {
             FileWriter fw = new FileWriter("e:\\Java\\Ceshi-stream.log", true);//输出流的位置追加内容
             pwLog = new PrintWriter(fw);
             while((s = br.readLine()) != null) {//获取输入
                 if(s.equalsIgnoreCase("exit")) {
                     break;
                 }
                 System.out.println(s.toUpperCase());//打印到控制台大写
                 pwLog.println("---------------------");//打印到文件分割线
                 pwLog.println(s.toUpperCase());//打印到文件大写
                 pwLog.flush();
             }
             pwLog.println("========== " + new Date() + " ===================");//结束后打印当前日期
             pwLog.flush();
             pwLog.close();
         } catch (IOException e) {
             e.printStackTrace();
         }

     }

 }

Object流

 package com.object;

 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.Serializable;

 public class TestObjectStream {
     public static void main(String[] args) {
         try {
             Test t = new Test();//实例化，自定义的类
             t.i += 5;
             FileOutputStream fos = new FileOutputStream("E:\\Java\\0801 流后传 线程\\ceshi.txt");//定义输出位置
             ObjectOutputStream oos = new ObjectOutputStream(fos);//对象处理流包起来
             oos.writeObject(t);//将对象写入到文件
             oos.flush();
             oos.close();

             FileInputStream fis = new FileInputStream("E:\\Java\\0801 流后传 线程\\ceshi.txt");//将文件读出来
             ObjectInputStream ois = new ObjectInputStream(fis);
             Test tread = (Test)ois.readObject();
             System.out.println(tread);
             ois.close();
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (ClassNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }

 // Serializable--标记型接口, 没有实际的方法, 知识用来表示这个类可以被序列化
 class Test implements Serializable {

     private static final long serialVersionUID = 1L;

     String name = "hanqi";
     int i = 3;
     int j = 15;
     transient double d = 12.345; // 透明的, 表示这个属性在写入流的时候不予考虑

     @Override
     public String toString() {
         return "Test [name=" + name + ", i=" + i + ", j=" + j + ", d=" + d + "]";
     }
 }