Java IO流

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

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

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

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();
				}
			}
		}
	}
}

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

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

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();
				}
			}
		}
	}
}

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();
				}
			}
		}
	}

}

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);
		
		
	}

}