Java-IO流-输入流和输出流

IO流

根据数据的流向分为：输入流和输出流。

	输入流	输出流
字节流	字节输入流 InputStream	字节输出流 OutputStream
字符流	字符输入流 ** **	字符输出流 Writer

• 输入流：将数据从其他设备(硬盘)上读取到内存中的流
• 输出流：将数据从内存中写出到其他设备的流
• 字节流：子节单位方式读写数据的流 ，字节是二进制数据的单位。一个字节通常8位长。
• 字符流：字符单位方式读写数据的流，字符

在UTF-8编码中，一个英文字母字符存储需要1个字节，一个汉字字符储存需要3到4个字节

一切皆为字节：一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

字节输出流【OutputStream】

• .close关闭输出流释放资源
• .flush刷新并强制任何缓冲的输出字节被写出
• write(byte[] b)将b.length字节从指定的字节数组写入此输出流
• write(byte[] b,int off,int len)从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流

小贴士：

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileOutputStream类

java.io.FileOutputStream类是文件输出流，用于将数据写出到文件。

public class FileOutputStreamConstructor throws IOException {
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileOutputStream fos = new FileOutputStream(file);
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("b.txt");
    }
}

写出字节数据：write()

        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
      	// 写出数据
      	fos.write(97); // 写出第1个字节
      	fos.write(98); // 写出第2个字节
      	fos.write(99); // 写出第3个字节
      	// 关闭资源
        fos.close();

写出字节数组：write(byte[] b)

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        z fos = new FileOutputStream("fos.txt");     
      	// 字符串转换为字节数组
      	byte[] b = "理解".getBytes();
      	// 写出字节数组数据
      	fos.write(b);
      	// 关闭资源
        fos.close();
    }
}
输出结果：

写出指定长度字节数组：write(byte[] b, int off, int len)

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
      	// 字符串转换为字节数组
      	byte[] b = "abcde".getBytes();
		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b,2,2);
      	// 关闭资源
        fos.close();
    }
}
输出结果：
cd

Windows系统里，换行符号是\r\n

字节输入流【InputStream】

.close：关闭输入流并释放与此流相关联的任何系统资源

.read：读取数据下一个字节

.read(byte[] b)：读取一些字节数

FileInputStream类

public class FileInputStreamConstructor throws IOException{
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileInputStream fis = new FileInputStream(file);
        // 使用文件名称创建流对象
        FileInputStream fis = new FileInputStream("b.txt");
    }
}

读取字节：read方法

使用字节数组读取：read(byte[] b)

public class FISRead{
    public static void main(String[] args)throw IOExcepetion{
        // 使用文件名称创建流对象.
        FileInputStream fis = new FileInputStream("read.txt");
        // 定义变量，作为有效个数
        int len;
         // 定义字节数组，作为装字节数据的容器  
        byte[] b = new byte[1024];
        // 循环读取
        while((len = fis.read(b)!=-1)){
            	// 每次读取后,把数组的有效字节部分，变成字符串打印
            System.out.println(new String(b,0,len));//  len 每次读取的有效字节个数
            // 关闭资源
            fis.close();
        }
    }
}

小贴士：

使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使用。

字符流

字符输入流【Reader】

java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。

.close

.read 从输入流读取一个字符。

.read(char[] c) 从输入流中读取一些字符，并将它们存储到字符数组 c中 。

FileReader类

读取字符：read方法

public class FRRead {
    public static void main(String[] args) throws IOException {
      	// 使用文件名称创建流对象
       	FileReader fr = new FileReader("read.txt");
      	// 定义变量，保存数据
        int b ；
        // 循环读取
        while ((b = fr.read())!=-1) {
            System.out.println((char)b);
        }
		// 关闭资源
        fr.close();
    }
}
输出结果：

使用字符数组读取 read(char[] cbuf)

public class FRRead {
    public static void main(String[] args) throws IOException {
      	// 使用文件名称创建流对象
       	FileReader fr = new FileReader("read.txt");
      	// 定义变量，保存有效字符个数
        int len ；
        // 定义字符数组，作为装字符数据的容器
         char[] cbuf = new char[2];
        // 循环读取
        while ((len = fr.read(cbuf))!=-1) {
            System.out.println(new String(cbuf));
        }
		// 关闭资源
        fr.close();
    }
}

字符输出流【Writer】

java.io.Writer抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。

• void write(int c) 写入单个字符。
• void write(char[] cbuf)写入字符数组。
• abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。

写出字符：write(int b)

小贴士：

1. 虽然参数为int类型四个字节，但是只会保留一个字符的信息写出。
2. 未调用close方法，数据只是保存到了缓冲区，并未写出到文件中。

关闭和刷新

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要flush 方法了。

• flush ：刷新缓冲区，流对象可以继续使用。
• close:先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

写出字符数组 ：write(char[] cbuf) 和 write(char[] cbuf, int off, int len)

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
      	// 字符串转换为字节数组
      	char[] chars = "我叫李津".toCharArray();
      
      	// 写出字符数组
      	fw.write(chars); // 我叫李津
        
		// 写出从索引2开始，2个字节。索引2是'李'，两个字节，也就是'李津'。
        fw.write(b,2,2); // 
      
      	// 关闭资源
        fos.close();
    }
}