IO流——字节流

一、字节输出流 OutputStream

OutputStream为抽象类，是表示输出字节流的所有类的超类。操作的数据都是字节，定义了输出字节流的基本共性方法。

1、方法：

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

2、FileOutputStream类

OutputStream 有很多子类，其中子类 FileOutputStream 可用来将数据写入到文件中。
FileOutputStream 类，即文件输出流，是用于将数据写入到 File 的输出流。

 

FileOutputStream 类的构造方法：

FileOutputStream(File file)：创建一个向指定File对象表示的文件中写入数据的文件输出流

FileOutputStream(String name)：创建一个向具有指定名称的文件中写入数据的文件输出流

2.1 FileOutputStream类写入数据到文件中

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

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

public class FileOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("F:\123.txt");
        byte[] b = "hello".getBytes();
        fos.write(b);
        fos.close();
    }
}

2.2 文件续写和换行

直接new FileOutputStream(file)这样创建对象，写入数据，会覆盖原有的文件。
如何想要实现文件续写，则需使用FileOutputStream(File file, boolean append)或者FileOutputStream(File file, boolean append)这两种构造方法。当append值为true时，就会在文件末尾继续添加。

 

构造方法：
FileOutputStream(File file, boolean append)：创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutputStream(File file, boolean append)：创建一个向具有指定名称的文件中写入数据的文件输出流

 

代码：

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

public class FileOutputStreamDemo {

    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("F:\123.txt", true);
        byte[] b = "hello".getBytes();
        fos.write(b);
        fos.close();
    }
}

执行上面的代码两次，会在123.txt文件中产生“hellohello”数据。

换行：直接在需要换行的地方加“ ”即可，例如，如果上面的代码需要实现换行功能，可在“hello”后面添加“ ”，即“hello ”。

 

二、字节输入流InputStream

InputStream是字节输入流的所有类的超类，定义了字节输入流的基本共性功能方法。

abstract int	read() 这个方法将读入一个字节，并返回读入的字节，或者在遇到输入源结尾时返回-1.
int	read(byte[] b) 读入一个字节数组，并返回实际读入的字节数，或者在碰到输入流的结尾时返回-1.这个read方法最多读入b.length个字节。

 

 

 

1.FileInputStream类

FileInputStream是InputStream的一个子类，可用来读取文件内容。
FileInputStream从文件系统中的某个文件中获得输入字节。

1.1 构造方法

FileInputStream(File file)	通过打开与File类对象代表的实际文件的链接来创建FileInputStream流对象
FileInputStream(String name)	通过指定的字符串参数来创建File类对象，而后再与File对象所代表的实际路径建立链接创建FileInputStream流对象

 

 

构造函数 FileInputStream(String name) 的源码：

public FileInputStream(String name) throws FileNotFoundException {
        this(name != null ? new File(name) : null);
    }

1.2 read()方法

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

public class FileInputStreamDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("F:\123.txt");
        FileInputStream fis = new FileInputStream(file);
        int ch = 0;
        while((ch = fis.read()) != -1){
            System.out.println((char)ch);
        }
        fis.close();
    }
}

 

1.3 read(byte[] b)方法

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

public class FileInputStreamDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("F:\123.txt");
        FileInputStream fis = new FileInputStream(file);
        byte[] b = new byte[1024];
        int ch = 0;
        while((ch = fis.read(b)) != -1){
            System.out.println(new String(b, 0, ch));
        }
        fis.close();
    }

}
 

 

练习

 

1.复制文件

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

public class Copy {
    
    public static void main(String[] args){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("F:\123.txt");
            fos = new FileOutputStream("D:\abc.txt");
            byte[] buf = new byte[1024];
            int len = 0;
            while((len = fis.read(buf)) != -1){
                fos.write(buf,0,len);
            }
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fos != null){

                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }

}