字节输出、输入流 OutputStream、 InputStream

@

目录

• 字节输出流 OutputStream
  • 结合异常处理的 IO流写法
• 字节输入流 InputStream
  • int read(byte[] b)
  • 字节输入流 + 字节输出流、拷贝文件

字节输出流 OutputStream

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) 写一个字节

    OutputStream os = new FileOutputStream("hello.txt");
    os.write("good".getBytes());
    byte[] bys = {97,98,99,100};
    os.write(bys, 1, 2);
    os.write(100);
    os.flush();
    os.close();

// 输出结果 hellowordbcd

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

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

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

FileOutputStream(String name, boolean append)
创建一个向具有指定 name 的文件中写入数据的输出文件流。

结合异常处理的 IO流写法

    System.out.println("Start");
    try (OutputStream os = new FileOutputStream("Test.txt");
        Scanner input = new Scanner(System.in);
            ){
        os.write("HelloWorld".getBytes());
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("End");

字节输入流 InputStream

方法摘要

int available()
返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数。
void close()
关闭此输入流并释放与该流关联的所有系统资源。
void mark(int readlimit)
在此输入流中标记当前的位置。
boolean markSupported()
测试此输入流是否支持 mark 和 reset 方法。
abstract int read()
从输入流中读取数据的下一个字节。

  **特点:** 
  	1.表示一次性读取一个字节
  	2.每读取一个字节,那么返回的实际读取的内容
  	3.读取一个字节完毕,会自动等待读取下一个字节,类似迭代器的 cursor
  	4.读取到文件末尾返回 -1

int read(byte[] b)
从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
int read(byte[] b, int off, int len)
将输入流中最多 len 个数据字节读入 byte 数组。
void reset()
将此流重新定位到最后一次对此输入流调用 mark 方法时的位置。
long skip(long n)
跳过和丢弃此输入流中数据的 n 个字节。

​ 文件 -> 内存 输入流 FileInputStream
​ 内存 -> 文件 输出流 PrintStream

注意:
​ 1.输出流如果文件不存在会自动创建,但是输入流文件必须存在,否则会抛出 FileNotFoundException
​ 2.一次读取一个字节 ,如果中间认为对每个字节做了强制类型转换,可能会导致乱码

int read(byte[] b)

1.一次性从外界读取一个字节数组的内容

2.每读取一次,返回实际读取的长度

3.读取到文件末尾返回 -1

4.每读取一次,指针向后移动一个字节数组的单位

注意:

虽然扩大了每次读取的范围,但是乱码现象依然存在,所以字节流读取一个字节或者字节数组,但是GBK或者UTF-8编码表中一个中文占 2个或者3个字节,肯定有可能乱码,所以还是不推荐字节流处理中文。

    InputStream is = new FileInputStream("d:\test.txt");
    byte[] bys = new byte[1024];
    int len = 0;
    while ((len = is.read(bys)) != -1) {
        System.out.print(new String(new String(bys, 0, len)));
    }

字节输入流 + 字节输出流、拷贝文件

test.java --> test.txt

数据源: test.java

目的地: test.txt

流向:

文件 -> 内存 FileInputStream

内存 -> 文件 FileOutputStream

拷贝方式:

1.一次性拷贝一个字节

2.一次性拷贝一个字节数组

1.一次性拷贝一个字节

/*
 * 功能: 一次性拷贝一个字节拷贝文件
 * 返回值类型 : void
 * 参数列表: String srcFileName, String descFileName
 * 方法名: copy
 */
public static void copy(String srcFileName, String descFileName) {
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        fis = new FileInputStream(srcFileName);
        fos = new FileOutputStream(descFileName);

        int by = 0;
        while ((by = fis.read()) != -1) {
            fos.write(by);
            fos.flush();
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } 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();
            }
        }
    }

}

2.一次性拷贝一个字节数组

/*
 * 功能: 一次性拷贝一个字节数组拷贝文件
 * 返回值类型 : void
 * 参数列表: File srcFile, File descFile
 * 方法名: copy
 */
public static void copy(File srcFile, File descFile, int capacity) {
    try (FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(descFile);) {
        byte[] bys = new byte[capacity];
        int len = 0;

        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
            fos.flush();
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    } 
}