day20-----------IO流（传智视频）

递归思想

兔子问题

package cn.itcast_02;

/*
 * 有一对兔子，从出生后第3个月起每月都生一对兔子，小兔子长到第三个月后每月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
 * 分析：咱们要想办法找规律
 * 			兔子对数
 * 第一个月： 	1
 * 第二个月：	1
 * 第三个月：	2
 * 第四个月：	3	
 * 第五个月：	5
 * 第六个月：	8
 * ...
 * 
 * 因而可知兔子对象的数据是：
 * 		1,1,2,3,5,8...
 * 规则：
 * 		A:从第三项开始，每一项是前两项之和
 * 		B:并且说明前两项是已知的
 * 
 * 如何实现这个程序呢?
 * 		A:数组实现
 * 		B:变量的变化实现
 * 		C:递归实现
 * 
 * 假如相邻的两个月的兔子对数是a,b
 * 第一个相邻的数据：a=1,b=1
 * 第二个相邻的数据：a=1,b=2
 * 第三个相邻的数据：a=2,b=3
 * 第四个相邻的数据：a=3,b=5
 * 看到了：下一次的a是之前的b，下一次是之前的a+b	
 */
public class DiGuiDemo2 {
	public static void main(String[] args) {
		// 定义一个数组
		int[] arr = new int[20];
		arr[0] = 1;
		arr[1] = 1;
		// arr[2] = arr[0] + arr[1];
		// arr[3] = arr[1] + arr[2];
		// ...
		for (int x = 2; x < arr.length; x++) {
			arr[x] = arr[x - 2] + arr[x - 1];
		}
		System.out.println(arr[19]);// 6765
		System.out.println("----------------");

		int a = 1;
		int b = 1;
		for (int x = 0; x < 18; x++) {
			// 临时变量存储上一次的a
			int temp = a;
			a = b;
			b = temp + b;
		}
		System.out.println(b);
		System.out.println("----------------");

		System.out.println(fib(20));
	}

	/*
	 * 方法： 返回值类型：int 参数列表：int n 出口条件： 第一个月是1，第二个月是1 规律： 从第三个月开始，每个月是前两个月之和
	 */
	public static int fib(int n) {
		if (n == 1 || n == 2) {
			return 1;
		} else {
			return fib(n - 1) + fib(n - 2);
		}
	}
}

递归输出指定目录下全部的java文件的绝对路径案例

package cn.itcast_03;

import java.io.File;

/*
 * 需求：请你们把E:\JavaSE目录下全部的java结尾的文件的绝对路径给输出在控制台。
 * 
 * 分析：
 * 		A:封装目录
 * 		B:获取该目录下全部的文件或者文件夹的File数组
 * 		C:遍历该File数组，获得每个File对象
 * 		D:判断该File对象是不是文件夹
 * 			是：回到B
 * 			否：继续判断是否以.java结尾
 * 				是：就输出该文件的绝对路径
 * 				否：不搭理它
 */
public class FilePathDemo {
	public static void main(String[] args) {
		// 封装目录
		File srcFolder = new File("E:\\JavaSE");

		// 递归功能实现
		getAllJavaFilePaths(srcFolder);
	}

	private static void getAllJavaFilePaths(File srcFolder) {
		// 获取该目录下全部的文件或者文件夹的File数组
		File[] fileArray = srcFolder.listFiles();

		// 遍历该File数组，获得每个File对象
		for (File file : fileArray) {
			// 判断该File对象是不是文件夹
			if (file.isDirectory()) {
				getAllJavaFilePaths(file);
			} else {
				// 继续判断是否以.java结尾
				if (file.getName().endsWith(".java")) {
					// 就输出该文件的绝对路径
					System.out.println(file.getAbsolutePath());
				}
			}
		}
	}
}

递归删除带内容的目录案例

package cn.itcast_03;

import java.io.File;

/*
 * 需求：递归删除带内容的目录
 * 
 * 目录我已经给定：demo
 * 
 * 分析：
 * 		A:封装目录
 * 		B:获取该目录下的全部文件或者文件夹的File数组
 * 		C:遍历该File数组，获得每个File对象
 * 		D:判断该File对象是不是文件夹
 * 			是：回到B
 * 			否：就删除
 */
public class FileDeleteDemo {
	public static void main(String[] args) {
		// 封装目录
		File srcFolder = new File("demo");
		// 递归实现
		deleteFolder(srcFolder);
	}

	private static void deleteFolder(File srcFolder) {
		// 获取该目录下的全部文件或者文件夹的File数组
		File[] fileArray = srcFolder.listFiles();

		if (fileArray != null) {
			// 遍历该File数组，获得每个File对象
			for (File file : fileArray) {
				// 判断该File对象是不是文件夹
				if (file.isDirectory()) {
					deleteFolder(file);
				} else {
					System.out.println(file.getName() + "---" + file.delete());
				}
			}

			System.out.println(srcFolder.getName() + "---" + srcFolder.delete());
		}
	}
}

IO流

 •‍‍什么状况下使用哪一种流呢?  •

  若是数据所在的文件经过windows自带的记事本打开并能读懂里面的内容，就用字符流。其余用字节流。 

•   若是你什么都不知道，就用字节流   ‍ ‍

FileOutputStream写入数据

package cn.itcast_01;

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

/*
 * IO流的分类：
 * 		流向：
 * 			输入流	读取数据
 * 			输出流 写出数据
 * 		数据类型：
 * 			字节流
 * 				字节输入流	读取数据	InputStream
 * 				字节输出流	写出数据	OutputStream
 * 			字符流
 * 				字符输入流	读取数据	Reader
 * 				字符输出流	写出数据	Writer
 * 
 * 		注意：通常咱们在探讨IO流的时候，若是没有明确说明按哪一种分类来讲，默认状况下是按照数据类型来分的。
 * 
 * 需求：我要往一个文本文件中输入一句话："hello,io"
 * 
 * 分析：
 * 		A:这个操做最好是采用字符流来作，可是呢，字符流是在字节流以后才出现的，因此，今天我先讲解字节流如何操做。
 * 		B:因为我是要往文件中写一句话，因此咱们要采用字节输出流。
 * 
 * 经过上面的分析后咱们知道要使用：OutputStream
 * 可是经过查看API，咱们发现该流对象是一个抽象类，不能实例化。
 * 因此，咱们要找一个具体的子类。
 * 而咱们要找的子类是什么名字的呢?这个时候，很简单，咱们回想一下，咱们是否是要往文件中写东西。
 * 文件是哪一个单词：File
 * 而后用的是字节输出流，联起来就是：FileOutputStream
 * 注意：每种基类的子类都是以父类名做为后缀名。
 * 		XxxOutputStream
 * 		XxxInputStream
 * 		XxxReader
 * 		XxxWriter
 * 查看FileOutputStream的构造方法：
 * 		FileOutputStream(File file) 
 *		FileOutputStream(String name)
 *
 * 字节输出流操做步骤：
 * 		A:建立字节输出流对象
 * 		B:写数据
 * 		C:释放资源
 */
public class FileOutputStreamDemo {
	public static void main(String[] args) throws IOException {
		// 建立字节输出流对象
		// FileOutputStream(File file)
		// File file = new File("fos.txt");
		// FileOutputStream fos = new FileOutputStream(file);
		// FileOutputStream(String name)
		FileOutputStream fos = new FileOutputStream("fos.txt");
		/*
		 * 建立字节输出流对象了作了几件事情：
		 * A:调用系统功能去建立文件
		 * B:建立fos对象
		 * C:把fos对象指向这个文件
		 */
		
		//写数据
		fos.write("hello,IO".getBytes());
		fos.write("java".getBytes());
		
		//释放资源
		//关闭此文件输出流并释放与此流有关的全部系统资源。
		fos.close();
		/*
		 * 为何必定要close()呢?
		 * A:让流对象变成垃圾，这样就能够被垃圾回收器回收了
		 * B:通知系统去释放跟该文件相关的资源
		 */
		//java.io.IOException: Stream Closed
		//fos.write("java".getBytes());
	}
}

FileOutputStream的write()的三个方法

package cn.itcast_01;

import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 字节输出流操做步骤：
 * A:建立字节输出流对象
 * B:调用write()方法
 * C:释放资源
 * 
 * public void write(int b):写一个字节
 * public void write(byte[] b):写一个字节数组
 * public void write(byte[] b,int off,int len):写一个字节数组的一部分
 */
public class FileOutputStreamDemo2 {
	public static void main(String[] args) throws IOException {
		// 建立字节输出流对象
		// OutputStream os = new FileOutputStream("fos2.txt"); // 多态
		FileOutputStream fos = new FileOutputStream("fos2.txt");

		// 调用write()方法
		//fos.write(97); //97 -- 底层二进制数据	-- 经过记事本打开 -- 找97对应的字符值 -- a
		// fos.write(57);
		// fos.write(55);
		
		//public void write(byte[] b):写一个字节数组
		byte[] bys={97,98,99,100,101};
		fos.write(bys);
		
		//public void write(byte[] b,int off,int len):写一个字节数组的一部分
		fos.write(bys,1,3);
		
		//释放资源
		fos.close();
	}
}

FileOutputStream写出数据实现换行和追加写入

package cn.itcast_01;

import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 如何实现数据的换行?
 * 		为何如今没有换行呢?由于你值写了字节数据，并无写入换行符号。
 * 		如何实现呢?写入换行符号便可呗。
 * 		刚才咱们看到了有写文本文件打开是能够的，经过windows自带的那个不行，为何呢?
 * 		由于不一样的系统针对不一样的换行符号识别是不同的?
 * 		windows:\r\n
 * 		linux:\n
 * 		Mac:\r
 * 		而一些常见的个高级记事本，是能够识别任意换行符号的。
 * 
 * 如何实现数据的追加写入?
 * 		用构造方法带第二个参数是true的状况便可
 */
public class FileOutputStreamDemo3 {
	public static void main(String[] args) throws IOException {
		// 建立字节输出流对象
		// FileOutputStream fos = new FileOutputStream("fos3.txt");
		// 建立一个向具备指定 name 的文件中写入数据的输出文件流。若是第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。
		FileOutputStream fos = new FileOutputStream("fos3.txt", true);

		// 写数据
		for (int x = 0; x < 10; x++) {
			fos.write(("hello" + x).getBytes());
			fos.write("\r\n".getBytes());
		}

		// 释放资源
		fos.close();
	}
}

FileOutputStream写出数据加入异常处理

package cn.itcast_01;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 加入异常处理的字节输出流操做
 */
public class FileOutputStreamDemo4 {
	public static void main(String[] args) {
		// 分开作异常处理
		// FileOutputStream fos = null;
		// try {
		// fos = new FileOutputStream("fos4.txt");
		// } catch (FileNotFoundException e) {
		// e.printStackTrace();
		// }
		//
		// try {
		// fos.write("java".getBytes());
		// } catch (IOException e) {
		// e.printStackTrace();
		// }
		//
		// try {
		// fos.close();
		// } catch (IOException e) {
		// e.printStackTrace();
		// }

		// 一块儿作异常处理
		// try {
		// FileOutputStream fos = new FileOutputStream("fos4.txt");
		// fos.write("java".getBytes());
		// fos.close();
		// } catch (FileNotFoundException e) {
		// e.printStackTrace();
		// } catch (IOException e) {
		// e.printStackTrace();
		// }

		// 改进版
		// 为了在finally里面可以看到该对象就必须定义到外面，为了访问不出问题，还必须给初始化值
		FileOutputStream fos = null;
		try {
			// fos = new FileOutputStream("z:\\fos4.txt");
			fos = new FileOutputStream("fos4.txt");
			fos.write("java".getBytes());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			// 若是fos不是null，才须要close()
			if (fos != null) {
				// 为了保证close()必定会执行，就放到这里了
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

FileInputStream读取数据

package cn.itcast_02;

import java.io.FileInputStream;
import java.io.IOException;

/*
 * 字节输入流操做步骤：
 * A:建立字节输入流对象
 * B:调用read()方法读取数据，并把数据显示在控制台
 * C:释放资源
 * 
 * 读取数据的方式：
 * A:int read():一次读取一个字节
 * B:int read(byte[] b):一次读取一个字节数组
 */
public class FileInputStreamDemo {
	public static void main(String[] args) throws IOException {
		// FileInputStream(String name)
		// FileInputStream fis = new FileInputStream("fis.txt");
		FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");

		// // 调用read()方法读取数据，并把数据显示在控制台
		// // 第一次读取
		// int by = fis.read();
		// System.out.println(by);
		// System.out.println((char) by);
		//
		// // 第二次读取
		// by = fis.read();
		// System.out.println(by);
		// System.out.println((char) by);
		//
		// // 第三次读取
		// by = fis.read();
		// System.out.println(by);
		// System.out.println((char) by);
		// // 咱们发现代码的重复度很高，因此咱们要用循环改进
		// // 而用循环，最麻烦的事情是如何控制循环判断条件呢?
		// // 第四次读取
		// by = fis.read();
		// System.out.println(by);
		// // 第五次读取
		// by = fis.read();
		// System.out.println(by);
		// //经过测试，咱们知道若是你读取的数据是-1，就说明已经读取到文件的末尾了

		// 用循环改进
		// int by = fis.read();
		// while (by != -1) {
		// System.out.print((char) by);
		// by = fis.read();
		// }

		// 最终版代码
		int by = 0;
		// 读取，赋值，判断
		while ((by = fis.read()) != -1) {
			System.out.print((char) by);
		}

		// 释放资源
		fis.close();
	}
}

字节流复制文本文件案例

package cn.itcast_03;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 复制文本文件。
 * 
 * 数据源：从哪里来
 * a.txt	--	读取数据	--	FileInputStream	
 * 
 * 目的地：到哪里去
 * b.txt	--	写数据		--	FileOutputStream
 * 
 * java.io.FileNotFoundException: a.txt (系统找不到指定的文件。)
 * 
 * 这一次复制中文没有出现任何问题，为何呢?
 * 上一次咱们出现问题的缘由在于咱们每次获取到一个字节数据，就把该字节数据转换为了字符数据，而后输出到控制台。
 * 而这一次呢?确实经过IO流读取数据，写到文本文件，你读取一个字节，我就写入一个字节，你没有作任何的转换。
 * 它会本身作转换。
 */
public class CopyFileDemo {
	public static void main(String[] args) throws IOException {
		// 封装数据源
		FileInputStream fis = new FileInputStream("a.txt");
		// 封装目的地
		FileOutputStream fos = new FileOutputStream("b.txt");

		int by = 0;
		while ((by = fis.read()) != -1) {
			fos.write(by);
		}

		// 释放资源(先关谁都行)
		fos.close();
		fis.close();
	}
}

计算机是如何识别把两个字节拼接为中文的呢

package cn.itcast_03;

import java.util.Arrays;

/*
 * 计算机是如何识别何时该把两个字节转换为一个中文呢?
 * 在计算机中中文的存储分两个字节：
 * 		第一个字节确定是负数。
 * 		第二个字节常见的是负数，可能有正数。可是没影响。
 */
public class StringDemo {
	public static void main(String[] args) {
		// String s = "abcde";
		// // [97, 98, 99, 100, 101]

		String s = "我爱你中国";
		// [-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]

		byte[] bys = s.getBytes();
		System.out.println(Arrays.toString(bys));
	}
}

字节流复制文本文件案例

package cn.itcast_03;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 需求：把c盘下的a.txt的内容复制到d盘下的b.txt中
 * 
 * 数据源：
 * 		c:\\a.txt	--	读取数据--	FileInputStream
 * 目的地：
 * 		d:\\b.txt	--	写出数据	--	FileOutputStream
 */
public class CopyFileDemo2 {
	public static void main(String[] args) throws IOException {
		// 封装数据源
		FileInputStream fis = new FileInputStream("c:\\a.txt");
		// 封装目的地
		FileOutputStream fos = new FileOutputStream("d:\\b.txt");

		// 复制数据
		int by = 0;
		while ((by = fis.read()) != -1) {
			fos.write(by);
		}

		// 释放资源
		fos.close();
		fis.close();
	}
}

字节流复制图片案例

package cn.itcast_03;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 需求：把e:\\林青霞.jpg内容复制到当前项目目录下的mn.jpg中
 * 
 * 数据源：
 * 		e:\\林青霞.jpg	--读取数据--FileInputStream
 * 目的地：
 * 		mn.jpg--写出数据--FileOutputStream
 */
public class CopyImageDemo {
	public static void main(String[] args) throws IOException {
		// 封装数据源
		FileInputStream fis = new FileInputStream("e:\\林青霞.jpg");
		// 封装目的地
		FileOutputStream fos = new FileOutputStream("mn.jpg");

		// 复制数据
		int by = 0;
		while ((by = fis.read()) != -1) {
			fos.write(by);
		}

		// 释放资源
		fos.close();
		fis.close();
	}
}

字节流复制视频案例

package cn.itcast_03;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 需求：把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中
 * 
 * 数据源：
 * 		e:\\哥有老婆.mp4--读取数据--FileInputStream
 * 目的地：
 * 		copy.mp4--写出数据--FileOutputStream
 */
public class CopyMp4Demo {
	public static void main(String[] args) throws IOException {
		// 封装数据源
		FileInputStream fis = new FileInputStream("e:\\哥有老婆.mp4");
		// 封装目的地
		FileOutputStream fos = new FileOutputStream("copy.mp4");

		// 复制数据
		int by = 0;
		while ((by = fis.read()) != -1) {
			fos.write(by);
		}

		// 释放资源
		fos.close();
		fis.close();
	}
}

FileInputStream读取数据一次一个字节数组

package cn.itcast_02;

import java.io.FileInputStream;
import java.io.IOException;

/*
 * 一次读取一个字节数组：int read(byte[] b)
 * 返回值实际上是实际读取的字节个数。
 */
public class FileInputStreamDemo2 {
	public static void main(String[] args) throws IOException {
		// 建立字节输入流对象
		// FileInputStream fis = new FileInputStream("fis2.txt");
		FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");

		// 读取数据
		// 定义一个字节数组
		// 第一次读取
		// byte[] bys = new byte[5];
		// int len = fis.read(bys);
		// // System.out.println(len);
		// // System.out.println(new String(bys));
		// // System.out.println(new String(bys, 0, len));
		// System.out.print(new String(bys, 0, len));
		//
		// // 第二次读取
		// len = fis.read(bys);
		// // System.out.println(len);
		// // System.out.println(new String(bys));
		// // System.out.println(new String(bys, 0, len));
		// System.out.print(new String(bys, 0, len));
		//
		// // 第三次读取
		// len = fis.read(bys);
		// // System.out.println(len);
		// // System.out.println(new String(bys));
		// // System.out.println(new String(bys, 0, len));
		// System.out.print(new String(bys, 0, len));
		//
		// // 第四次读取
		// len = fis.read(bys);
		// // System.out.println(len);
		// // System.out.println(new String(bys, 0, len));
		// System.out.print(new String(bys, 0, len));
		// // 代码重复了，用循环改进
		// // 可是，我不知道结束条件
		// // len = fis.read(bys);
		// // System.out.println(len);
		// // len = fis.read(bys);
		// // System.out.println(len);
		// // 若是读取到的实际长度是-1，就说明没有数据了

		// byte[] bys = new byte[115]; // 0
		// int len = 0;
		// while ((len = fis.read(bys)) != -1) {
		// System.out.print(new String(bys, 0, len));
		// // System.out.print(new String(bys)); //千万要带上len的使用
		// }

		// 最终版代码
		// 数组的长度通常是1024或者1024的整数倍
		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = fis.read(bys)) != -1) {
			System.out.print(new String(bys, 0, len));
		}

		// 释放资源
		fis.close();
	}
}

FileInputStream读取数据的两种方式比较图解

字节复制文本文件案例

package cn.itcast_04;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 需求：把c:\\a.txt内容复制到d:\\b.txt中
 * 
 * 数据源：
 * 		c:\\a.txt	--	读取数据	--	FileInputStream
 * 目的地：
 * 		d:\\b.txt	--	写出数据	--	FileOutputStream
 */
public class CopyFileDemo {
	public static void main(String[] args) throws IOException {
		// 封装数据源
		FileInputStream fis = new FileInputStream("c:\\a.txt");
		FileOutputStream fos = new FileOutputStream("d:\\b.txt");

		// 复制数据
		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = fis.read(bys)) != -1) {
			fos.write(bys, 0, len);
		}

		// 释放资源
		fos.close();
		fis.close();
	}
}

字节流复制视频案例

package cn.itcast_04;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 需求：把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中
 * 
 * 数据源：
 * 		e:\\哥有老婆.mp4--读取数据--FileInputStream
 * 目的地：
 * 		copy.mp4--写出数据--FileOutputStream
 */
public class CopyMp4Demo {
	public static void main(String[] args) throws IOException {
		// 封装数据源
		FileInputStream fis = new FileInputStream("e:\\哥有老婆.mp4");
		// 封装目的地
		FileOutputStream fos = new FileOutputStream("copy.mp4");

		// 复制数据
		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = fis.read(bys)) != -1) {
			fos.write(bys, 0, len);
		}

		// 释放资源
		fos.close();
		fis.close();
	}
}

BufferedOutputStream写出数据

package cn.itcast_05;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 经过定义数组的方式确实比之前一次读取一个字节的方式快不少，因此，看来有一个缓冲区仍是很是好的。
 * 既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。
 * 这种类被称为：缓冲区类(高效类)
 * 写数据：BufferedOutputStream
 * 读数据：BufferedInputStream
 * 
 * 构造方法能够指定缓冲区的大小，可是咱们通常用不上，由于默认缓冲区大小就足够了。
 * 
 * 为何不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?
 * 缘由很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。可是呢，真正的读写操做还得靠基本的流对象实现。
 */
public class BufferedOutputStreamDemo {
	public static void main(String[] args) throws IOException {
		// BufferedOutputStream(OutputStream out)
		// FileOutputStream fos = new FileOutputStream("bos.txt");
		// BufferedOutputStream bos = new BufferedOutputStream(fos);
		// 简单写法
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream("bos.txt"));

		// 写数据
		bos.write("hello".getBytes());

		// 释放资源
		bos.close();
	}
}

package cn.itcast_05;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

/*
 * 注意：虽然咱们有两种方式能够读取，可是，请注意，这两种方式针对同一个对象在一个代码中只能使用一个。
 */
public class BufferedInputStreamDemo {
	public static void main(String[] args) throws IOException {
		// BufferedInputStream(InputStream in)
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
				"bos.txt"));

		// 读取数据
		// int by = 0;
		// while ((by = bis.read()) != -1) {
		// System.out.print((char) by);
		// }
		// System.out.println("---------");

		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = bis.read(bys)) != -1) {
			System.out.print(new String(bys, 0, len));
		}

		// 释放资源
		bis.close();
	}
}

字节流四种方式复制MP4并测试效率

package outdemo;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求：把F:\\technology\\720.mp4复制到当前项目目录下的copy.mp4中
 * 
 * 字节流四种方式复制文件：
 * 基本字节流一次读写一个字节：	共耗时：193370毫秒
 * 基本字节流一次读写一个字节数组： 共耗时：192毫秒
 * 高效字节流一次读写一个字节： 共耗时：1222毫秒
 * 高效字节流一次读写一个字节数组： 共耗时：172毫秒
 */


public class CopyMp4 {

	public static void main(String[] args) throws IOException {
		
		method1("F:\\technology\\720.mp4","copy1.mp4");
		method2("F:\\technology\\720.mp4","copy2.mp4");
		method3("F:\\technology\\720.mp4","copy3.mp4");
		method4("F:\\technology\\720.mp4","copy4.mp4");
	}
	// 高效字节流一次读写一个字节数组：
	private static void method4(String srcString, String destString) throws IOException {
		long start = System.currentTimeMillis();
		BufferedInputStream fis = new BufferedInputStream(new FileInputStream(srcString));
		BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream(destString));
		byte[] by = new byte[20480000];
		int len = 0;
		while ((len=fis.read(by))!=-1){
			fos.write(by,0,len);
		}
		fos.close();
		fis.close();
		long end = System.currentTimeMillis();
		System.out.println("Buffer 数组--共耗时：" + (end - start) + "毫秒");
	}
	// 高效字节流一次读写一个字节：
	private static void method3(String srcString, String destString) throws IOException {
		long start = System.currentTimeMillis();
		BufferedInputStream fis = new BufferedInputStream(new FileInputStream(srcString));
		BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream(destString));
		int byt = 0;
		while ((byt=fis.read())!=-1){
			fos.write(byt);
		}
		fos.close();
		fis.close();
		long end = System.currentTimeMillis();
		System.out.println("Buffer 字节--共耗时：" + (end - start) + "毫秒");
	}
	// 基本字节流一次读写一个字节数组
	private static void method2(String srcString, String destString) throws IOException {
		long start = System.currentTimeMillis();
		FileInputStream fis = new FileInputStream(srcString);
		FileOutputStream fos = new FileOutputStream(destString);
		byte[] by = new byte[20480000];
		int byt = 0;
		while ((byt=fis.read(by))!=-1){
			fos.write(by,0,byt);
		}
		fos.close();
		fis.close();
		long end = System.currentTimeMillis();
		System.out.println("字节 数组--共耗时：" + (end - start) + "毫秒");
	}
	// 基本字节流一次读写一个字节
	private static void method1(String srcString, String destString) throws IOException {
		long start = System.currentTimeMillis();
		FileInputStream fis = new FileInputStream(srcString);
		FileOutputStream fos = new FileOutputStream(destString);
		int by = 0;
		while ((by=fis.read())!=-1){
			fos.write(by);
		}
		fos.close();
		fis.close();
		long end = System.currentTimeMillis();
		System.out.println("字节--共耗时：" + (end - start) + "毫秒");
	}

}

day20 总结

1:递归(理解)
	(1)方法定义中调用方法自己的现象
		举例：老和尚给小和尚讲故事，咱们学编程
	(2)递归的注意事项；
		A:要有出口，不然就是死递归
		B:次数不能过多，不然内存溢出
		C:构造方法不能递归使用
	(3)递归的案例：
		A:递归求阶乘
		B:兔子问题
		C:递归输出指定目录下全部指定后缀名的文件绝对路径
		D:递归删除带内容的目录(当心使用)

2:IO流(掌握)
	(1)IO用于在设备间进行数据传输的操做	
	(2)分类：
		A:流向
			输入流	读取数据
			输出流	写出数据
		B:数据类型
			字节流	
					字节输入流
					字节输出流
			字符流
					字符输入流
					字符输出流
		注意：
			a:若是咱们没有明确说明按照什么分，默认按照数据类型分。
			b:除非文件用windows自带的记事本打开咱们可以读懂，才采用字符流，不然建议使用字节流。
	(3)FileOutputStream写出数据
		A:操做步骤
			a:建立字节输出流对象
			b:调用write()方法
			c:释放资源
			
		B:代码体现：
			FileOutputStream fos = new FileOutputStream("fos.txt");
			
			fos.write("hello".getBytes());
			
			fos.close();
			
		C:要注意的问题?
			a:建立字节输出流对象作了几件事情?
			b:为何要close()?
			c:如何实现数据的换行?
			d:如何实现数据的追加写入?
	(4)FileInputStream读取数据
		A:操做步骤
			a:建立字节输入流对象
			b:调用read()方法
			c:释放资源
			
		B:代码体现：
			FileInputStream fis = new FileInputStream("fos.txt");
			
			//方式1
			int by = 0;
			while((by=fis.read())!=-1) {
				System.out.print((char)by);
			}
			
			//方式2
			byte[] bys = new byte[1024];
			int len = 0;
			while((len=fis.read(bys))!=-1) {
				System.out.print(new String(bys,0,len));
			}
			
			fis.close();
	(5)案例：2种实现
		A:复制文本文件
		B:复制图片
		C:复制视频
	(6)字节缓冲区流
		A:BufferedOutputStream
		B:BufferedInputStream
	(7)案例：4种实现
		A:复制文本文件
		B:复制图片
		C:复制视频
		
3:自学字符流
	IO流分类
		字节流：
			InputStream
				FileInputStream
				BufferedInputStream
			OutputStream
				FileOutputStream
				BufferedOutputStream
		
		字符流：
			Reader
				FileReader
				BufferedReader
			Writer
				FileWriter
				BufferedWriter