Java IO流详解

File对象可以表示存在的文件或文件夹,也可以表示不存在的。

我们想要得到文件的内容怎么办,File只是操作文件,文件的内容如何处理就需要使用io流技术了。

例如在C盘下有一个名称为a.txt的文本文件.想要通过Java程序读出来文件中的内容,需要使用IO流技术.同样想要将程序中的数据,保存到硬盘的文件中,也需要IO流技术.

读和写文件文件示例:

public class IoTest {
	public static void main(String[] args) throws FileNotFoundException,
			IOException {
		writFileTest();

		readFileTest();
	}

	private static void writFileTest() throws FileNotFoundException,
			IOException {
		// 创建文件对象
		File file = new File("c:\\a.txt");
		// 创建文件输出流
		FileOutputStream fos = new FileOutputStream(file);
		fos.write('g');
		fos.write('z');
		fos.write('i');
		fos.write('t');
		fos.write('c');
		fos.write('a');
		fos.write('s');
		fos.write('t');
		fos.close();
	}

	private static void readFileTest() throws FileNotFoundException,
			IOException {
		// 创建文件对象
		File file = new File("c:\\a.txt");
		// 创建文件输入流
		FileInputStream fis = new FileInputStream(file);
		// 有对多长,就读多少字节。
		for (int i = 0; i < file.length(); i++) {
			System.out.print((char) fis.read());
		}
		fis.close();
	}

当完成流的读写时,应该通过调用close方法来关闭它,这个方法会释放掉十分有限的操作系统资源.如果一个应用程序打开了过多的流而没有关闭它们,那么系统资源将被耗尽.

1.IO流简介:(Input/Output

I/O类库中使用这个抽象概念。Java对设备中数据的操作是通过流的方式。

表示任何有能力产出数据的数据源对象,或者是有能力接受数据的接收端对象。屏蔽了实际的I/O设备中处理数据的细节。IO流用来处理设备之间的数据传输。设备是指硬盘、内存、键盘录入、网络等。

Java用于操作流的对象都在IO包中。IO流技术主要用来处理设备之间的数据传输。

由于Java用于操作流的对象都在IO包中。所以使用IO流需要导包如:import java.io.*;

2.IO流的分类:

流按操作数据类型的不同分为两种:字节流与字符流。

流按流向分为:输入流,输出流(以程序为参照物,输入到程序,或是从程序输出),如图:



3.字节流

(1)字节流基类

1)InputStream

InputStream:字节输入流基类,抽象类是表示字节输入流的所有类的超类。

常用方法:
    // 从输入流中读取数据的下一个字节
    abstract int read()
    // 从输入流中读取一定数量的字节,并将其存储在缓冲区数组 b中
    int read(byte[] b)
    // 将输入流中最多 len 个数据字节读入 byte 数组
    int read(byte[] b, int off, int len)
    // 跳过和丢弃此输入流中数据的 n个字节
    long skip(long n)
    // 关闭此输入流并释放与该流关联的所有系统资源
    void close()
2)OutputStream

OutputStream:字节输出流基类,抽象类是表示输出字节流的所有类的超类。

常用方法:
    // 将 b.length 个字节从指定的 byte 数组写入此输出流
    void write(byte[] b)
    // 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流
    void write(byte[] b, int off, int len)
    // 将指定的字节写入此输出流
    abstract void write(int b)
    // 关闭此输出流并释放与此流有关的所有系统资源
    void close()
    // 刷新此输出流并强制写出所有缓冲的输出字节
    void flush()
(2)字节文件操作流

1)FileInputStream

FileInputStream:字节文件输入流,从文件系统中的某个文件中获得输入字节,用于读取诸如图像数据之类的原始字节流。

构造方法:
    // 通过打开一个到实际文件的连接来创建一个FileInputStream,该文件通过文件系统中的File对象file指定
    FileInputStream(File file)
    // 通过打开一个到实际文件的连接来创建一个FileInputStream,该文件通过文件系统中的路径name指定
    FileInputStream(String name)
 常用方法:覆盖和重写了父类的的常用方法。
        // 读取f盘下该文件f://hell/test.txt
        //构造方法1
        InputStream inputStream = new FileInputStream(new File("f://hello//test.txt"));
        int i = 0;
        //一次读取一个字节
        while ((i = inputStream.read()) != -1) {
            // System.out.print(i + " ");// 65 66 67 68
            //为什么会输出65 66 67 68?因为字符在底层存储的时候就是存储的数值。即字符对应的ASCII码。
            System.out.print((char) i + " ");// A B C D
        }
        //关闭IO流
        inputStream.close();
  // 读取f盘下该文件f://hell/test.txt
        //构造方法2
        InputStream inputStream2 = new FileInputStream("f://hello/test.txt");
        // 字节数组
        byte[] b = new byte[2];
        int i2 = 0;
        //  一次读取一个字节数组
        while ((i2 = inputStream2.read(b)) != -1) {
            System.out.print(new String(b, 0, i2) + " ");// AB CD
        }
        //关闭IO流
        inputStream2.close();

注意: 一次读取一个字节数组,提高了操作效率,IO流使用完毕一定要关闭。

2)FileOutputStream

FileOutputStream:字节文件输出流是用于将数据写入到File,从程序中写入到其他位置。

 构造方法:
    // 创建一个向指定File对象表示的文件中写入数据的文件输出流
    FileOutputStream(File file)
    // 创建一个向指定File对象表示的文件中写入数据的文件输出流
    FileOutputStream(File file, boolean append)
    // 创建一个向具有指定名称的文件中写入数据的输出文件流
    FileOutputStream(String name)
    // 创建一个向具有指定name的文件中写入数据的输出文件流
    FileOutputStream(String name, boolean append)
 常用方法:覆盖和重写了父类的的常用方法。
OutputStream outputStream = new FileOutputStream(new File("test.txt"));
        // 写出数据
        outputStream.write("ABCD".getBytes());
        // 关闭IO流
        outputStream.close();
        // 内容追加写入
        OutputStream outputStream2 = new FileOutputStream("test.txt", true);
        // 输出换行符
        outputStream2.write("\r\n".getBytes());
        // 输出追加内容
        outputStream2.write("hello".getBytes());
        // 关闭IO流
        outputStream2.close();

注意:输出的目的地文件不存在,则会自动创建,不指定盘符的话,默认创建在项目目录下;输出换行符时一定要写\r\n不能只写\n,因为不同文本编辑器对换行符的识别存在差异性。

(3)字节缓冲流

1)BufferedInputStream

BufferedInputStream:字节缓冲输入流,提高了读取效率

 构造方法:
     // 创建一个 BufferedInputStream并保存其参数,即输入流in,以便将来使用。
     BufferedInputStream(InputStream in)
     // 创建具有指定缓冲区大小的 BufferedInputStream并保存其参数,即输入流in以便将来使用
     BufferedInputStream(InputStream in, int size)
 InputStream in = new FileInputStream("test.txt");
        // 字节缓存流
        BufferedInputStream bis = new BufferedInputStream(in);
        byte[] bs = new byte[20];
        int len = 0;
        while ((len = bis.read(bs)) != -1) {
            System.out.print(new String(bs, 0, len));
            // ABCD
            // hello
        }
        // 关闭流
        bis.close();
2)BufferedOutputStream

BufferedOutputStream:字节缓冲输出流,提高了写出效率。

 构造方法:
     // 创建一个新的缓冲输出流,以将数据写入指定的底层输出流
     BufferedOutputStream(OutputStream out)
     // 创建一个新的缓冲输出流,以将具有指定缓冲区大小的数据写入指定的底层输出流
     BufferedOutputStream(OutputStream out, int size)
     常用方法:
     // 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流
     void write(byte[] b, int off, int len)
     // 将指定的字节写入此缓冲的输出流
     void write(int b)
     // 刷新此缓冲的输出流
     void flush()
 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test.txt", true));
        // 输出换行符
        bos.write("\r\n".getBytes());
        // 输出内容
        bos.write("Hello Android".getBytes());
        // 刷新此缓冲的输出流
        bos.flush();
        // 关闭流
        bos.close();
4.字符流

(1)字符流基类

1)Reader

Reader:读取字符流的抽象类.

 常用方法:
    // 读取单个字符
    int read()
    // 将字符读入数组
    int read(char[] cbuf)
    // 将字符读入数组的某一部分
    abstract int read(char[] cbuf, int off, int len)
    // 跳过字符
    long skip(long n)
    // 关闭该流并释放与之关联的所有资源
    abstract void close()
2)Writer

Writer:写入字符流的抽象类.

常用方法:
    // 写入字符数组
     void write(char[] cbuf)
    // 写入字符数组的某一部分
    abstract void write(char[] cbuf, int off, int len)
    // 写入单个字符
    void write(int c)
    // 写入字符串
    void write(String str)
    // 写入字符串的某一部分
    void write(String str, int off, int len)
    // 将指定字符添加到此 writer
    Writer append(char c)
    // 将指定字符序列添加到此 writer
    Writer append(CharSequence csq)
    // 将指定字符序列的子序列添加到此 writer.Appendable
    Writer append(CharSequence csq, int start, int end)
    // 关闭此流,但要先刷新它
    abstract void close()
    // 刷新该流的缓冲
    abstract void flush()
(2)字符转换流

1)InputStreamReader

InputStreamReader:字节流转字符流,它使用的字符集可以由名称指定或显式给定,否则将接受平台默认的字符集。

 构造方法:
    // 创建一个使用默认字符集的 InputStreamReader
    InputStreamReader(InputStream in)
    // 创建使用给定字符集的 InputStreamReader
    InputStreamReader(InputStream in, Charset cs)
    // 创建使用给定字符集解码器的 InputStreamReader
    InputStreamReader(InputStream in, CharsetDecoder dec)
    // 创建使用指定字符集的 InputStreamReader
    InputStreamReader(InputStream in, String charsetName)
 特有方法:
    //返回此流使用的字符编码的名称 
    String getEncoding() 
       //使用默认编码        
        InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"));
        int len;
        while ((len = reader.read()) != -1) {
            System.out.print((char) len);//爱生活,爱Android
        }
        reader.close();
         //指定编码 
        InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"),"utf-8");
        int len;
        while ((len = reader.read()) != -1) {
            System.out.print((char) len);//????????Android
        }
        reader.close();

注意:Eclipse默认使用GBK编码,test.txt文件所以是GBK编码,当指定utf-8编码时所以会乱码。

2)OutputStreamWriter

OutputStreamWriter:字节流转字符流。

 构造方法:
    // 创建使用默认字符编码的 OutputStreamWriter
    OutputStreamWriter(OutputStream out)
    // 创建使用给定字符集的 OutputStreamWriter
    OutputStreamWriter(OutputStream out, Charset cs)
    // 创建使用给定字符集编码器的 OutputStreamWriter
    OutputStreamWriter(OutputStream out, CharsetEncoder enc)
    // 创建使用指定字符集的 OutputStreamWriter
    OutputStreamWriter(OutputStream out, String charsetName)
 特有方法:
    //返回此流使用的字符编码的名称 
    String getEncoding() 
(3)字符缓冲流(高效流)

1)BufferedReader

BufferedReader:字符缓冲流,从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。

 构造方法:
    // 创建一个使用默认大小输入缓冲区的缓冲字符输入流
    BufferedReader(Reader in)
    // 创建一个使用指定大小输入缓冲区的缓冲字符输入流
    BufferedReader(Reader in, int sz)
 特有方法:
    // 读取一个文本行
    String readLine()
      //生成字符缓冲流对象
        BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("test.txt")));
        String str;
        //一次性读取一行
        while ((str = reader.readLine()) != null) {
            System.out.println(str);// 爱生活,爱Android
        }
        //关闭流
        reader.close();
2)BufferedWriter

BufferedWriter:字符缓冲流,将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。

 构造方法:
    // 创建一个使用默认大小输出缓冲区的缓冲字符输出流
    BufferedWriter(Writer out)
    // 创建一个使用给定大小输出缓冲区的新缓冲字符输出流
    BufferedWriter(Writer out, int sz)
 特有方法:
    // 写入一个行分隔符
    void newLine() 
(4)FileReader、FileWriter

 FileReader:InputStreamReader类的直接子类,用来读取字符文件的便捷类,使用默认字符编码。
 FileWriter:OutputStreamWriter类的直接子类,用来写入字符文件的便捷类,使用默认字符编码
5.高效流效率比对

读取f盘下的一个视频文件到项目中:文件大小29.5 MB

读取方式一:

       FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4");
        FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
        int len;
        // 开始时间
        long begin = System.currentTimeMillis();
        // 一次读取一个字节
        while ((len = inputStream.read()) != -1) {
            outputStream.write(len);
        }
        // 用时毫秒
        System.out.println(System.currentTimeMillis() - begin);// 213195
        //关闭流释放资源
        inputStream.close();
        outputStream.close();

读取方式二:

       FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4");
        FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
        int len;
        byte[] bs = new byte[1024];
        // 开始时间
        long begin = System.currentTimeMillis();
        // 一次读取一个字节数组
        while ((len = inputStream.read(bs)) != -1) {
            outputStream.write(bs, 0, len);
        }
        // 用时毫秒
        System.out.println(System.currentTimeMillis() - begin);// 281
        inputStream.close();
        outputStream.close();

读取方式三:

        FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4");
        BufferedInputStream bis = new BufferedInputStream(inputStream);
        FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
        BufferedOutputStream bos = new BufferedOutputStream(outputStream);
        int len;
        byte[] bs = new byte[1024];
        // 开始时间
        long begin = System.currentTimeMillis();
        while ((len = bis.read(bs)) != -1) {
            bos.write(bs, 0, len);
        }
        // 用时毫秒
        System.out.println(System.currentTimeMillis() - begin);// 78
        bis.close();
        bos.close();
注:由此可以看出高效缓冲流读写速度是非常快的,建议使用。

发布了284 篇原创文章 · 获赞 406 · 访问量 99万+
展开阅读全文

readUTF()使用报 java.io.EOFException异常

12-25

今天在编程的时候,用到了DataInPutStream类的readUTF()方法时报了个异常,查了好多资料也不能解决,求大神指点啊.高分悬赏. ``` package IO流; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class DataTest { /** * 数据输入输出流 * */ public static void main(String[] args) throws IOException { //向指定文件中写入数据 //打开文件输出流 FileOutputStream fos=new FileOutputStream("G://word.txt"); //将此输出流链接到指定基础输出流DataOutPutStream DataOutputStream dos=new DataOutputStream(fos); //写入数据: dos.writeBytes("我是大禹!");//用此方法写入的数据用记事本打开是乱码 dos.writeChars("我治水!");//用此方法写入的数据用记事本打开是乱码 dos.writeUTF("你智障吗?"); //关闭流 fos.close(); //从文件中读取数据 //首先打开文件输入流 FileInputStream fis=new FileInputStream("G://word.txt"); //将此输入流连接到基本数据输入流DataInPutStream DataInputStream dis=new DataInputStream(fis); //开始读取数据啦 // String s=dis.readUTF(); System.out.println(dis.readUTF()); dis.close(); } } ``` 异常信息: Exception in thread "main" java.io.EOFException at java.io.DataInputStream.readFully(DataInputStream.java:180) at java.io.DataInputStream.readUTF(DataInputStream.java:592) at java.io.DataInputStream.readUTF(DataInputStream.java:547) at IO流.DataTest.main(DataTest.java:35) 问答

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览