2.1 IO流概述和分类

##IO流概述：
IO：输入/输出（input/ouput）
流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输

IO流就是用来处理设备间数据传输问题的
常见的应用：文件复制，文件上传，文件下载

按数据流向:输入流，输出流

输入流为读数据，输出流为写数据

按数据类型：字节输入流/输出流，字符输入流/输出流

一般来说是按数据类型来分的。

2.2 字节流写数据

输入流读数据：

public abstract class InputStream
extends Object
implements Closeable

Direct Known Subclasses:
AudioInputStream, ByteArrayInputStream, FileInputStream, FilterInputStream, InputStream, ObjectInputStream, PipedInputStream, SequenceInputStream, StringBufferInputStream

输出流写数据：

public abstract class OutputStream
extends Object
implements Closeable, Flushable

Direct Known Subclasses:
ByteArrayOutputStream, FileOutputStream, FilterOutputStream, ObjectOutputStream, OutputStream, PipedOutputStream

这里的抽象类InputStream、OutputStream表示 输入字节流、输出字节流的所有类的超类

字节流抽象类基类：
1、InputStream：这个抽象类是表示字节输入流的所有类的超类
2、OutputStream：这个抽象类是表示字节输出流的所有类的超类
3、子类名特点：子类名称都是以其父类名作为子类名的后缀

FileOutputStream：文件输出流用于将数据写入文件File

使用字节输出流写数据的步骤

1.创建字节输出流对象（调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件）
2.调用字节输出流对象的写数据方法
3.释放资源（关闭此输出流并释放与此流相关联的任何系统资源）

FileOutputStream(String name)

Creates a file output stream to write to the file with the specified name.

write(int b)

Writes the specified byte to this file output stream.

close()

Closes this file output stream and releases any system resources associated with this stream.

package dailyioStream;

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

public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("src\\dailyioStream\\fos.txt");
        /*
        这里创建了字节输出流对象 fos
        创建字节输出流对象这里一共有三步操作：
        1.调用了系统功能创建了文件
        2.创建了字节流输出对象
        3.让字节输出流对象指向创建好的文件
         */
        fos.write(97);//写到低层是97（ASCII码），但是我们打开文件内容是a
        fos.write(57);
        fos.write(55);
        
        fos.close();//释放资源，关闭此文件输出流释放并与此流相关联的任何系统资源


    }
}

2.3 字节流写数据的3种方式

void write(int b)

将指定的字节写入到此文件输出流，一次写一个字节数据
Writes the specified byte to this file output stream.

package dailyioStream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("src\\dailyioStream\\fos.txt");
        fos.write(97);
        fos.close();
    }
}

void write(byte[] b)

将b.length字节从指定的字节数组写入此文件输出流，一次写一个字节数组数据
Writes b.length bytes from the specified byte array to this file output stream.

package dailyioStream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("src\\dailyioStream\\fos.txt");
        byte[] bys = {97,98,99,100,101};
        fos.write(bys);
        fos.close();
    }
}

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

将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流，一次写一个字节数组的部分数据

Writes len bytes from the specified byte array starting at offset off to this file output stream.

package dailyioStream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("src\\dailyioStream\\fos.txt");
        byte[] bs1 = "abcdefghijk".getBytes(StandardCharsets.UTF_8);
        fos.write(bs1,0,1);//从索引off开始，写length个字节
        fos.close();
    }
}

note：String类中有getBytes()可以获取字符串的字节，返回字符串对应的字节数组

2.4 字节流写数据的两个小问题

1.字节流写数据如何实现换行？（\n换行,\r\n,\r）

package dailyioStream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class FileOutputStreamDemo03 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("src\\dailyioStream\\fos.txt");
        for(int i=0;i<10;i++){
            fos.write("hello".getBytes(StandardCharsets.UTF_8));
            fos.write("\n".getBytes(StandardCharsets.UTF_8));//  \n换行
        }
        fos.close();
    }
}

2.字节流写输出如果实现追加写入？（构造方法中的参数boolean append）

FileOutputStream的构造方法：

public FileOutputStream(String name,
                        boolean append)
                 throws FileNotFoundException

这里有带boolean append，如果为true，会从文件的末尾写入数据。
默认是false，从文件的开头写入数据。

package dailyioStream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class FileOutputStreamDemo03 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("src\\dailyioStream\\fos.txt",true);
        for(int i=0;i<10;i++){
            fos.write("hello".getBytes(StandardCharsets.UTF_8));
            fos.write("\n".getBytes(StandardCharsets.UTF_8));//  \n换行
        }
        for (int i=0;i<10;i++){
            fos.write("world".getBytes());
            fos.write("\n".getBytes(StandardCharsets.UTF_8));
        }
        fos.close();

    }
}

2.5 字节流写数据加异常处理

一般直接在外面包try{}catch{}，但是会有一个问题，如果写入数据失败会运行catch的内容，但是close方法没有运行到也就是资源没有被释放。所以在io操作一定要保存内存被释放。

package dailyioStream;

import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class FileOutputStreamDemo04 {

        public static void main(String[] args) throws IOException {
            try {
                FileOutputStream fos = new FileOutputStream("src\\dailyioStream\\fos.txt",true);
                for(int i=0;i<10;i++){
                    fos.write("hello".getBytes(StandardCharsets.UTF_8));
                    fos.write("\n".getBytes(StandardCharsets.UTF_8));//  \n换行
                }
            for (int i=0;i<10;i++){
                fos.write("world".getBytes());
                fos.write("\n".getBytes(StandardCharsets.UTF_8));
            }
            fos.close();} catch (IOException e){
                e.printStackTrace();
            }

        }
    }

提供了finally块来执行所有清除操作

finally：在异常处理时提供finally块来执行所有清除的操作。比如io流中的资源释放。
特点：被finally块控制的语句一定会执行，除非JVM退出

try{
可能出现异常的代码；
}catch(IOException e){
异常处理代码；
}
finally{
执行所有清除操作；
}

package dailyioStream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class FileOutputStreamDemo05 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("src\\dailyioStream\\fos.txt");
            fos.write("hello".getBytes(StandardCharsets.UTF_8));
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if (fos!=null){
                try {
                    fos.close();
                }catch (IOException e){
                    e.printStackTrace();  
                }
            }
        }
    }
}

2.6 字节流读数据（一次读一个字节数据）

需求：把文件fos.txt中的内容读取出来在控制台输出

FileInputStream：从文件系统中的文件获取输入字节

使用字节输入流读数据的步骤：

1.创建字节输入流对象
2.调用字节输入流对象的读数据方法
3.释放资源

FileInputStream(String name)：通过打开一个文件的连接来创建一个FileInputStream

Creates a FileInputStream by opening a connection to an actual file, the file named by the path name name in the file system.

读取一个字节

public class FileInputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("src\\dailyioStream\\fos.txt");
        int read = fis.read();
        System.out.println(read);
        fis.close();
    }
}

循环读取该文件全部内容

package dailyioStream;

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

public class FileInputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("src\\dailyioStream\\fos.txt");
        int read = fis.read();
        while(read !=-1){
            System.out.print((char) read);
            read = fis.read();
        }
        fis.close();
    }
}

优化：
while((read=fis.read()) !=-1)
1.fis.read()
2.read=fis.read()
3.read != -1

public class FileInputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("src\\dailyioStream\\fos.txt");
        int read;
        while((read=fis.read()) !=-1){
            System.out.print((char) read);
        }
        fis.close();
    }
}

案例：复制文本文件

需求：把”E:\it\java.txt“复制到模块目录下的”java.txt“

分析：
1、复制文本文件，其实就是把文本文件的内容从一个文件中读取出来（数据源），然后写入到另外一个文件中（目的地）
2、数据源：
”E:\it\java.txt“—读数据—InputStream—FileInputStream
3、目的地：
“src\dailyioStream\java.txt”—写数据—OutputStream—FileOutputStream

思路：
1、根本数据源创建字节输入流对象
2、根据目的地创建字节输出流对象
3、读写数据，复制文本文件（一次读取一个字节，一次写入一个字节）

package dailyioStream;

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

public class CopyTxtDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("C:\\Users\\n\\Desktop\\personal\\javaDemo\\java\\案例.txt");
        FileOutputStream fos = new FileOutputStream("src\\dailyioStream\\fos.txt");

        int bys;
        bys = fis.read();
        while ((bys=fis.read()) != -1){
            fos.write(bys);
        }
        fis.close();
        fos.close();
    }
}

案例：把文件fos.txt中的内容读取出来在控制台输出

//待续