Java之IO流学习总结

流：可以理解为数据的流动，就是一个数据流，IO流最终要以对象来体现

流的分类：
    按照流的方向：输入流和输出流  （输入流只能进行读操作，输出流只能进行写操作）
    按照处理数据的不同：字节流与字符流 （若处理的数据是纯文本类型的用字符流，其他全用字节流）

字节流：处理字节数据的流对象，无论是图片、文字、视频，他都可以以二进制存储，所以字节流可以
处理设备上的所有数据，当然也包含字符数据，只不过字符流处理字符数据更高效。

字符流：因为每个国家的字符都不一样，所以涉及到了字符编码问题，在获取中文字节数据的同时+指定的编码表
才可以正确解析数据，为了方便解析，将字节流与编码表等装成对象，这个对象就是字符流。只要处理纯字符数据
就优先考虑字符流。
注意：流的操作只有两种：读和写。

流的体系共有四个基类，都是抽象类：
字节流：InputStream    OutputStream
字符流：Reader        Writer

在这四个系统中，他们的子类名后缀都是父类名，前缀都是这个子类的功能名称  例子FileInputStream
BufferedWriter与BufferedReader，是用来给字符的输出流提高效率用的，意味着缓冲区对象建立时，必须要先有流对象
明确要提高具体的流对象效率

总结：
1.当需要读取时使用InputStream  Reader
  当需要写入时使用OutputStream  Writer
2.纯文本数据：Reader(读取) Writer（写入）
  非文本数据：InputStream（读取） OutputStream（写入）
  PS：读取是从从内存读取，写入是写到外部文件
3.如果是对文件操作使用Filexxx的对象，键盘System.in或者System.out
4.键盘录入：要加缓冲这样可以大大提高效率
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));


close()和flush()的区别：
flush()：将缓冲区的数据刷到目的地中后，流可以使用。
close()：将缓冲区的数据刷到目的地中后，流就关闭了，该方法主要用于结束调用的底层资源。这个动作一定做。
在io操作中一定要写close()方法来释放资源，另外最好将其写在finally()方法中，这样即使抛出异常也可以关闭流

public class JavaFileWriter {
	public static void main(String[] args) throws IOException{
		/**
		 * 1.FileWriter创建一个字符输出流对象，用于操作文件，该对象一旦建立，就必须明确数据存储位置，是一个文件
		 * 2.对象创建后，会在堆内存中有一个实体，同时在指定的位置创建了一个存储数据的文件
		 * 3.如果指定位置出现了同名文件，文件会被覆盖
		 */
		File file = new File("F:\demo1.txt");
//		FileWriter fw = null;
//		
//		fw = new FileWriter(file);
//		//调用write方法写入字符串，字符串并未直接写到目的地，而是写入了流中（其实是写入到了内存缓冲区中）
//		fw.write("aaaaaaa");
//		fw.flush();//刷新缓冲区，将缓冲区中的数据写到目的文件
//	    fw.close();//关闭流，在关闭前会先刷新流。
//		
//		/**
//		 * FileWriter创建可以读取文本的流对象，
//		 */
//		FileReader fr = null;
//		fr = new FileReader(file);
//		int ch = 0;
//		while((ch=fr.read())!=-1){//未读到结尾
//			System.out.print((char)ch);
//		}
//		fr.close();
			
		
		/**
		 * 读取文件的第二种方法，设置缓冲区，速度更快
		 */
//		FileReader fr = new FileReader(file);
//		char[] buf = new char[1024];
//		int len = 0;
//		while((len=fr.read(buf))!=-1){//将最多b.length个字节的数据读入byte数组
//			System.out.println(new String(buf,0,len));
//		}
//		fr.close();
		
		/**
		 * 采用字节流缓冲区实现读取
		 */
//		FileInputStream fis = new FileInputStream(file);
//		byte[] buf = new byte[1024];
//		int len = 0;
//		while((len = fis.read(buf))!=-1){//将最多b.length个字节的数据读入byte数组
//			System.out.println(new String(buf, 0, len)); //从byte数组输出buf中的数据
//		}
//		fis.close();
		
		/**
		 * 键盘输入对象写入文件
		 * 利用BufferedReader实现键盘输入，使用BufferedWriter实现写入文件
		 *
		 */
		//long startTime = System.currentTimeMillis();
		FileWriter fw = new FileWriter(file);
		BufferedReader bufferreader = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bufferwriter = new BufferedWriter(fw);
		String line;
		while((line = bufferreader.readLine())!=null){//readLine方法返回的时候是不带换行符的
			bufferwriter.write(line);
			bufferwriter.newLine();
			bufferwriter.flush();
		}
		bufferreader.close();
		bufferwriter.close();
		
//		long endTime = System.currentTimeMillis();
//		float excTime=(float)(endTime-startTime)/1000;
//	    System.out.println("执行时间："+excTime+"s");
	}
}

实现文件的copy

public class JavaStream {
	public static void main(String[] args) throws IOException {
		System.out.println();
		File source = new File("D:\11.txt");
		File target = new File("D:\22.txt");
		JavaStream js = new JavaStream();
		js.copyFile(source, target);
	}
	
	public void copyFile(File source,File target) throws IOException{
		InputStream in = null;
		OutputStream out = null;
		try {
			in = new FileInputStream(source);  //输入流用来读取源文件中的数据
			out = new FileOutputStream(target);//输出流用来接收源文件的数据并写入目标文件
			byte[] buffer = new byte[1024];//类似于缓冲，先将byte数组填满，再进行接收提高效率
			int bytesRead;
			while((bytesRead = in.read(buffer))>0){
				out.write(buffer, 0, bytesRead);  //
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			in.close();
			out.close();
		}
		
	}
}