javase_14(字节流)

 

字节流的抽象基类:

InputStream(输入)  OutPutStream(输出)

字符流的抽象基类:

Reader(读)       Writer(写)

这四个类派生出来的子类都是由父类的名作为子类名的后缀.

 

IO需要了解的问题:

1.有了垃圾回收站为什么还要调用close方法去进行关闭

解答: 虽然java已经垃圾回收了这个流,但是系统根本就不知道什么时候关闭这个流,所以我们要手动的去关闭

2.为什么IO异常一定要处理嗯?

解答:如果io异常不处理的, 当读到一个文件的时候出现错误,那么后面的也就会执行不到了.所以我们一定要异常处理/..

字符流创建一个文件

FileWriter fw = new FileWriter(“src/a.txt”); //建立数据存放的文件

 fw.writer(“test”); //把text写入到流中

 

关闭流资源,并将流中的数据进行清空到文件中.

如果想要在原文件中加入新的数据呢?

FileWriter fw = new FileWriter(“src/a.txt”,true);//代表从一个文件的末尾处追加
fw.writer(“happy”);

 

1.jpgCopy.class(对一个图片进行拷贝)

package com.javami.kudy.Code14;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.FileOutputStream;
 public class JpgCopy {
     public static void main(String[]args)
     {
         FileInputStream fis = null;
         FileOutputStream fos = null;
         try
         {
             fis = new FileInputStream("src/a.jpg"); //输入一个图(输出(读)  输出(写))
             fos = new FileOutputStream("src/b.jpg");
             int len;
             while((len=fis.read())!=-1)
             {
                 fos.write(len); //输出(写入)
             }
             
         }catch(IOException e)
         {
             e.printStackTrace();
         }
         finally
         {
             
         }
     }
 }

 

CloseUtil.class(自己写的一个工具关闭流)

 

package com.javami.kudy.Code14;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.Reader;
 import java.io.Writer;
 public class CloseUtil {
     private CloseUtil(){}
     public static void close(InputStream is,OutputStream os,Reader r,Writer w) throws IOException
     {
         try
         {
             is.close();
         }
         finally
         {
             os.close();
             try
             {
                 r.close();
             }
             finally
             {
                 w.close();
             }
         }
     }
 }

 

System.currentTimeillis();//获取毫米数 

 

 自定义输入流:(读)

package com.javami.kudy.CodeBuffer;
 
 import java.io.IOException;
 import java.io.InputStream;
 
 public class MyBufferedInputStream extends InputStream {
     private InputStream is;
     private byte[] buf = new byte[1024]; //假设我这边有1024个缓冲区
     private int len; //默认为零
     private int pos; //标记一下角标的个数
     public MyBufferedInputStream(InputStream is)
     {
         this.is = is;
     }
     /*
      * 1.需要考虑的问题?
      * 思路:
      * 加速
      * FileInputStream  is = new FileInputStream("src/a.jpg");
      */
     @Override
     public int read() throws IOException
     {
         if(len==0)
         {
             len = is.read(buf); //一次性填充缓冲区(从这个文件中截取1024个放到buf里面去,返回的是最长的个数)
             //角标pos置零
             pos=0;
         }
         if(len==-1)
             return -1;
         len--;
         //但是返回的这个byte有可能是-1 ,如果-1程序就错了
         return buf[pos++]&0xff; //0xff代表:11111111 &00000000    00000000 00000000 11111111
         //返回的结果是前面+24个08个1.这样就不会被当成-1处理啦
     }
     public void close()throws IOException
     {
         //关闭底层的流
         is.close();
     }
 
 }

 

自定义输出(写入)

package com.javami.kudy.CodeBuffer;
 
 import java.io.IOException;
 import java.io.OutputStream;
 
 public class MyBufferedOutputStream extends OutputStream {
     private OutputStream op;
     private byte[] buf = new byte[1024];
     int pos;
     int len;
     public MyBufferedOutputStream(OutputStream op)
     {
         this.op = op;
     }
     @Override
     public void write(int b) throws IOException {
         if(pos == 1024)
         {
             flush();
             pos = 0;
         }
         /*
          * 外部执行的情况:
          * while 不断往里面放入字节
          * 内部实现: 判断是否满了.如果满了.我这边就刷新一下.
          */
         buf[pos++] = (byte)b;
     }
     public void flush()throws IOException
     {
         op.write(buf,0,pos);//写入 : 输出(到一个指定的文件里面去)
     }
     public void close()throws IOException
     {
         op.close();
     }
 
 }

 

测试几种用法的时间差:

package com.javami.kudy.CodeBuffer;
 import java.io.BufferedOutputStream;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.BufferedInputStream;
 import com.javami.kudy.Code14.CloseUtil;
 public class Mp3Copy {
     public static void main(String[]agrs)
     {    
         /*
         //时间差
         
         long Timedifference =end - start;
         System.out.println(Timedifference);*/
 
         String source = "src/a.mp3";     //来源
         String target =  "src/d.mp3";   //目标
 
         long start = System.currentTimeMillis();
         try
         {
             myTest(source,target);
         }
         catch(IOException e)
         {
             e.printStackTrace();
         }
         long end = System.currentTimeMillis();
         System.out.println(end-start); //获取到时间差
         System.out.println("hello");
     }
     /*
      * 单个拷贝字节: 毫秒大概是: 50000~60000之间
      */
     private static void FileInputStreamTest(String source,String target)throws IOException
     {
         FileInputStream fls = null;
         FileOutputStream fos = null;
         try
         {
             fls = new FileInputStream(source);
             fos = new FileOutputStream(target);
             int ch;
             while((ch=fls.read())!=-1)
             {
                 fos.write(ch);
             }
         }
         finally
         {
             CloseUtil.close(fls, fos, null, null);
         }
     }
     /*
      * 通过包装类来拷贝  缓存---> 593
      */
     private static void BufferedTest(String source,String target)throws IOException
     {
         BufferedInputStream  bis= null; //读(输入)
         BufferedOutputStream bos = null; //写(输出)
         try
         {
             bis = new BufferedInputStream(new FileInputStream(source));
             bos = new BufferedOutputStream(new FileOutputStream(target));
             int len;
             while((len=bis.read())!=-1) //把左边的内容读到底层的一个bis[pos++]之后再从缓冲区里面返回
             {
                 bos.write(len);
             }
         }
         finally
         {
             CloseUtil.close(bis, bos, null, null);
         }
     }
     /*
      * 用户自定义的缓存数组: 94
      */
     private static void copyMp3ByBuf(String source,String target)throws IOException
     {
         FileInputStream fis = null;
         FileOutputStream fos = null;
         try
         {
             fis = new FileInputStream(source);
             fos = new FileOutputStream(target);
             byte[] buf = new byte[1024];
             int ch;
             while((ch=fis.read(buf))!=-1)
             {
                 fos.write(buf);
             }
         }
         finally
         {
             CloseUtil.close(fis, fos, null, null);
         }
     }
     /*
      * 用自己写的包装输入输出字节流
      * 203
      * 通过比较得出的结论:
      * 
      */
     private static void myTest(String source,String target )throws IOException
     {
         MyBufferedInputStream mis = null;
         MyBufferedOutputStream mos = null;
         try
         {
             mis = new MyBufferedInputStream(new FileInputStream(source));
             mos = new MyBufferedOutputStream(new FileOutputStream(target));
             int b;
             while((b=mis.read())!=-1)
             {
                 mos.write(b);
             }
         }
         finally
         {
             CloseUtil.close(mis, mos, null, null);
         }
     }
 }

 

关闭流的工具类:

package com.javami.kudy.Code14;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.Reader;
 import java.io.Writer;
 public class CloseUtil {
     private CloseUtil(){}
     public static void close(InputStream is,OutputStream os,Reader r,Writer w) throws IOException
     {
         try
         {
             if(is!=null)
                 is.close();
         }
         finally
         {
             if(os!=null)
                 os.close();
             try
             {
                 if(r!=null)
                     r.close();
             }
             finally
             {
                 if(w!=null)
                     w.close();
             }
         }
     }
 }

 

其实字符流的底层实现是需要字节流的

package com.javami.kudy.CodeBuffer;
 
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
 
 public class MyFileWriter extends OutputStreamWriter {
     
     /*
      * 如果你放进去一个字符流!
      * 我们通过底层调用父类的字节流.帮你处理这个数据
      */
     public MyFileWriter(String name)throws IOException
     {
         //底层实现原理: 其实调用字符流底层是字节流实现的?为何呢?
         super(new FileOutputStream(name));
     }
     
     public MyFileWriter(String name,boolean is)throws IOException
     {
         super(new FileOutputStream(name,true));
     }
     
 }

 

关于字节流转字符流

package com.javami.kudy.PM;
 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.io.PrintStream;
 import java.io.OutputStreamWriter;
 import java.io.Reader;
 import java.io.Writer;
 
 import com.javami.kudy.Code14.CloseUtil;
 public class TreasStreamTest {
     /*
      * 字节流转换成字符流
      * 思路:
      * 1.首先要获取到输入流与输出流
      * 2.(字符流) ==  <-- InputStreamReader--> (输入流)
        3.(字符流) == <--OutputStream-->(输出流)
      */
     public static void main(String[]args)
     {
         /*//1.获取输入流
         InputStream ism = System.in;
         //2.获取输出流
         PrintStream pts = System.out;
         //3.字符流(读)-->输入流 转换
         InputStreamReader isr = new InputStreamReader(ism);
         //4.字符流(写)-->输出留
         OutputStreamWriter osr = new OutputStreamWriter(pts);
         //5.转换成父类型的引用可以指向子类型的对象(转换成字符流的读)
         Reader r = isr;
         //6.转换成父类型的引用可以指向子类型的对象(转换成字符流的写)
         Writer w = osr;
         //包装字符流
         BufferedReader br = new BufferedReader(r);//包装
         BufferedWriter bw = new BufferedWriter(w);
         关于执行速度-->
         */
         //从字节流转换成字符流的步骤
         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
         try
         {
             String line;
             while(true)
             {
                 line = br.readLine(); //读一行
                 bw.write(line); //写一行
                 bw.newLine();
                 bw.flush(); //刷新-->从流里面刷新一下.因为它是属于打一行打一行的概率
                 if("bye".equals(br))
                     break;
             }
         }
         catch(IOException e)
         {
             e.printStackTrace();
         }
         finally
         {
             try
             {
                 CloseUtil.close(null, null, br, bw); 
             }
             catch(IOException e)
             {
                 e.printStackTrace();
             }
         }
     }
 }

 

流程图:

 

System.in(读)

System.out(写)

 

BufferedReader br = new BufferedReader(new InputStream(System.in)); //把输入流转换成包装的读

BufferedWriter bw = new BufferedWriter(new OutputStream(System.out)); //把输出流转换成包装的写

BuffferedReader对标准输入System.in进行包装，实现读取键盘上输入的一行

注意:

如果想要实现读一行,打一行↓

 

String line br.readLine(); //第一行

bw.writer(line);

bw.newLine(); //换行

bw.flush()刷新一下流

 

/**
      * 测试题5
      * 输入学生新,按break终止，每个学生有3门课的成绩，定义一种比较直观的文本文件格式，
         输入学生姓名和成绩，从键盘输入以上数据（包括姓名，三门课成绩），
         按总分数从高到低的顺序将学生信息存放在磁盘文件"stu.txt"中。
         思路:
         1.读取键盘，一行输入一个学生的信息，封装成学生对象
         2.将学生对象存入一个TreeSet按总分排序
         3.遍历TreeSet集合，取出所有的学生信息，输出到stu.txt中
      */
 
 package com.javami.kudy.PM;
 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.util.Comparator;
 import java.util.TreeSet;
 public class Test {
     public static void main(String[]args)
     {
         TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>(){
                 
             //比较器
             @Override
             public int compare(Student s1, Student s2) {
                 int num = s1.getSum()-s2.getSum();
                 if(num!=0)
                     return -num;
                 return s1.getName().compareTo(s2.getName());
             }
             
         });
         try
         {
             saveStuInfo(ts);
             listStuInfo(ts);
         }
         catch(IOException e)
         {
             e.printStackTrace();
         }
     }
     /*
      * 遍历集合里面的内容,把它写入到一个文件名里面
      */
     private static void listStuInfo(TreeSet<Student> ts)throws IOException
     {
         BufferedWriter bw = null;
         try
         {
             bw = new BufferedWriter(new FileWriter("src/a.txt"));
             for(Student str : ts)
             {    
                 //一定要标记为toString  为啥呢?  因为它是不会自动的打印toString的
                 bw.write(str.toString());
                 bw.newLine();
             }
         }
         finally
         {
             bw.close();
         }
     }
     /*
      * 读取键盘
      * 获取学习的对象
      * 把学习的对象存入ts里面去
      */
     public static void saveStuInfo(TreeSet<Student> ts)throws IOException
     {
         //当你读的时候,我们要求它用逗号分隔
         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));//输入-?读
         try
         {
             String line;
             while(true)
             {
                 line = br.readLine(); //读一行
                 if("break".equals(line))
                     break;
                 //将line分隔成4部分
                 String[]bufs = line.split(",");
                 Student s = new Student(bufs[0],Integer.parseInt(bufs[1])
                             ,Integer.parseInt(bufs[2])
                             ,Integer.parseInt(bufs[3]));
                 ts.add(s);
             }
         }
         finally
         {
             br.close();
         }
     }
 }
 
 class Student
 {
     private String name;
     private int chinese; //语文成绩
     private int math; //数学成绩
     private int english; //英语成绩
     private int sum; //总分
     public Student(String name,int chinese,int math,int english)
     {
         this.name = name;
         this.chinese = chinese;
         this.math = math;
         this.english = english;
         this.sum = chinese+math+english;
     }
     public int getSum()
     {
         return sum;
     }
     public String getName()
     {
         return name;
     }
     @Override
     public String toString()
     {
         return "姓名:"+name+"语文成绩:"+chinese+"数学成绩:"+math+"英语成绩:"+english;
     }
     
 }