JAVA单排日记-2020/1/23-IO流-字节流

1.IO流概述

2.OutputStream字节输出流

OutputStream类为抽象类，无法直接使用，需要创造子类使用

2.1FileOutputStream文件字节输出流

1. 作用：把内存中的数据以字节的方式写入到硬盘的文件中
2. 构造方法：

作用：

• 创建一个FileOutputStream对象
• 根据构造方法中的文件/文件路径，创建一个空的文件
• 会把FileOutputStream对象指向创建好的空的文件

FileOutputStream(String name) 写入数据的目的地是一个文件的路径

FileOutputStream(File file)  写入数据的目的地是一个文件

• 字节输出流的使用步骤

1. 创建一个创建一个FileOutputStream对象，构造方法中填写写入数据的目的地

FileOutputStream fos01 = new FileOutputStream("G:\\Java\\测试文件夹\\a.txt");

2. 调用创建一个FileOutputStream对象的write方法，把数据写入到文件

fos01.write(12);

3. 释放资源

fos01.close();

• 一次写多个字节的方法

法一：写入整个字节数组

byte[] b = {97,98,99,100};
fos01.write(b);

如果第一个字节为正数(0-127)，那么显示的时候会查询ASCII码表
如果第一个字节为负数，那么第一个字节和第二个字节会组成一个中文，显示的时候会查询系统默认码表

法二：写入字节数组的一部分

byte[] b = {97,98,99,100,121};
fos01.write(byte[] b,int off,int leng); 写入字节数组b的从off开始，长度为leng的数据

package FileOutputStream;

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

public class Demo01 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos01 = new FileOutputStream("G:\\Java\\测试文件夹\\b.txt");
        byte[] b = {97,98,99,100,121};
        fos01.write(b);
        fos01.write(b,1,3);
        fos01.close();
    }
}

法三：

使用getBytes()方法，将字符串转换为字节数组

package FileOutputStream;

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

public class Demo02 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("G:\\Java\\测试文件夹\\c.txt");
        byte[] b = "你好".getBytes();
        fos.write(b);
        fos.close();
    }
}

• 数据的追加写（续写）和换行

• 续写
  构造方法中：

FileOutputStream(String name,boolean append) 写入数据的目的地是一个文件的路径,append为true则不会覆盖原文件,继续在原文件中续写,append为false则覆盖原文件

FileOutputStream(File file,boolean append)  写入数据的目的地是一个文件,append为true则不会覆盖原文件,继续在原文件中续写,append为false则覆盖原文件

• 换行：写换行符号

windows：\r\n
Linux：/n
Mac：/r

3.InputStream字节输入流

InputStream类为抽象类，无法直接使用，需要创造子类使用

3.1FileInputStream文件字节输入流

1. 作用：把硬盘的文件中的数据以字节的方式读取到内存中
2. 构造方法：

作用：

• 创建一个FileInputStream对象
• 会把FileInputStream对象指向读取的文件

FileInputStream(String name) 读取文件的数据源是一个文件的路径

FileInputStream(File file)  读取文件的数据源是一个文件

• 字节输入流的使用步骤

1. 创建一个创建一个FileInputStream对象，构造方法中填写读取文件的数据源

FileInputStream fos = new FileInputStream("G:\\Java\\测试文件夹\\c.txt");

2. 调用创建一个FileInputStream对象的read()方法，读取文件

fos.read();   读取文件中的一个字节并返回,并且将指针后移一位,读取到文件的末尾返回-1

3. 释放资源

fos.close();

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

public class Demo02 {
    public static void main(String[] args) throws IOException {
        FileInputStream fos = new FileInputStream("G:\\Java\\测试文件夹\\c.txt");

        fos.read();
        System.out.println(fos.read());

        fos.read();
        System.out.println(fos.read());

        fos.read();
        System.out.println(fos.read());

        fos.read();
        System.out.println(fos.read());

        fos.close();
    }
}

• 字节输入流循环读取全部字节

FileInputStream fos = new FileInputStream("G:\\Java\\测试文件夹\\a.txt");
int len = 0;
while ((len = fos.read()) != -1) {
    System.out.println(len);
}

不能
while (fos.read()!=-1){
System.out.println(fos.read());
}
因为每次执行fos.read()，指针都会后移一位

• 一次读多个字节的方法

 FileInputStream file = new FileInputStream("G:\\Java\\测试文件夹\\a.txt");
 byte[] bytes = new byte[2]; 创建一个字节数组，用于盛放多个字节
 int len = file.read(bytes); 读取字节数组容量的字节个数，返回值为字节长度
 System.out.println(len);    打印字节长度
 System.out.println(Arrays.toString(bytes));  将数组按照默认格式变成字符串
 System.out.println(new String(bytes));  创建字符串三种构造方法之一，根据字节数组的内容，来创建字符串

例子：

package FileInputStream;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) throws IOException {
        FileInputStream file = new FileInputStream("G:\\Java\\测试文件夹\\a.txt");

        byte[] bytes1 = new byte[2];
        int len1 = file.read(bytes1);

        System.out.println(len1);
        System.out.println(new String(bytes1));
        System.out.println("============================");


        byte[] bytes2 = new byte[2];
        int len2 = file.read(bytes2);

        System.out.println(len2);
        System.out.println(new String(bytes2));
        System.out.println("============================");



        byte[] bytes3 = new byte[2];
        int len3 = file.read(bytes3);

        System.out.println(len3);
        System.out.println(new String(bytes3));
        System.out.println("============================");



        byte[] bytes4 = new byte[2];
        int len4 = file.read(bytes4);

        System.out.println(len4);
        System.out.println(new String(bytes4));
    }
}

• 原理：
  

• 循环读取全部字节优化：

byte[] bytes = new byte[1024];
int len = 0;
while ((len=file.read(bytes))!=-1){
    System.out.println(new String(bytes,0,len));
}

package FileInputStream;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) throws IOException {
        FileInputStream file = new FileInputStream("G:\\Java\\测试文件夹\\a.txt");

/*        byte[] bytes1 = new byte[2];
        int len1 = file.read(bytes1);

        System.out.println(len1);
        System.out.println(new String(bytes1));
        System.out.println("============================");


        byte[] bytes2 = new byte[2];
        int len2 = file.read(bytes2);

        System.out.println(len2);
        System.out.println(new String(bytes2));
        System.out.println("============================");



        byte[] bytes3 = new byte[2];
        int len3 = file.read(bytes3);

        System.out.println(len3);
        System.out.println(new String(bytes3));
        System.out.println("============================");



        byte[] bytes4 = new byte[2];
        int len4 = file.read(bytes4);

        System.out.println(len4);
        System.out.println(new String(bytes4));*/
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len=file.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }

    }
}