字节流输入输出问题图解

及向文件中写数据为输出，从文件中读取数据为输入

字节输出流：OutputStream

• FileOutputStream
• 写入数据文件，学习父类方法，使用子类对象
• 子类中的构造方法：作用：绑定输出的输出目的
• 参数：
• File 封装一个文件
• String 字符串的文件名

流对象使用步骤

1. 创建流的子类的对象，绑定数据目的
2. 调用流对象的方法write写
3. close释放资源

流对象的构造方法，可以创建文件,如果文件已经存在，直接覆盖

代码：

package cn.hiluna.demo;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 *  FileOutputStream
 *  写入数据文件，学习父类方法，使用子类对象
 * 
 *  子类中的构造方法：作用：绑定输出的输出目的
 *      参数：
 *          File    封装一个文件
 *          String  字符串的文件名
 * 
 *  流对象使用步骤
 *      1.创建流的子类的对象，绑定数据目的
 *      2.调用流对象的方法write写
 *      3.close释放资源
 * 
 *  流对象的构造方法，可以创建文件,如果文件已经存在，直接覆盖
 * @author zhang
 */
public class FileOutputStreamDemo {
    public static void main(String[] args)throws IOException{
        FileOutputStream fos = new FileOutputStream("e:\\a.txt");
        //流对象的方法write
        //写1个字节
        fos.write(100);

        //写字节数组
        byte[] bytes = {65,66,67,68};
        fos.write(bytes);

        //写字节数组的一部分,开始的索引，写几个
        fos.write(bytes,1,2);

        //写入字节数组的简便方式
        //写字符串
        fos.write("hello".getBytes());

        //关闭资源
        fos.close();
    }
}

创建的文件截图：

异常处理

package cn.hiluna.demo;

import java.io.FileOutputStream;
import java.io.IOException;

/**
 *  IO流的异常处理
 *  try catch finally
 * 
 *  细节：
 *      1.保证流对象变量，作用域足够
 *      2.catch里面，怎么处理：
 *          输出异常信息，看哪里出现问题
 *          停下程序，重新尝试
 *      3.如果流对象建立失败了，需要关闭资源吗？
 *          new 对象的时候，失败了，没有占用系统资源
 *          释放资源的时候，需要对流对象判断null
 * @author zhang
 */
public class FileOutputStreamDemo02 {
    public static void main(String[] args) {
        //try 外面声明变量，try的里面建立对象
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("e:\\a.txt");
            fos.write(100);
        } catch (IOException ex) {
            ex.printStackTrace();
            throw new RuntimeException("文件写入失败，重试");
        }finally{
            try {
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException ex) {
                throw new RuntimeException("关闭资源失败");
            }
        }

    }
}

读取

read带有String为参数的读取方法

package cn.hiluna.demo;

/**
 * 字节输入流
 *  java.io.InputStream 所有字节输入流的超类
 * 作用：读取任意文件，每次只读取一个字节
 *
 * 读取的方法  read
 *      返回值：int  read() 读取一个字节
 *      返回值：int  read(byte[] b) 读取一定量的字节，存储到数组中
 */

import java.io.FileInputStream;
import java.io.IOException;

/**
 * FileInputStream读取文件
 *
 * 构造方法：为这个流对象绑定数据源
 *
 *  参数：
 *      File 类型对象
 *      String 类型对象
 *  输入流读取文件的步骤：
 *      1.创建字节输入流的子类的对象
 *      2.调用读取方法read读取
 *      3.关闭流
 *
 *      read()方法，
 *          read()执行一次，就会自动读取下一个字节
 *          返回值，返回的是读取到的字节，读取到文件结尾返回-1
 */
public class Input {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("e:\\a.txt");
        //读取一个字节，调用方法read 返回int
        //使用循环方式，读取文件， 循环结束的条件  read()方法返回-1 结束
        int len = 0;//接受一些read方法返回值

        while ((len = fileInputStream.read()) != -1){
            System.out.print((char)len);
        }


        //关闭资源
        fileInputStream.close();
    }
}

read带有数组为参数的读取方法

package cn.hiluna.demo;

import java.io.FileInputStream;
import java.io.IOException;


/**
 * FileInputStream读取文件
 *  读取方法int read(byte[] b) 读取字节数组
 *  数组作用：起到缓冲作用，提高效率
 *  read返回的int，表示读取多少个有效的字节数
 */
public class Input02 {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("e:\\a.txt");
        //创建一个字节数组
        byte[] b = new byte[1024];

        int len = 0;
        while ((len = fileInputStream.read(b)) != -1){
            System.out.println(new String(b,0,len));
        }

//        int len = fileInputStream.read(b);
//        System.out.println(new String(b));//ab
//        System.out.println(len);//2
//
//        len = fileInputStream.read(b);
//        System.out.println(new String(b));//cd
//        System.out.println(len);//2
//
//        len = fileInputStream.read(b);
//        System.out.println(new String(b));//ed
//        System.out.println(len);//1
//
//        len = fileInputStream.read(b);
//        System.out.println(new String(b));//ed
//        System.out.println(len);//1

        fileInputStream.close();
    }
}