Java学习17(IO流)

Posted Zephyr丶J

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java学习17(IO流)相关的知识,希望对你有一定的参考价值。

Java学习17

放假真是放假,放的不知所以了

IO流

IO流,什么是IO?
    I : Input
    O : Output
    通过IO可以完成硬盘文件的读和写。

IO流的分类?

    有多种分类方式:

	一种方式是按照流的方向进行分类:
		以内存作为参照物,
			往内存中去,叫做输入(Input)。或者叫做读(Read)。
			从内存中出来,叫做输出(Output)。或者叫做写(Write)。

	另一种方式是按照读取数据方式不同进行分类:
		有的流是按照字节的方式读取数据,一次读取1个字节byte,等同于一次读取8个二进制位。
		这种流是万能的,什么类型的文件都可以读取。包括:文本文件,图片,声音文件,视频文件等....
			假设文件file1.txt,采用字节流的话是这样读的:
				a中国bc张三fe
				第一次读:一个字节,正好读到'a'
				第二次读:一个字节,正好读到'中'字符的一半。
				第三次读:一个字节,正好读到'中'字符的另外一半。

		有的流是按照字符的方式读取数据的,一次读取一个字符,这种流是为了方便读取普通文本文件而存在的,
		这种流不能读取:图片、声音、视频等文件。只能读取纯文本文件,连word文件都无法读取。
			假设文件file1.txt,采用字符流的话是这样读的:
				a中国bc张三fe
				第一次读:'a'字符('a'字符在windows系统中占用1个字节。)
				第二次读:'中'字符('中'字符在windows系统中占用2个字节。)

综上所述:流的分类
	输入流、输出流
	字节流、字符流

Java中的IO流都已经写好了,我们程序员不需要关心,我们最主要还是掌握,在java中已经提供了哪些流,每个流的特点是什么,每个流对象上的常用方法有哪些????
    java中所有的流都是在:java.io.*;下。

    java中主要还是研究:
	    怎么new流对象。
	    调用流对象的哪个方法是读,哪个方法是写。

java IO流这块有四大家族:
    四大家族的首领:
	    java.io.InputStream  字节输入流
	    java.io.OutputStream 字节输出流

        java.io.Reader		字符输入流
        java.io.Writer		字符输出流

        四大家族的首领都是抽象类。(abstract class)

	所有的流都实现了:
		java.io.Closeable接口,都是可关闭的,都有close()方法。
		流毕竟是一个管道,这个是内存和硬盘之间的通道,用完之后一定要关闭,
		不然会耗费(占用)很多资源。养成好习惯,用完流一定要关闭。

	所有的输出流都实现了:
		java.io.Flushable接口,都是可刷新的,都有flush()方法。
		养成一个好习惯,输出流在最终输出之后,一定要记得flush()
		刷新一下。这个刷新表示将通道/管道当中剩余未输出的数据
		强行输出完(清空管道!)刷新的作用就是清空管道。
		注意:如果没有flush()可能会导致丢失数据。


注意:在java中只要“类名”以Stream结尾的都是字节流。以“Reader/Writer”结尾的都是字符流。

java.io包下需要掌握的流有16个:

    文件专属:
        java.io.FileInputStream(掌握)
        java.io.FileOutputStream(掌握)
        java.io.FileReader
        java.io.FileWriter

    转换流:(将字节流转换成字符流)
        java.io.InputStreamReader
        java.io.OutputStreamWriter

    缓冲流专属:
        java.io.BufferedReader
        java.io.BufferedWriter
        java.io.BufferedInputStream
        java.io.BufferedOutputStream

    数据流专属:
        java.io.DataInputStream
        java.io.DataOutputStream

    标准输出流:
        java.io.PrintWriter
        java.io.PrintStream(掌握)

    对象专属流:
        java.io.ObjectInputStream(掌握)
        java.io.ObjectOutputStream(掌握)

FileInputStream(掌握)

一般在finally语句块中对流进行关闭
read() 方法返回值是:读取到的“字节”本身,读到文件末尾,返回-1

int read(byte[] b)    一次最多读取 b.length 个字节。    
    减少硬盘和内存的交互,提高程序的执行效率。往byte[]数组当中读。
    该方法的返回值是读取到的字节数,一个字节也没有读到返回-1

int available():返回流当中剩余的没有读到的字节数量
long skip(long n):跳过几个字节不读。

注意:char在java中是两个字节,'a'在java中占两个字节,但windows操作系统中占用一个字节
		FileInputStream fis = null;
        try {
        	//绝对路径
            fis = new FileInputStream("D:\\\\course\\\\JavaProjects\\\\02-JavaSE\\\\temp");

            /*while(true) {
                int readData = fis.read();
                if(readData == -1) {
                    break;
                }
                System.out.println(readData);
            }*/

            // 改造while循环
            int readData = 0;
            while((readData = fis.read()) != -1){
                System.out.println(readData);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        	// 在finally语句块当中确保流一定关闭。
            if (fis != null) {
            // 关闭流的前提是:流不是空。流是null的时候没必要关闭。
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
		FileInputStream fis = null;
        try {
            // 相对路径的话呢?相对路径一定是从当前所在的位置作为起点开始找!
            // IDEA默认的当前路径是哪里?工程Project的根就是IDEA的默认当前路径。
            //fis = new FileInputStream("tempfile3");
            //fis = new FileInputStream("chapter23/tempfile2");
            //fis = new FileInputStream("chapter23/src/tempfile3");
            fis = new FileInputStream("chapter23/src/com/bjpowernode/java/io/tempfile4");

            // 开始读,采用byte数组,一次读取多个字节。最多读取“数组.length”个字节。
            byte[] bytes = new byte[4]; // 准备一个4个长度的byte数组,一次最多读取4个字节。
            // 这个方法的返回值是:读取到的字节数量。(不是字节本身)
            int readCount = fis.read(bytes);
            System.out.println(readCount); // 第一次读到了4个字节。
            // 将字节数组全部转换成字符串
            //System.out.println(new String(bytes)); // abcd
            // 不应该全部都转换,应该是读取了多少个字节,转换多少个。
            System.out.println(new String(bytes,0, readCount));

            readCount = fis.read(bytes); // 第二次只能读取到2个字节。
            System.out.println(readCount); // 2
            // 将字节数组全部转换成字符串
            //System.out.println(new String(bytes)); // efcd
            // 不应该全部都转换,应该是读取了多少个字节,转换多少个。
            System.out.println(new String(bytes,0, readCount));

            readCount = fis.read(bytes); // 1个字节都没有读取到返回-1
            System.out.println(readCount); // -1

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
		FileInputStream fis = null;
        try {
            fis = new FileInputStream("tempfile");
            System.out.println("总字节数量:" + fis.available());
            // 读1个字节
            //int readByte = fis.read();
            // 还剩下可以读的字节数量是:5
            //System.out.println("剩下多少个字节没有读:" + fis.available());
            // 这个方法有什么用?
            //byte[] bytes = new byte[fis.available()]; // 这种方式不太适合太大的文件,因为byte[]数组不能太大。
            // 不需要循环了。
            // 直接读一次就行了。
            //int readCount = fis.read(bytes); // 6
            //System.out.println(new String(bytes)); // abcdef

            // skip跳过几个字节不读取,这个方法也可能以后会用!
            fis.skip(3);
            System.out.println(fis.read()); //100

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

FileOutputStream

文件字节输出流,负责写。从内存到硬盘。
写的文件不存在时,会在默认路径下自动新建
在创建对象时,如果没有append,则会将原文件清空再写入,需要给append赋值true,则会写到文件的末尾
		FileOutputStream fos = null;
        try {
            // myfile文件不存在的时候会自动新建!
            // 这种方式谨慎使用,这种方式会先将原文件清空,然后重新写入。
            //fos = new FileOutputStream("myfile");
            //fos = new FileOutputStream("chapter23/src/tempfile3");

            // 以追加的方式在文件末尾写入。不会清空原文件内容。
            fos = new FileOutputStream("chapter23/src/tempfile3", true);
            // 开始写。
            byte[] bytes = {97, 98, 99, 100};
            // 将byte数组全部写出!
            fos.write(bytes); // abcd
            // 将byte数组的一部分写出!
            fos.write(bytes, 0, 2); // 再写出ab

            // 字符串
            String s = "我是一个中国人,我骄傲!!!";
            // 将字符串转换成byte数组。
            byte[] bs = s.getBytes();
            // 写
            fos.write(bs);

            // 写完之后,最后一定要刷新
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

拷贝文件

使用FileInputStream + FileOutputStream完成文件的拷贝。
拷贝的过程应该是一边读,一边写。
使用以上的字节流拷贝文件的时候,文件类型随意,万能的。什么样的文件都能拷贝。

使用FileReader FileWriter进行拷贝的话,只能拷贝“普通文本”文件。
		FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            // 创建一个输入流对象
            fis = new FileInputStream("D:\\\\course\\\\02-JavaSE\\\\video\\\\chapter01\\\\动力节点-JavaSE-001-文件扩展名的显示.avi");
            // 创建一个输出流对象
            fos = new FileOutputStream("C:\\\\动力节点-JavaSE-001-文件扩展名的显示.avi");

            // 最核心的:一边读,一边写
            byte[] bytes = new byte[1024 * 1024]; // 1MB(一次最多拷贝1MB。)
            int readCount = 0;
            while((readCount = fis.read(bytes)) != -1) {
                fos.write(bytes, 0, readCount);
            }

            // 刷新,输出流最后要刷新
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 分开try,不要一起try。
            // 一起try的时候,其中一个出现异常,可能会影响到另一个流的关闭。
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
		FileReader in = null;
        FileWriter out = null;
        try {
            // 读
            in = new FileReader("chapter23/src/com/bjpowernode/java/io/Copy02.java");
            // 写
            out = new FileWriter("Copy02.java");

            // 一边读一边写:
            char[] chars = new char[1024 * 512]; // 1MB
            int readCount = 0;
            while((readCount = in.read(chars)) != -1){
                out.write(chars, 0, readCount);
            }

            // 刷新
            out.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

BufferedReader and BufferedWriter

BufferedReader: 带有缓冲区的字符输入流。   
BufferedWriter:带有缓冲的字符输出流。
使用这个流的时候不需要自定义char数组,或者说不需要自定义byte数组。自带缓冲。

BufferedReader br = new BufferedReader(reader);
当一个流的构造方法中需要一个流的时候,这个被传进来的流叫做:节点流。
外部负责包装的这个流,叫做:包装流,还有一个名字叫做:处理流。
像当前这个程序来说:FileReader就是一个节点流。BufferedReader就是包装流/处理流。

br.readLine()方法读取一个文本行,但不带换行符。

对于包装流来说,只需要关闭最外层流就行,里面的节点流会自动关闭。(可以看源代码。)
		FileReader reader = new FileReader("Copy02.java");
        // 当一个流的构造方法中需要一个流的时候,这个被传进来的流叫做:节点流。
        // 外部负责包装的这个流,叫做:包装流,还有一个名字叫做:处理流。
        // 像当前这个程序来说:FileReader就是一个节点流。BufferedReader就是包装流/处理流。
        BufferedReader br = new BufferedReader(reader);

        // 读一行
        /*String firstLine = br.readLine();
        System.out.println(firstLine);

        String secondLine = br.readLine();
        System.out.println(secondLine);

        String line3 = br.readLine();
        System.out.println(line3);*/

        // br.readLine()方法读取一个文本行,但不带换行符。
        String s = null;
        while((s = br.readLine()) != null){
            System.out.print(s);
        }

        // 关闭流
        // 对于包装流来说,只需要关闭最外层流就行,里面的节点流会自动关闭。(可以看源代码。)
        br.close();
		/*// 字节流
        FileInputStream in = new FileInputStream("Copy02.java");

        // 通过转换流转换(InputStreamReader将字节流转换成字符流。)
        // in是节点流。reader是包装流。
        InputStreamReader reader = new InputStreamReader(in);

        // 这个构造方法只能传一个字符流。不能传字节流。
        // reader是节点流。br是包装流。
        BufferedReader br = new BufferedReader(reader);*/

        // 合并
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("Copy02.java")));

        String line = null;
        while((line = br.readLine()) != null){
            System.out.println(line);
        }

        // 关闭最外层
        br.close();
		// 带有缓冲区的字符输出流
        //BufferedWriter out = new BufferedWriter(new FileWriter("copy"));

        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("copy", true)));
        // 开始写。
        out.write("hello world!");
        out.write("\\n");
        out.write("hello kitty!");
        // 刷新
        out.flush();
        // 关闭最外层
        out.close();

InputStreamReader and OutputStreamWriter

将字节流转换成字符流。

DataInputStream and DataOutputStream

java.io.DataOutputStream:数据专属的流。
这个流可以将数据连同数据的类型一并写入文件。
注意:这个文件不是普通文本文档。能用记事本编辑的都是普通文本文件(这个文件使用记事本打不开。)

DataOutputStream写的文件,只能使用DataInputStream去读。并且读的时候你需要提前知道写入的顺序。读的顺序需要和写的顺序一致。才可以正常取出数据
		// 创建数据专属的字节输出流
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data"));
        // 写数据
        byte b = 100;
        short s = 200;
        int i = 300;
        long l = 400L;
        float f = 3.0F;
        double d = 3.14;
        boolean sex = false;
        char c = 'a';
        // 写
        dos.writeByte(b); // 把数据以及数据的类型一并写入到文件当中。
        dos.writeShort(s);
        dos.writeInt(i);
        dos.writeLong(l);
        dos.writeFloat(f);
        dos.writeDouble(d);
        dos.writeBoolean(sex);
        dos.writeChar(c);

        // 刷新
        dos.flush();
        // 关闭最外层
        dos.close();

这时创建了一个名为data的文件

		DataInputStream dis = new DataInputStream(new FileInputStream("data"));
        // 开始读
        byte b = dis.readByte();
        short s = dis.readShort();
        int i = dis.readInt();
        long l = dis.readLong();
        float f = dis.readFloat();
        double d = dis.readDouble();
        boolean sex = dis.readBoolean();
        char c = dis.readChar();

        System.out.println(b);
        System.out.println(s);
        System.out.println(i + 1000);
        System.out.println(l);
        System.out.println(f);
        System.out.println(d);
        System.out.println(sex);
        System.out.println(c);

        dis.close();

标准输出流PrintStream

标准的字节输出流,默认输出到控制台
标准输出流不需要手动close()关闭。

可以改变标准输出流的输出方向:
    // 标准输出流不再指向控制台,指向“log”文件。
    PrintStream printStream = new PrintStream(new FileOutputStream("log"));
    // 修改输出方向,将输出方向修改到"log"文件。
    System.setOut(printStream);
		// 联合起来写
        System.out.printl

以上是关于Java学习17(IO流)的主要内容,如果未能解决你的问题,请参考以下文章

Java学习17(IO流)

Java基础17:Java IO流总结

2016年3月17日Android学习笔记

Java笔记(22):IO流(04)

Java IO流基础总结

Java-IO流学习