• JAVA中IO流详解


    IO流:数据传输是需要通道的,而IO流就是数据传输的通道。

        IO流可以形象的比喻为运送货物的传输带。

    IO流的分类:

      ①根据操作的数据类型的不同可以分为 :字节流与字符流。

      ②根据数据的流向分为:输入流与输出流,程序(内存)作为参照物,程序从外部读取称为输入(Input),程序向外部写数据成为输出(Output)。

    字节输入流:

        父类:InputStream

     常用的字节输入流:FileInputStream

    1.FileInputStream

       ①构造方法:

      FileInputStream(File)

      FileInputStream(String  filename)

    2.常用方法 

      ①read :读取一个字节,返回该字节的值,如果到达文件的末尾,则返回-1。需要注意:read()方法和迭代器一样,会自动下移的

      ②read(byte[ ])从输入流中读取至多一个数组长度的内容,到达文件末尾,则返回-1。    

    • 数组称为缓冲区数组,大小一般取值为1024的整数倍。
    • 转换为字符时,使用String(byte [ ]   bytes,int offset,int length)
    • available()没有读取的剩余字节数,如果该文件还从未被读取,就返回该文件的长度。
    • close() 关闭流并释放资源

    字节输入流代码演示:

    其中1.txt位于本项目的根目录下:内容为"abcdefg"

    复制代码
     1 import java.io.File;
     2 import java.io.FileInputStream;
     3 import java.io.IOException;
     4 
     5 public class Demo6 {
     6 
     7     public static void main(String[] args) throws IOException{
     8         File file=new File("1.txt");     //新建一个文件的抽象路径
     9         FileInputStream fis=new FileInputStream(file);  
    10         int result=fis.read();
    11         System.out.println(result);
    12 
    13     }
    14 
    15 }
    复制代码

     程序执行的结果为97,因为读取的a的ASCII码值

     字节输入流的循环读取:

    复制代码
     1 import java.io.File;
     2 import java.io.FileInputStream;
     3 import java.io.IOException;
     4 
     5 public class Demo7 {
     6 
     7     public static void main(String[] args) throws IOException{
     8         File file =new File("1.txt");
     9         FileInputStream fis=new FileInputStream(file);
    10         int result;
    11         while((result=fis.read())!=-1) {
    12             System.out.print(result+"	");
    13         }
    14         
    15 
    16     }
    17 
    18 }
    复制代码

     打印了a到g的ASCII码值

    字符流的读取方法:

    复制代码
     1 import java.io.File;
     2 import java.io.FileInputStream;
     3 import java.io.IOException;
     4 
     5 public class Demo8 {
     6 
     7     public static void main(String[] args) throws IOException{
     8         File file =new File("1.txt");
     9         FileInputStream fis=new FileInputStream(file);
    10         byte[] bt=new byte[1024];
    11         int count;
    12         while((count=fis.read(bt))!=-1) {
    13             String string =new String(bt,0,count);
    14             System.out.println(string);
    15         }
    16     }
    17 }
    复制代码

    输出结果

    下面可以用同样的文件来比较字节输入流和字符输入流的读取速度:

    文件是一张格式为png图片

    先是字节输入流的读取速度

    复制代码
     1 import java.io.File;
     2 import java.io.FileInputStream;
     3 import java.io.IOException;
     4 
     5 public class Demo9 {
     6 
     7     public static void main(String[] args) throws IOException{
     8         File file =new File("D:\Java代码\123.png");
     9         FileInputStream fis=new FileInputStream(file);
    10         int count;
    11         long start=System.currentTimeMillis();
    12         while((count=fis.read())!=-1) {
    13             System.out.println(count);
    14         }
    15         long end=System.currentTimeMillis();
    16         System.out.println("======下面是所用的时间======");
    17         System.out.println(end-start);
    18     }
    19 
    20 }
    复制代码

    结果如下:

    下面是字符输入流:

    复制代码
     1 import java.io.File;
     2 import java.io.FileInputStream;
     3 import java.io.IOException;
     4 
     5 public class Demo10 {
     6 
     7     public static void main(String[] args) throws IOException {
     8         File file=new File("D:\Java代码\123.png");
     9         FileInputStream fis=new FileInputStream(file);
    10         byte[] bt=new byte[1024];
    11         int count;
    12         long start=System.currentTimeMillis();
    13         while((count=fis.read(bt))!=-1) {
    14             System.out.println(count);
    15         }
    16         long end=System.currentTimeMillis();
    17         System.out.println("======下面是所用的时间======");
    18         System.out.println(end-start);
    19     }
    20 }
    复制代码

    结果如下:

    字节输入流读取文件花费了760毫秒,而字符输入流读取文件花费了3毫秒,由此可见,字符输入流的速度要比字节输入流更快。

    文件字节输出流:

    字节输出流:OutputStream  是所有输出流的超类

    常用子类:FileOutputStream  文件字节输出流

    构造方法:

        FileOutputStream(File file) /FileOutputStream(String name)

      注意:如果父目录不存在,会报FileNotFoundException异常,如果父目录存在,会创建一个新的文件,如果此时已经有文件存在,会覆盖原文件

       FileOutputStream(File file,boolean flag)/FileOutputStream(String name,boolean flag)

      注意:如果当前文件需要从文件末尾进行插入(接着文件里的内容继续写),必须将第二个参数设置为true,默认不写为false,会覆盖原文件

    常用方法:

      write(int)向文件中写入一个字节的值

      write(byte[]) 向文件中写入一个数组的数据。

      ***③ write(byte[] offset len) 将 偏移量为 offset 的索引位置的长度为 len 的数据,写入到输出流中。

    代码示例:

    复制代码
     1 import java.io.File;
     2 import java.io.FileOutputStream;
     3 import java.io.IOException;
     4 
     5 public class Demo11 {
     6 
     7     public static void main(String[] args) throws IOException {
     8         File file=new File("3.txt");
     9         FileOutputStream fos=new FileOutputStream(file);
    10         
    11         fos.write("没有绝对的绝缘体,只有不努力的电压。".getBytes());                
    12     }
    13 }
    复制代码

    执行结果,会在本项目的根目录下生成一个3.txt 文件,并且将内容写入进去。

    文件复制:将一个文件通过IO流复制到另一个文件中去

    代码示例:

    复制代码
     1 import java.io.File;
     2 import java.io.FileInputStream;
     3 import java.io.FileOutputStream;
     4 import java.io.IOException;
     5 
     6 public class Demo12 {
     7 
     8     public static void main(String[] args) throws IOException {
     9         File file=new File("1.txt");
    10         FileInputStream fis=new FileInputStream(file);
    11         FileOutputStream fos=new FileOutputStream(new File("4.txt"));
    12         byte[] bt=new byte[1024];
    13         int count;
    14         while((count=fis.read(bt))!=-1) {
    15             fos.write(bt,0,count);
    16         }
    17         fis.close();
    18         fos.close();
    19     }
    20 }
    复制代码

    结果会将1.txt的内容复制到4.txt中

    带缓冲区的字节流
    1. 通过比较 read() 与 read(byte[]) 的方法复制文件的时间的长短,可以看出,带缓冲区的读写文件的速度快,
    java 上提供了专门带缓冲区的字节流,用以提高读写速度。
    2.BufferedInputStream /BufferedOutputStream 带缓冲区的字节输入 / 输出流
    3. 结论: 带缓冲区的字节流 读取速度高于字节流
    代码演示:

    复制代码
     1 public class  带缓冲区的字节流 {
     2 public static void main(String[] args) throws IOException {
     3 /*FileInputStream fis=new FileInputStream(new File("src\com\ 文件复制 .java"));
     4 // 复制操作 :
     5 BufferedInputStream bis=new BufferedInputStream(fis);*/
     6 // // 读取
     7 // BufferedInputStream bis=new BufferedInputStream(new FileInputStream(new File("src\com\ 文
     8 件复制 .java")));
     9 // // 写入
    10 // BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(new File("1.java"))
    11 );
    12 // 读取
    13 BufferedInputStream bis=new BufferedInputStream(new FileInputStream(new File("D:\0318java 班
    14 \day08\ 录屏 \1_day08IO 流概述 .mp4")));
    15 // 写入
    16 BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(new File("C:\Users\
    17 Administrator\Desktop\2.mp4")));
    18 byte[] bt=new byte[1024];
    19 int count=0;
    20 long start=System.currentTimeMillis();
    21 while((count=bis.read(bt))!=-1) {
    22 bos.write(bt, 0, count);
    23 }
    24 long end=System.currentTimeMillis();
    25 System.out.println(end-start);
    26 bis.close();
    27 bos.close();
    28 }
    29 }
    复制代码

    jdk1.6 流的异常处理
    1. 异常处理方式:
    ① try-catch-finally 异常的捕获
    ② throws 异常的声明
    2. 以文件复制的形式来写流的异常处理 :
    在 1.7jdk 之前包括 1.6 不包含 1.7 的流的异常处理形式。
    代码演示:

    复制代码
     1 public class  字节流的异常处理方式 {
     2 public static void main(String[] args) {
     3 // 为了在 finally 里面能够使用关闭资源,提升作用域
     4 FileInputStream fis=null;
     5 FileOutputStream fos=null;
     6 try {
     7 // 输入流
     8 fis=new FileInputStream(new File("src\com\ 带缓冲区的字节流 .java"));
     9 // 输出流
    10 fos=new FileOutputStream(new File("2.java"));
    11 // 文件复制
    12 byte[] bt=new byte[1024];
    13 int count=0;
    14 while((count=fis.read(bt))!=-1) {
    15 fos.write(bt,0,count);
    16 }
    17 }catch(Exception e) {
    18 e.printStackTrace();
    19 }finally {
    20 close(fis, fos);
    21 }
    22 }
    23 public static void close(InputStream fis,OutputStream fos) {
    24 // 关闭资源
    25 try {
    26 // 为了防止空指针,需要判断不为 null 再关闭
    27 if (fis!=null) {
    28 fis.close();
    29 }
    30 } catch (IOException e) {
    31 // TODO Auto-generated catch block
    32 e.printStackTrace();
    33 }
    34 try {
    35 // 为了防止空指针,需要判断不为 null 再关闭
    36 if (fos!=null) {
    37 fos.close();
    38 }
    39 } catch (IOException e) {
    40 // TODO Auto-generated catch block
    41 e.printStackTrace();
    42 }
    43 }
    44 }
    复制代码

    Jdk1_7 流的异常处理形式

    复制代码
     1 public class Jdk1_7 流的异常处理形式 {
     2 public static void main(String[] args) {
     3 try(
     4 FileInputStream fis=new FileInputStream(new File("src\com\ 带缓冲区的字节流 .java"));
     5 FileOutputStream fos=new FileOutputStream(new File("3.java"));
     6 ){
     7 /*Scanner sc=new Scanner(System.in);
     8 sc.close();*/
     9 byte[] bt=new byte[1024];
    10 int count=0;
    11 while((count=fis.read(bt))!=-1) {
    12 fos.write(bt,0,count);
    13 }
    14 }catch (Exception e) {
    15 e.printStackTrace();
    16 }
    17 Scanner sc1=new Scanner(System.in);
    18 String name = sc1.nextLine();
    19 }
    20 }
     
  • 相关阅读:
    《30天自制操作系统》笔记(10)——定时器
    《30天自制操作系统》笔记(09)——绘制窗口
    《30天自制操作系统》笔记(08)——叠加窗口刷新
    《30天自制操作系统》笔记(07)——内存管理
    《30天自制操作系统》笔记(06)——CPU的32位模式
    《30天自制操作系统》笔记(05)——启用鼠标键盘
    《30天自制操作系统》笔记(04)——显示器256色
    《30天自制操作系统》笔记(03)——使用Vmware
    《30天自制操作系统》笔记(02)——导入C语言
    《30天自制操作系统》笔记(01)——hello bitzhuwei’s OS!
  • 原文地址:https://www.cnblogs.com/xianz666/p/13738841.html
Copyright © 2020-2023  润新知