IO流

来源：互联网发布：vnr更新数据库失败编辑：程序博客网时间：2024/06/04 08:27

IO流分类

  IO流的分类：        流向：            输入流 读取数据            输出流 写出数据        数据类型：            字节流                字节输入流   读取数据    InputStream                字节输出流   写出数据    OutputStream            字符流                字符输入流   读取数据    Reader                字符输出流   写出数据    Writer        注意：一般我们在探讨IO流的时候，如果没有明确说明按哪种分类来说，默认情况下是按照数据类型来分的。

FileOutputStream

方法

  public void write(int b):写一个字节  public void write(byte[] b):写一个字节数组  public void write(byte[] b,int off,int len):写一个字节数组的一部分

例

  需求：我要往一个文本文件中输入一句话："hello,io"  分析：        A:这个操作最好是采用字符流来做，但是呢，字符流是在字节流之后才出现的，所以，今天我先讲解字节流如何操作。        B:由于我是要往文件中写一句话，所以我们要采用字节输出流。  通过上面的分析后我们知道要使用：OutputStream  但是通过查看API，我们发现该流对象是一个抽象类，不能实例化。  所以，我们要找一个具体的子类。  而我们要找的子类是什么名字的呢?这个时候，很简单，我们回想一下，我们是不是要往文件中写东西。  文件是哪个单词：File  然后用的是字节输出流，联起来就是：FileOutputStream  注意：每种基类的子类都是以父类名作为后缀名。        XxxOutputStream        XxxInputStream        XxxReader        XxxWriter  查看FileOutputStream的构造方法：        FileOutputStream(File file)         FileOutputStream(String name)  字节输出流操作步骤：        A:创建字节输出流对象        B:写数据        C:释放资源

package cn.itcast_01;import java.io.File;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;public class FileOutputStreamDemo {    public static void main(String[] args) throws IOException {        // 创建字节输出流对象        // FileOutputStream(File file)        // File file = new File("fos.txt");        // FileOutputStream fos = new FileOutputStream(file);        // FileOutputStream(String name)        FileOutputStream fos = new FileOutputStream("fos.txt");        /*         * 创建字节输出流对象了做了几件事情：         * A:调用系统功能去创建文件         * B:创建fos对象         * C:把fos对象指向这个文件         */        //写数据        fos.write("hello,IO".getBytes());        fos.write("java".getBytes());        //释放资源        //关闭此文件输出流并释放与此流有关的所有系统资源。        fos.close();        /*         * 为什么一定要close()呢?         * A:让流对象变成垃圾，这样就可以被垃圾回收器回收了         * B:通知系统去释放跟该文件相关的资源         */        //java.io.IOException: Stream Closed        //fos.write("java".getBytes());    }}

几个常见问题

 1. 创建字节输出流对象了做了几件事情：          A:调用系统功能去创建文件          B:创建fos对象          C:把fos对象指向这个文件 2. 为什么一定要close()呢?          A:让流对象变成垃圾，这样就可以被垃圾回收器回收了          B:通知系统去释放跟该文件相关的资源             * 如何实现数据的换行? 3. 为什么现在没有换行呢?因为你值写了字节数据，并没有写入换行符号。        如何实现呢?写入换行符号即可呗。        刚才我们看到了有写文本文件打开是可以的，通过windows自带的那个不行，为什么呢?        因为不同的系统针对不同的换行符号识别是不一样的?        windows:\r\n        linux:\n        Mac:\r        而一些常见的个高级记事本，是可以识别任意换行符号的。  4. 如何实现数据的追加写入?        用构造方法带第二个参数是true的情况即可

public class FileOutputStreamDemo3 {    public static void main(String[] args) throws IOException {        // 创建字节输出流对象        // FileOutputStream fos = new FileOutputStream("fos3.txt");        // 创建一个向具有指定 name 的文件中写入数据的输出文件流。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。        FileOutputStream fos = new FileOutputStream("fos3.txt", true);        // 写数据        for (int x = 0; x < 10; x++) {            fos.write(("hello" + x).getBytes());            fos.write("\r\n".getBytes());        }        // 释放资源        fos.close();    }}

加入异常处理的字节输出流操作

package cn.itcast_01;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;public class FileOutputStreamDemo4 {    public static void main(String[] args) {        // 分开做异常处理        // FileOutputStream fos = null;        // try {        // fos = new FileOutputStream("fos4.txt");        // } catch (FileNotFoundException e) {        // e.printStackTrace();        // }        //        // try {        // fos.write("java".getBytes());        // } catch (IOException e) {        // e.printStackTrace();        // }        //        // try {        // fos.close();        // } catch (IOException e) {        // e.printStackTrace();        // }        // 一起做异常处理        // try {        // FileOutputStream fos = new FileOutputStream("fos4.txt");        // fos.write("java".getBytes());        // fos.close();        // } catch (FileNotFoundException e) {        // e.printStackTrace();        // } catch (IOException e) {        // e.printStackTrace();        // }        // 改进版        // 为了在finally里面能够看到该对象就必须定义到外面，为了访问不出问题，还必须给初始化值        FileOutputStream fos = null;        try {            // fos = new FileOutputStream("z:\\fos4.txt");            fos = new FileOutputStream("fos4.txt");            fos.write("java".getBytes());        } catch (FileNotFoundException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        } finally {            // 如果fos不是null，才需要close()            if (fos != null) {                // 为了保证close()一定会执行，就放到这里了                try {                    fos.close();                } catch (IOException e) {                    e.printStackTrace();                }            }        }    }}

FileInputStream

  字节输入流操作步骤：  A:创建字节输入流对象  B:调用read()方法读取数据，并把数据显示在控制台  C:释放资源  读取数据的方式：  A:int read():一次读取一个字节  B:int read(byte[] b):一次读取一个字节数组

/*int read():一次读取一个字节*/package cn.itcast_02;import java.io.FileInputStream;import java.io.IOException;public class FileInputStreamDemo {    public static void main(String[] args) throws IOException {        // FileInputStream(String name)        // FileInputStream fis = new FileInputStream("fis.txt");        FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");        // // 调用read()方法读取数据，并把数据显示在控制台        // // 第一次读取        // int by = fis.read();        // System.out.println(by);        // System.out.println((char) by);        //        // // 第二次读取        // by = fis.read();        // System.out.println(by);        // System.out.println((char) by);        //        // // 第三次读取        // by = fis.read();        // System.out.println(by);        // System.out.println((char) by);        // // 我们发现代码的重复度很高，所以我们要用循环改进        // // 而用循环，最麻烦的事情是如何控制循环判断条件呢?        // // 第四次读取        // by = fis.read();        // System.out.println(by);        // // 第五次读取        // by = fis.read();        // System.out.println(by);        // //通过测试，我们知道如果你读取的数据是-1，就说明已经读取到文件的末尾了        // 用循环改进        // int by = fis.read();        // while (by != -1) {        // System.out.print((char) by);        // by = fis.read();        // }        // 最终版代码        int by = 0;        // 读取，赋值，判断        while ((by = fis.read()) != -1) {            System.out.print((char) by);        }        // 释放资源        fis.close();    }}

package cn.itcast_02;import java.io.FileInputStream;import java.io.IOException;/* * 一次读取一个字节数组：int read(byte[] b) * 返回值其实是实际读取的字节个数。 */public class FileInputStreamDemo2 {    public static void main(String[] args) throws IOException {        // 创建字节输入流对象        // FileInputStream fis = new FileInputStream("fis2.txt");        FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");        // 读取数据        // 定义一个字节数组        // 第一次读取        // byte[] bys = new byte[5];        // int len = fis.read(bys);        // // System.out.println(len);        // // System.out.println(new String(bys));        // // System.out.println(new String(bys, 0, len));        // System.out.print(new String(bys, 0, len));        //        // // 第二次读取        // len = fis.read(bys);        // // System.out.println(len);        // // System.out.println(new String(bys));        // // System.out.println(new String(bys, 0, len));        // System.out.print(new String(bys, 0, len));        //        // // 第三次读取        // len = fis.read(bys);        // // System.out.println(len);        // // System.out.println(new String(bys));        // // System.out.println(new String(bys, 0, len));        // System.out.print(new String(bys, 0, len));        //        // // 第四次读取        // len = fis.read(bys);        // // System.out.println(len);        // // System.out.println(new String(bys, 0, len));        // System.out.print(new String(bys, 0, len));        // // 代码重复了，用循环改进        // // 但是，我不知道结束条件        // // len = fis.read(bys);        // // System.out.println(len);        // // len = fis.read(bys);        // // System.out.println(len);        // // 如果读取到的实际长度是-1，就说明没有数据了        // byte[] bys = new byte[115]; // 0        // int len = 0;        // while ((len = fis.read(bys)) != -1) {        // System.out.print(new String(bys, 0, len));        // // System.out.print(new String(bys)); //千万要带上len的使用        // }        // 最终版代码        // 数组的长度一般是1024或者1024的整数倍        byte[] bys = new byte[1024];        int len = 0;        while ((len = fis.read(bys)) != -1) {            System.out.print(new String(bys, 0, len));        }        // 释放资源        fis.close();    }}

这里写图片描述

练习题

  需求：把e:\\林青霞.jpg内容复制到当前项目目录下的mn.jpg中  数据源：        e:\\林青霞.jpg --读取数据--FileInputStream  目的地：        mn.jpg--写出数据--FileOutputStream

package cn.itcast_03;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;public class CopyImageDemo {    public static void main(String[] args) throws IOException {        // 封装数据源        FileInputStream fis = new FileInputStream("e:\\林青霞.jpg");        // 封装目的地        FileOutputStream fos = new FileOutputStream("mn.jpg");        // 复制数据        int by = 0;        while ((by = fis.read()) != -1) {            fos.write(by);        }        // 释放资源        fos.close();        fis.close();    }}

字节缓冲区流

  通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的。  既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。  这种类被称为：缓冲区类(高效类)      写数据：BufferedOutputStream              构造方法：                 public BufferedOutputStream(OutputStream out)                 public BufferedOutputStream(OutputStream out,int size)      读数据：BufferedInputStream              构造方法：                 public BufferedInputStream(InputStream in)                  public BufferedInputStream(InputStream in,int size)  构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。  为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?  原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。

package cn.itcast_05;import java.io.BufferedOutputStream;import java.io.FileOutputStream;import java.io.IOException;public class BufferedOutputStreamDemo {    public static void main(String[] args) throws IOException {        // BufferedOutputStream(OutputStream out)        // FileOutputStream fos = new FileOutputStream("bos.txt");        // BufferedOutputStream bos = new BufferedOutputStream(fos);        // 简单写法        BufferedOutputStream bos = new BufferedOutputStream(                new FileOutputStream("bos.txt"));        // 写数据        bos.write("hello".getBytes());        // 释放资源        bos.close();    }}

package cn.itcast_05;import java.io.BufferedInputStream;import java.io.FileInputStream;import java.io.IOException;/* * 注意：虽然我们有两种方式可以读取，但是，请注意，这两种方式针对同一个对象在一个代码中只能使用一个。 */public class BufferedInputStreamDemo {    public static void main(String[] args) throws IOException {        // BufferedInputStream(InputStream in)        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(                "bos.txt"));        // 读取数据        // int by = 0;        // while ((by = bis.read()) != -1) {        // System.out.print((char) by);        // }        // System.out.println("---------");        byte[] bys = new byte[1024];        int len = 0;        while ((len = bis.read(bys)) != -1) {            System.out.print(new String(bys, 0, len));        }        // 释放资源        bis.close();    }}

0 0