java的io流_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 importjava.io.File;2 importjava.io.FileInputStream;3 importjava.io.IOException;4

5 public classDemo6 {6

7 public static void main(String[] args) throwsIOException{8 File file=new File("1.txt"); //新建一个文件的抽象路径9 FileInputStream fis=newFileInputStream(file);10 int result=fis.read();11 System.out.println(result);12

13 }14

15 }

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

字节输入流的循环读取：

1 importjava.io.File;2 importjava.io.FileInputStream;3 importjava.io.IOException;4

5 public classDemo7 {6

7 public static void main(String[] args) throwsIOException{8 File file =new File("1.txt");9 FileInputStream fis=newFileInputStream(file);10 intresult;11 while((result=fis.read())!=-1) {12 System.out.print(result+"\t");13 }14

15

16 }17

18 }

打印了a到g的ASCII码值

字符流的读取方法：

1 importjava.io.File;2 importjava.io.FileInputStream;3 importjava.io.IOException;4

5 public classDemo8 {6

7 public static void main(String[] args) throwsIOException{8 File file =new File("1.txt");9 FileInputStream fis=newFileInputStream(file);10 byte[] bt=new byte[1024];11 intcount;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 importjava.io.File;2 importjava.io.FileInputStream;3 importjava.io.IOException;4

5 public classDemo9 {6

7 public static void main(String[] args) throwsIOException{8 File file =new File("D:\\Java代码\\123.png");9 FileInputStream fis=newFileInputStream(file);10 intcount;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 importjava.io.File;2 importjava.io.FileInputStream;3 importjava.io.IOException;4

5 public classDemo10 {6

7 public static void main(String[] args) throwsIOException {8 File file=new File("D:\\Java代码\\123.png");9 FileInputStream fis=newFileInputStream(file);10 byte[] bt=new byte[1024];11 intcount;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 importjava.io.File;2 importjava.io.FileOutputStream;3 importjava.io.IOException;4

5 public classDemo11 {6

7 public static void main(String[] args) throwsIOException {8 File file=new File("3.txt");9 FileOutputStream fos=newFileOutputStream(file);10

11 fos.write("没有绝对的绝缘体，只有不努力的电压。".getBytes());12 }13 }

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

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

代码示例：

1 importjava.io.File;2 importjava.io.FileInputStream;3 importjava.io.FileOutputStream;4 importjava.io.IOException;5

6 public classDemo12 {7

8 public static void main(String[] args) throwsIOException {9 File file=new File("1.txt");10 FileInputStream fis=newFileInputStream(file);11 FileOutputStream fos=new FileOutputStream(new File("4.txt"));12 byte[] bt=new byte[1024];13 intcount;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) throwsIOException {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 voidmain(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 voidclose(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 classJdk1_7 流的异常处理形式 {2 public static voidmain(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=newScanner(System.in);18 String name =sc1.nextLine();19 }20 }