java IO 输入流

输入：读取外部数据（磁盘或光盘中的数据）到程序（内存）中

输出：将程序（内存）中的数据输入到磁盘或光盘等存储设备中

java的IO流主要包括输入输出IO流，每种输入输出流可分为字节流和字符流两大类

File类代表与平台无关的文件和目录

File能新建，删除，重命名文件和目录，但file不能访问文件内容本身，如果需要访问文件内容，则需要使用输入输出流

IO流的分类

按流向：输入流，输出流

按处理单位：字节流（8位的字节），字符流（16位的字节）

按流的角色：节点流，处理流

InputStream和Reader是所有输入流的基类

程序中打开的IO资源不属于内存中的资源，垃圾回收机制无法回收该资源，所以应显式关闭文件IO资源 

package com.java.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;

import org.junit.Test;

public class IoTest {

	/**
	 * 测试字符输入流
	 * @throws IOException
	 */
	@Test
	public void testReader() throws IOException{
		Reader read = new FileReader("hello.txt");
		char[] buffer = new char[10];
		int len = 10;
		while((len = read.read(buffer))!=-1){
			for(int i = 0;i<len;i++){
				System.out.print(buffer[i]);
			}
		}
		read.close();
	}
	/**
	 * 字节输入流，需要强制转换
	 * @throws IOException
	 */
	@Test
	public void testInputStream() throws IOException{
		//创建一个字节输入流
		InputStream in = new FileInputStream("hello.txt");
		
		//读取文件内容
		//1.读一个,效率低,-1代表文件的结尾
		int result = in.read();
		while(result!=-1){
		    System.out.print((char)result);
		    result = in.read();
		}
		//2 一次读取一组：一组字符,一次读取10个字节
		byte[] buffer = new byte[10];
		int len = 0;
		//返回一次读取的字节数，若为-1则表示读取到文件的结尾,但是用这个方法读容易出问题，就是文件的大小如果不是10的倍数
		//那么很容易出问题，会多读
		/*while((len = in.read(buffer))!=-1){
			for(byte b:buffer){
				System.out.print((char)b);
			}
		}*/
		//所以，
		while((len = in.read(buffer))!=-1){
			for(int i = 0;i<len;i++){
				System.out.print((char)buffer[i]);
			}
		}
		
		//3,把内容读取到的字节数组的部分连续元素中
		//本来是一次读取1024*10 若文件内容没有这么大，那么我们可以把内容放进bytes中指定的位置，第10个开始，一直到
		//文件读取结束
		byte[] bytes = new byte[1024*10];
		in.read(bytes,10,in.available());
		//关闭
		in.close();
	}
	/**
	 * File 代表物理意义的文件或目录
	 */
	@Test
	public void testFile(){
		//创建File对象
		File file = new File("hello.txt");
		
		//文件名相关的方法
		String fileName = file.getName();
		System.out.println(fileName);
		
		//访问文件的绝对路径
		String path = file.getAbsolutePath();
		System.out.println(path);
		//.....
		
		//文件检测相关
		System.out.println(file.exists());
		
		//............
		
		//获取文件的常规信息
		System.out.println(file.length());
		
	}
}

关于文件的复制

/**
	 * 缓冲流效率更高
	 * @throws IOException
	 */
	@Test
	public void testBufferInputStreamAndBufferOutputStream()throws IOException{
		InputStream in = new FileInputStream("hello.txt");
		BufferedInputStream bufferedInputStream = new BufferedInputStream(in);
		OutputStream out = new FileOutputStream("hello5.txt");
		BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(out);
		
		byte[] buff = new byte[1024];
		int len = 0;
		while((len = bufferedInputStream.read(buff))!=-1){
			bufferedOutputStream.write(buff, 0, len);
		}
		bufferedInputStream.close();
		bufferedOutputStream.close();
		
	}
	/**
	 * BufferedReader 和  BufferedWriter 是对Reader和Writer的包装
	 * BufferedReader 可以一次读取一行 返回String
	 * 再读取的时候我们要考虑一下换行，因为只读取一行的数据，如果不考虑换行的话，所有的数据全在一行
	 * 但，考虑换行的话也要注意，不要最后一次读取也有换行
	 * 所以，使用int i = 0; 作为一个记录
	 * 只有第一次读取的时候不换行，以后每次读取，都要在写入数据之间换行
	 * @throws IOException
	 */
	@Test
	public void testBufferReaderAndBufferWriter()throws IOException{
		Reader in = new FileReader("hello.txt");
		BufferedReader bufferedReader = new BufferedReader(in);
		Writer out = new FileWriter("hello4.txt");
		BufferedWriter bufferedWriter = new BufferedWriter(out);
		String str = null;
		int i = 0;
		
		while((str = bufferedReader.readLine())!=null){
			if(i!=0){
				bufferedWriter.write("\n");
			}
			bufferedWriter.write(str);
			i++;
		}
		
		
		//直接关闭包装流，内部会关闭节点流
		bufferedReader.close();
		bufferedWriter.close();
	}
	@Test
	public void testCopyReaderAndWriter()throws IOException{
		//创建字符输入，输出流
		Reader reader = new FileReader("hello.txt");
		Writer writer = new FileWriter("hello3.txt");
		
		//创建一个字符数组
		char[] buff = new char[10];
		
		//利用循环读取源文件，并向目标文件写入
		//当读取文件时，因为设定的是一次读取10个字符，也就是说，只有最后一次读取时可能是读取10个，也可能少于10个
		//reader.read(buff) 返回实际读取的字符数，
		//reader.read(buff) == -1 时，读取到文件结尾，结束循环
		int len = 0;
		while((len = reader.read(buff))!=-1){
			writer.write(buff, 0, len);
		}
		//
		
		//关闭
		reader.close();
		writer.close();
	}
	
	@Test
	public void testFileCopy() throws IOException{
		// 创建定位到hello.txt的文件输入流
		InputStream in = new FileInputStream("hello.txt");
		
		//创建定位到hello2.txt的文件输入流
		OutputStream out = new FileOutputStream("hello2.txt");
		//创建一个byte数组，用于读写文件
		byte[] bytes = new byte[1024];
		int len = 0;
		//读写文件
		
		while((len = in.read(bytes))!=-1){
			out.write(bytes,0,len);
		}
		//关闭 
		out.close();
		in.close();
		
		
	}