HelloWorld
登录

Java IO流

Wesley13

2021-10-11

1157 0 0

IO流框架

IO框架

IO流概述

IO即输入与输出,Java把不同来源和目标的数据抽象为流,在此基础上对流进行数据操作

IO流分类

  • 按流向分：
    1. 输入流
    2. 输出流
  • 按操作类型分：
    1. 字节流 : 面向字节,非必须缓冲区,可处理任意文件
    2. 字符流 : 面向字符(可能是多个字节),必须缓冲区,一般处理文本

IO流顶层父类皆为抽象类

顶层父类

描述

InputStrream

输入字节流

OutputStream

输出字节流

Reader

输入字符流

Writer

输出字符流

IO使用流程

  1. 使用前，导入IO包中的类
  2. 使用时，进行IO异常处理
  3. 使用后，释放资源

字节流

FileInputStream,FileOutputStream(简单字节流)

demo

1import java.io.*;
2
3public class IoTest {
4    public static void main(String[] args) throws IOException {
5        FileInputStream fi=new FileInputStream("a.txt");
6        FileOutputStream fo=new FileOutputStream("b.txt");
7        int len;
8        byte[] buffer=new byte[1024*8];//缓冲区大小
9        while ((len=fi.read(buffer))!=-1)//read()返回-1表示到结尾,返回正数表示读到的有效字节数
10            fo.write(buffer,0,len);
11        fi.close();
12        fo.close();
13    }
14}

FileOutputStream的追加模式

1FileOutputStream(File file, boolean append) 
2//创建文件输出流,将append设置为1即为追加模式

BufferedInputStream,BufferOutputStream(自建缓冲区)

demo

1import java.io.*;
2
3public class IoTest {
4    public static void main(String[] args) throws IOException {
5        BufferedInputStream fi=new BufferedInputStream(new FileInputStream("a.txt"));
6        BufferedOutputStream fo=new BufferedOutputStream(new FileOutputStream("b.txt"));
7        int temp;
8        while ((temp=fi.read())!=-1)//read()返回-1表示到结尾
9            fo.write(temp);
10        fi.close();
11        fo.close();
12    }
13}

默认缓冲区大小是8192字节

private static int DEFAULT_BUFFER_SIZE = 8192;

flush和close方法的区别

  • flush()方法用来刷新缓冲区的,将缓冲中的数据写入
  • close()方法用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,会先调用flush()在调用close()关闭流

SequenceInputStream(序列流)

序列流可以把多个字节输入流整合成一个输入流, 从序列流中读取数据时, 按照整合顺序一一读取

整合两个字节流

1FileInputStream fis1 = new FileInputStream("a.txt");			//创建输入流对象,关联a.txt
2FileInputStream fis2 = new FileInputStream("b.txt");			//创建输入流对象,关联b.txt
3SequenceInputStream sis = new SequenceInputStream(fis1, fis2);	//将两个流整合成一个流
4FileOutputStream fos = new FileOutputStream("c.txt");			//创建输出流对象,关联c.txt
5int b;
6while((b = sis.read()) != -1) {									//用整合后的读
7	fos.write(b);												//写到指定文件上
8}
9sis.close();
10fos.close();

整合多个字节流

1FileInputStream fis1 = new FileInputStream("a.txt");	//创建输入流对象,关联a.txt
2FileInputStream fis2 = new FileInputStream("b.txt");	//创建输入流对象,关联b.txt
3FileInputStream fis3 = new FileInputStream("c.txt");	//创建输入流对象,关联c.txt
4Vector<InputStream> v = new Vector<>();		//创建vector集合对象
5v.add(fis1);	//将流对象添加
6v.add(fis2);
7v.add(fis3);
8Enumeration<InputStream> en = v.elements();		//获取枚举引用
9SequenceInputStream sis = new SequenceInputStream(en);	//传递给SequenceInputStream构造
10FileOutputStream fos = new FileOutputStream("d.txt");
11int b;
12while((b = sis.read()) != -1) {
13	fos.write(b);
14}
15sis.close();
16fos.close();

ByteArrayInputStream,ByteArrayOutputStream(内存流)

1FileInputStream fi=new FileInputStream("a.txt");
2ByteOutputStream bo=new ByteOutputStream();
3int temp;
4while ((temp=fi.read())!=-1)//read()返回-1表示到结尾
5    bo.write(temp);//将字节写入内存
6System.out.println(bo);//将内存中的字节转换为字符再打印
7fi.close();

ObjectInputStream,ObjectOutputStream(对象流)

1ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"));
2Person p1 = (Person) ois.readObject();
3Person p2 = (Person) ois.readObject();
4System.out.println(p1);
5System.out.println(p2);
6ois.close();

字符流

字符流是不可以拷贝非纯文本的文件

  • 因为在读的时候会将字节转换为字符,在转换过程中,可能找不到对应的字符,就会用?代替,写出的时候会将字符转换成字节写出去

FileReader,FileWriter(简单字符流)

1FileReader fr = new FileReader("aaa.txt");//创建字符输入流,关联aaa.txt
2FileWriter fw = new FileWriter("bbb.txt");//创建字符输出流,关联bbb.txt
3int len;
4char[] arr = new char[1024*8];//创建字符数组
5while((len = fr.read(arr)) != -1) {//将数据读到字符数组中
6	fw.write(arr, 0, len);//从字符数组将数据写到文件上
7}
8fr.close();//关流释放资源
9fw.close();

BufferedReader,BufferedWriter(自建缓冲区)

1BufferedReader br = new BufferedReader(new FileReader("aaa.txt"));//创建字符输入流对象,关联aaa.txt
2BufferedWriter bw = new BufferedWriter(new FileWriter("bbb.txt"));//创建字符输出流对象,关联bbb.txt
3	int ch;				
4	while((ch = br.read()) != -1) {//read一次,会先将缓冲区读满,从缓冲去中一个一个的返给临时变量ch
5		bw.write(ch);//write一次,是将数据装到字符数组,装满后再一起写出去
6	}
7	br.close();//关流
8	bw.close();

readLine()和newLine()方法

  • readLine()方法可以读取一行字符(不包含换行符号)

  • newLine()可以输出一个跨平台的换行符号"\r\n"

    BufferedReader br = new BufferedReader(new FileReader("a.txt")); BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt")); String line; while((line = br.readLine()) != null) { bw.write(line); bw.newLine();//跨平台的 } br.close(); bw.close();

InputStreamReader,OutputStreamWriter(指定字符编码)

1InputStreamReader isr=new InputStreamReader(new FileInputStream("a.txt"),"utf-8");//按照urf-8读a.txt
2OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("b.txt"),"gbk");//按照gbk写入到b.txt
3int temp;
4while ((temp=isr.read())!=-1)//read()返回-1表示到结尾
5     osw.write(temp);
6isr.close();
7osw.close();

LineNumberReader (记录行号)

  • LineNumberReader是BufferedReader的子类, 具有相同的功能, 并且可以统计行号

    • 调用getLineNumber()方法可以获取当前行号
    • 调用setLineNumber()方法可以设置当前行号

    LineNumberReader lnr = new LineNumberReader(new FileReader("a.txt")); String line; lnr.setLineNumber(100);//设置行号,从101开始打印,但还是对应第一行 while((line = lnr.readLine()) != null) { System.out.println(lnr.getLineNumber() + ":" + line);//获取行号 } lnr.close();

IO流异常处理

方法一

1FileInputStream fis =null;
2FileOutputStream fos =null;
3try(
4    fis = new FileInputStream("aaa.txt");
5    fos = new FileOutputStream("bbb.txt");
6    int b;
7    while((b = fis.read()) != -1) {
8         fos.write(b);
9    }
10)finally{
11   try{
12       if(fis!=null)//输入流如果打开了
13           fis.close;
14   }finally{
15       if(fos!=null)//输出流如果打开了
16           fos.close;
17   }
18}

方法二

1try(
2    FileInputStream fis = new FileInputStream("aaa.txt");
3    FileOutputStream fos = new FileOutputStream("bbb.txt");
4){
5    int b;
6    while((b = fis.read()) != -1) {
7         fos.write(b);
8    }
9}
  • 在try()中创建的流对象必须实现了AutoCloseable这个接口,如果实现了,在try后面的{}(读写代码)执行后就会自动调用,流对象的close方法将流关掉
点赞
收藏

评论区

加载中...

相关推荐

手写Java HashMap源码

HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程22

NIO入门

1、I/O输入输出，所有的IO都被视作是单个字节的移动，通过stream对象一次移动一个字节。流IO负责把对象转换为字节，然后再转换为对象。NIO提供了二套NIO，一套是针对标准输入输出NIO，另一套是网络编程NIO2、流与块的比较NIO和IO最大的区别是数据打包和传输方式，IO是以流的方式来处理数据，而NIO是以块的方式处理数据。面向块的IO

IO（输入输出）

IO流有很多种，按照操作数据的不同，可以分为字节流和字符流，按照数组传输方向的不同又可分为输入流和输出流。字节流的输入输出流分别用java.io.InputStream和java.io.OutputStream表示，字符流的输入输出流分别用java.io.Reader和java.io.Writer表示。!(https://oscimg

Java IO输入输出

学前知道Java的IO使用“流”的概念来表示。IO流涉及到数据源和目的地。流，是从源“流向”目的的数据流。Java将各种数据源和目标之间数据的传输统一抽象为流，通过对流对象的操作来完成I/O功能。输入输出实际都是对内存而言的。数据源可以是键盘、文件、应用程序、鼠标、网络连接。

Java IO流详解

参考转载地址：https://blog.csdn.net/zhangliangzi/article/details/51226652(https://www.oschina.net/action/GoToLink?urlhttps%3A%2F%2Fblog.csdn.net%2Fzhangliangzi%2Farticle%2Fdetails%2F51

Java NIO和IO的区别

IO               NIO面向流           面向缓冲阻塞IO           非阻塞IO无               选择器面向流与面向缓冲JavaNIO和IO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。JavaIO面向流意味着每次从流中