Java IO流

1. IO流

I/O流
I：input，输入
O：output，输出

生活中的水流：水从一个位置流向另一个位置。
	小河，小溪，大海，湖泊。。。
	
从饮水机中打水：
IO流：流的是数据。以(字节/字符)。用途：将数据从一个地方流到另一个地方。
	将本地文件中的数据----->程序中
	程序中----->保存到文件中
	
	网络上的数据------>电脑某个程序中
	电脑中某个文件----->网络上

流的分类：
	流向来分：
		输入流：数据从外部进入到程序中。。
		输出流：数据从程序中出去。。。
	单位来分：
		字节流：以字节为单位。		核心：所有类型的文件
		字符流：以字符为单位。——>文本信息
	功能来分：
    	节点流：直接结束数据源的流。
    	处理流：又叫过滤流。套在流上的流。
	
计算机原理：只识别0和1。---->字节为基本。    
音频文件，
视频文件，
图片文件，
本文文本
。。。。。。

2. IO流的4大基类

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

package com.qf.demo03;

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

public class Test7FileInputStream {

	public static void main(String[] args) {
		//需求：将本地haha.txt文件中的数据，读入程序中，并打印输出
		/*
		 * 根据需求分析：数据从哪到哪
		 * 
		 * 数据源：文件
		 * 目的地：程序
		 */
		//step1：先准备文件的信息：File对象或者文件的路径名
		String path = "C:\\Ruby\\pro\\aa\\haha.txt";
		FileInputStream fis = null;
		try {
			//step2：创建一个文件输入流
			fis = new FileInputStream(path);
			
			//step3：操作fis文件输入流，吭哧吭哧读文件中的数据，到程序中
			//第1次读取：97
			int data = fis.read();
			System.out.println((char)data);
			//第2次读取：98
			data = fis.read();
			System.out.println((char)data);
			//第3次读取：99
			data = fis.read();
			System.out.println(data);
			//第4次读取，
			data = fis.read();
			System.out.println(data);//-1
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			//step4：关闭流
			if(fis != null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

3. IO流的操作步骤

step1：确定数据从哪到哪。文件信息。
step2：创建流：
	流向：输入，输出
	单位：字节，字符
	子类流：文件，内存。。。。
step3：操作流
	读取数据：输入
		read()
	写出数据：输出
		write()
step4：关闭流
	close()

用于以字节为单位，读取文件中的数据，到程序中。

4. FileInputStream

1、构造方法：

FileInputStream(String name) 
通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。
FileInputStream(File file) 
通过打开与实际文件的连接创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名

4.1 read

package com.qf.demo01;

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

public class Test1FileInputStream {

	public static void main(String[] args) {
		//需求：将本地haha.txt文件中的数据，读入程序中，并打印输出
		/*
		 * 根据需求分析：数据从哪到哪
		 * 
		 * 数据源：文件
		 * 目的地：程序
		 */
		//step1：先准备文件的信息：File对象或者文件的路径名
		String path = "C:\\Ruby\\pro\\aa\\haha.txt";
		FileInputStream fis = null;
		try {
			//step2：创建一个文件输入流
			fis = new FileInputStream(path);
			
			//step3：操作fis文件输入流，吭哧吭哧读文件中的数据，到程序中
			/*
			//第1次读取：97
			int data = fis.read();
			System.out.println((char)data);//a
			//第2次读取：98
			data = fis.read();
			System.out.println((char)data);//b
			//第3次读取：99
			data = fis.read();
			System.out.println(data);//c
			//第4次读取，
			data = fis.read();
			System.out.println(data);//-1
			
			data = fis.read();
//			System.out.println("--->"+data);
 * 
 */	
			//这是一种写法
			/*
			int data = 0;
			while(true){
				data = fis.read();
				if(data == -1){
					System.out.println("读完啦。。");
					break;
				}
				System.out.println((char)data);
			}
			*/
			//惯用写法
			int data = 0;
			while((data = fis.read())!=-1){//一次读一个字节
				System.out.println((char)data);
			}
			System.out.println("读完了。。");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			//step4：关闭流
			if(fis != null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

4.2 read（byte[]）

read()-->int
    每次读取一个字节。返回值就是读入的数据本身。如果读到文件的末尾了，-1。
     
read(byte[] bs)-->int
    每次读取多个字节，最多是bs数组的长度个。
	返回值是本次读取的实际的字节个数。如果到达末尾，-1.
     
int read(byte[] bs, int off, int len)
    从该输入流读取最多 len字节的数据为字节数组 。
	第一个参数表示要存储本地读取的数据的数组，
	第二个参数，表示从哪个下标开始存储，
	第三个参数是表示本次读取预计的读取数量。该方法的返回值是本次读取的实际数量。
	如果到达文件末尾，-1。
     
     
     
byte[] bs = new byte[3];//内存资源
 
数据源：250个字节
    数组：100个长度  
    1次：100，剩150 读取100个
    2次：100，剩50  读取100个
    3次：50，读完了   读取50个
     
int read(byte[] bs) -->读多个，最多数组长度，实际看返回值，
数据在数组中，将读取到的数据存入到数组中，默认从头开始存储。

 

 

 

package com.qf.demo01;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Array;
import java.util.Arrays;

public class Test2FileInputStream {

	public static void main(String[] args) {
		/*
		 * 需求：将haha.txt中的数据，读入到程序中，打印
		 * step1：数据从哪到哪，文件信息
		 * step2：创建流
		 * step3：操作流：读，写
		 * step4：关闭流
		 */
		//step1：准备文件信息：path，File
		File file = new File("C:\\Ruby\\pro\\aa\\haha.txt");
		FileInputStream fis = null;
		try {
			//step2：创建流
			fis = new FileInputStream(file);
			//step3：操作流：读取数据
//			int data = fis.read();//效率太低
			byte[] bs = new byte[3];
			
			int len = 0;
			while((len = fis.read(bs))!=-1){
				//循环里，处理bs数组中的数据
//				for(int i=0;i<len;i++){
//					System.out.println((char)bs[i]);
//				}
				String s1 = new String(bs,0,len);
				System.out.println(s1);
			}
			
			
			/*
			System.out.println(Arrays.toString(bs));//[0, 0, 0]
			//第一次读
			int len = fis.read(bs);
			System.out.println(Arrays.toString(bs));//[97, 98, 99]
			System.out.println(len);//3
			//遍历数组，打印数据
			for(int i=0;i<bs.length;i++){
				System.out.println((char)bs[i]);
			}
			
			//第二次读
			len = fis.read(bs);
			System.out.println(Arrays.toString(bs));//[100, 101, 102]
			System.out.println(len);//3
			for(int i=0;i<bs.length;i++){
				System.out.println((char)bs[i]);
			}
			//第三次读
			len = fis.read(bs);
			System.out.println(Arrays.toString(bs));//[103, 104, 102]
			System.out.println(len);//2
			for(int i=0;i<len;i++){
				System.out.println((char)bs[i]);
			}
			
			//第四次
			len = fis.read(bs);
			System.out.println(Arrays.toString(bs));
			System.out.println(len);//-1
			*/
			
		
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(fis!= null){
				try {
					fis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

}

5. FileOutputStream

构造方法：

FileOutputStream(String name) ,在文件开头写，擦除写
创建文件输出流以指定的名称写入文件。
FileOutputStream(String name, boolean append) ，在文件的末尾写数据，追加
创建文件输出流以指定的名称写入文件。

FileOutputStream(File file) ，在文件开头写，擦除写
创建文件输出流以写入由指定的 File对象表示的文件。
FileOutputStream(File file, boolean append) ，在文件的末尾写数据，追加
创建文件输出流以写入由指定的 File对象表示的文件。 

写出去的数据，是清空写。将文件中原来的数据全部擦除，从头开始写数据。

void write(int data)，将参数，这个字节数据写出去
void write(byte[] b),将 b.length个字节从指定的字节数组写入此文件输出流。 
void write(byte[] b, int off, int len) ,将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。  　

package com.qf.demo01;

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

public class Test4FileInputStream {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
/*
 * int read(byte[] bs, int off, int len) 
	从该输入流读取最多 len字节的数据为字节数组 
	第一个参数：byte[] bs，存储本次读取的字节数据
	
	第二个参数：int off，从哪个下标开始存储
	
	第三个参数：int len，预计读取的数量
	
	返回值：是实际读入的数量
 */
		FileInputStream fis = new FileInputStream("C:\\Ruby\\pro\\aa\\haha.txt");
		
		byte[] bs = new byte[10];
		System.out.println(Arrays.toString(bs));//[00000 00000];
		int len = fis.read(bs, 3, 4);//预计读4个字节，从下标为3的位置开始存储，实际读取的量是len
		System.out.println(Arrays.toString(bs));
		System.out.println(len);
		
		len = fis.read(bs, 3, 6);//预计读6个字节，从下标为3位置开始存储,实际读取的量是len
		System.out.println(Arrays.toString(bs));
		System.out.println(len);
		
		
	}

}