输入输出字节流，文件的读取和写入，文件的复制

Java流的分类

① 按流向分类

• 输出流：OutputStream 和 Writer 为基类。

• 输入流：InputStream 和 Reader 为基类。

② 根据传输数据单位分类

• 字节流：OutputStream 和 InputStream 为基类。

• 字符流：Writer 和 Reader 为基类。

一、输入输出字节流

1.1 概念：

字节输入输出流:每次只操作一个字节(读取或写入),字节操作流,默认每次执行写入操作会直接把数据写入文件.

io流:
输入流:Input;
输出流:Output

流的本质是数据传输,根据数据传输特性将流抽象为各种类,方便进行数据操作;

流是一种有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象,即数组在两台设备间传输为流;

io流的分类:
根据处理数据类型的不同分为:字符流和字节流;
根据数据流向不同分为:输入流和输出流;
字节是数据传输的基本单位,文件内容也是以字节为单位存储的,从文件中把数据读到程序为输入流,从程序把数据写到文件称为输出流,都是相对于程序;

字节输出流:

OutputStream:此为抽象类,所有输出字节流的超类,向文件中输出使用FileOutputStream类;

字节输入流:

InputStream:所有字节输入流的超类,向程序输入使用FileInputStream;

1.2 OutputStream（字节输出流）

java.io.OutputStream 是所有字节输出流的超类。需要该类的子类必须实现向输出流写入一个字节的方法

常用方法
abstract void write(int b)

向输出流中写入一个字节。该方法是一个抽象方法，要求子类必须实现此方法。

 void write(byte b[])

向输出流中写入多个字节。该方法将缓存区 b 中的字节写入到输出流中。

 void write(byte b[], int off, int len)

向输出流中写入多个字节，从缓存区 b 的 off 下标处开始写入 len 个字节。

 void flush()

刷新该输出流，强制将缓存区中的字节写出去。

 void close()

关闭该输出流，并释放与之相关的所有资源。

1.3InputStream（字节输入流）

java.io.InputStream 是所有字节输入流的超类。需要该类的子类必须实现读取下一个字节的方法。

常用方法

abstract int read()

该方法从输入流读取数据的下一个字节。将读取的字节以 int 型返回，如果读取至末尾，则返回值 -1 。另外，该方法是一个抽象方法，要求子类必须实现此方法。

 int read(byte b[])

从输入流中读取多个字节，并将它们存储至缓冲区 b 中。读取的字节数最多等于 b 的长度，也可以读取比 b 长度小的字节数。返回值为实际读取的字节数，如果没有可读取的字节，则返回值 -1。

int read(byte b[], int off, int len)

从输入流中读取 len 个字节，并从缓存区 b 的 off 下标处开始存储（即读取的第一个字节存入缓 b[off] 中，下一个字节存入 b[off + 1] 中…）。同样返回值为实际读取的字节数，如果没有可读取的字节，则返回值 -1。

 int available()

返回该输入流中可读取的有效字节数。

 void close()

关闭该输入流，并释放与之相关的所有系统资源。

例题：假设有一个D:\my\HelloJava.java 文件，下面使用 FileInputStream 类读取并输出该文件的内容。代码如下：

public class Test1 {
public static void main(String[] args) {
File f = new File("D:/my/HelloJava.java");
FileInputStream fis = null;
try {
// 因为File没有读写的能力,所以需要有个InputStream
fis = new FileInputStream(f);
// 定义一个字节数组
byte[] bytes = new byte[1024];
int n = 0; // 得到实际读取到的字节数
System.out.println("D:\\my\\HelloJava.java文件内容如下：");
// 循环读取
while ((n = fis.read(bytes)) != -1) {
String s = new String(bytes, 0, n); // 将数组中从下标0到n的内容给s
System.out.println(s);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
 
​
注意：FileInputStream 类重写了父类 InputStream 中的 read() 方法、skip() 方法、available() 方法和 close() 方法，不支持 mark() 方法和 reset() 方法。

2.6复制原理截图


 案例实现
package Java2;
 
import java.io.*;
 
public class CopyFileTest1 {
    public static void main(String[] args) throws IOException {
        //1.定义源文件和目的文件的文件对象
        File f1=new File("D:/a.jpg");
        File newFile=new File("D:/aa/copy.jpg");
 
        //2.创建目的文件
        newFile.createNewFile();
 
        //3.定义输入输出流：使用输入流读取内容 使用输出流写入内容
        InputStream in=new FileInputStream(f1);
        OutputStream out=new FileOutputStream(newFile);
 
        //练习是容易理解的方式
        byte[] buffe=new byte[10];
        int n=0;
        while (true){
            n=in.read(buffe);//读取文件，内容放入buffer数组中，返回的是实际读取的字节数
            if (n!=-1){
                out.write(buffe,0,n);//把buffer数组从0开始，截取读取到有效字节数n 写入到目的文件中
            }else {
                break;
            }
        }
    }
}

二、 文件的读取和写入

例题：使用字符流完成文件的读写操作

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
 
/**
* 使用字符流完成文件的读写操作
*/
public class WriterAndReader {
 
    public static void main(String[] args) {
        out();
        in();
    }
 
    // 从文件读取数据
    private static void in() {
        File file = new File("F:/test.txt");
        try {
            Reader in = new FileReader(file);
 
            // 因为使用了处理过的字符流，所以缓冲数组cs的大小随意，都不会导致多读
            char[] cs = new char[3];
            int len = -1;
            StringBuilder sb = new StringBuilder();
            while ((len = in.read(cs)) != -1) {
                sb.append(new String(cs, 0, len));
            }
            in.close();
            System.out.println(sb);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }
 
    // 将数据写入到文件
    private static void out() {
        File file = new File("F:/test.txt");
        try {
            Writer out = new FileWriter(file, true);
            out.write("我爱Java");
            out.flush();
            out.close();
            System.out.println("数据写入成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
}

三、文件的复制

3.1Java复制文件 (Java Copy File)

这是Java中文件复制的常规方式。 在这里，我们创建两个文件-源文件和目标文件。 然后，我们从源创建InputStream并使用OutputStream进行java复制文件操作，将其写入目标文件。

例题：

package Java2;
 
import java.io.*;
 
public class CopyFileTest1 {
    public static void main(String[] args) throws IOException {
        //1.定义源文件和目的文件的文件对象
        File f1=new File("D:/a.jpg");
        File newFile=new File("D:/aa/copy.jpg");
 
        //2.创建目的文件
        newFile.createNewFile();
 
        //3.定义输入输出流：使用输入流读取内容 使用输出流写入内容
        InputStream in=new FileInputStream(f1);
        OutputStream out=new FileOutputStream(newFile);
 
        //练习是容易理解的方式
        byte[] buffe=new byte[10];
        int n=0;
        while (true){
            n=in.read(buffe);//读取文件，内容放入buffer数组中，返回的是实际读取的字节数
            if (n!=-1){
                out.write(buffe,0,n);//把buffer数组从0开始，截取读取到有效字节数n 写入到目的文件中
            }else {
                break;
            }
        }
    }
}