案例一: 递归求阶乘
需求: 用递归求5的阶乘，并把结果在控制台输出
分析: 1.阶乘: 一个正整数的阶乘是所有小于及等于该书的正整数的积，自然数n的阶乘写作n!
5! = 5*4*3*2*1
2.递归出口: 1! = 1
3.递归规则: n! = n*(n-1)!
5! = 5*4!
思路: 1.定义一个方法，用于递归求阶乘，参数为一个int类型的变量
2.在方法内部判断该变量的值是否是1
是: 返回1
不是: 返回n*(n-1)!
3.调用方法
4.输出结果
package test;
public class Test66 {
public static void main(String[] args) {
// 3.调用方法
int result = factorial(5);
// 4.输出结果
System.out.println("5的阶乘为:"+result);
}
// 1.定义一个方法，用于递归求阶乘，参数为一个int类型的变量
public static int factorial(int n){
// 2.在方法内部判断该变量的值是否是1
if (n == 1){
// 是: 返回1
return 1;
}else {
// 不是: 返回n*(n-1)!
return n*factorial(n-1);
}
}
}
案例二: 遍历目录
需求: 给定一个路径(E:\itcast),请通过递归完成遍历该目录下的所有内容，并把所有文件的绝对路径输出在控制台
思路: 1.根据给定的路径创建一个File对象
2.定义一个方法，用于获取给定目录下的所有内容，参数为第1步创建的File对象
3.获取给定的Flie目录下所有的文件或者目录的File数组
4.遍历该File数组，得到每一个File对象
5.判断该File对象是否是目录
是: 递归调用
不是: 获取绝对路径输出在控制台
6.调用方法
package test;
import java.io.File;
public class Test67 {
public static void main(String[] args) {
// 1.根据给定的路径创建一个File对象
File file = new File("E:\itcast");
// 6.调用方法
getAllFilePath(file);
}
// 2.定义一个方法，用于获取给定目录下的所有内容，参数为第1步创建的File对象
public static void getAllFilePath(File file){
// 3.获取给定的Flie目录下所有的文件或者目录的File数组
File[] files = file.listFiles();
// 4.遍历该File数组，得到每一个File对象
if (files != null){
for (File f : files){
// 5.判断该File对象是否是目录
if (f.isDirectory()){
// 是: 递归调用
getAllFilePath(f);
}else {
// 不是: 获取绝对路径输出在控制台
System.out.println(f.getAbsolutePath());
}
}
}
}
}
案例三: 赋值文本文件
需求: 把"E:\itcast\窗里窗外.txt"复制一份到模块目录下的"窗里窗外.txt"
分析: 1.复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源),然后写入到另一个文件中(目的地)
2.数据源:
E:\itcast\窗里窗外.txt---读数据---InputStream---FileInputStream
3.目的地:
myByteStream\窗里窗外.txt---写数据---OutputStream---FileOutPutStream
思路: 1.根据数据源创建字节输入流对象
2.根据目的地创建字节输出流对象
3.读取数据,复制文本文件(一次读一个字节，一次写一个字节)
4.释放资源
package test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test68 {
public static void main(String[] args) throws IOException {
// 1.根据数据源创建字节输入流对象
FileInputStream fis = new FileInputStream("E:\itcast\窗里窗外.txt");
// 2.根据目的地创建字节输出流对象
FileOutputStream fos = new FileOutputStream("myByteStream\窗里窗外.txt");
// 3.读取数据,复制文本文件(一次读一个字节，一次写一个字节)
int b;
while ((b = fis.read()) != -1){
fos.write((char)b);
}
// 4.释放资源
fos.close();
fis.close();
}
}
案例四: 复制图片
需求: 把"E:\itcast\mn.jpg"复制到模块目录下的"mn.jpg"
思路: 1.根据数据源创建字节输入流对象
2.根据目的地创建字节输出流对象
3.读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
4.释放资源
package test;
import com.sun.org.apache.xpath.internal.operations.String;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test69 {
public static void main(String[] args) throws IOException {
// 1.根据数据源创建字节输入流对象
FileInputStream fis = new FileInputStream("E:\itcast\mn.jpg");
// 2.根据目的地创建字节输出流对象
FileOutputStream fos = new FileOutputStream("myByteStream\mn.jpg");
// 3.读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
byte[] bys = new byte[1024];
int len;
while ((len = fis.read(bys)) != -1){
fos.write(bys,0,len);
}
// 4.释放资源
fos.close();
fis.close();
}
}
案例五: 复制视频
需求: 把"E:\itcast\字节流复制图片.avi"复制到模块目录下的"字节流复制图片.avi"
思路: 1.根据数据源创建字节输入流对象
2.根据目的地创建字节输出流对象
3.读写数据，复制视频
4.释放资源
package test;
import java.io.*;
public class Test70 {
public static void main(String[] args) throws IOException {
// 记录开始时间
long startTime = System.currentTimeMillis();
// 复制视频
method1();
method2();
method3();
method4();
// 记录结束时间
long endTime = System.currentTimeMillis();
System.out.println("共耗时:"+(endTime - startTime) + "好眠");
}
// 基本字节流一次读写一个字节
public static void method1() throws IOException {
// 1.根据数据源创建字节输入流对象
FileInputStream fis = new FileInputStream("E:\itcast\字节流复制图片.avi");
// 2.根据目的地创建字节输出流对象
FileOutputStream fos = new FileOutputStream("myByteStream\字节流复制图片.avi");
// 3.读写数据，复制视频
int by;
while ((by = fis.read()) != -1){
fos.write(by);
}
// 4.释放资源
fos.close();
fis.close();
}
// 基本字节流一次读写一个字节数组
public static void method2() throws IOException {
// 1.根据数据源创建字节输入流对象
FileInputStream fis = new FileInputStream("E:\itcast\字节流复制图片.avi");
// 2.根据目的地创建字节输出流对象
FileOutputStream fos = new FileOutputStream("myByteStream\字节流复制图片.avi");
// 3.读写数据，复制视频
byte[] bys = new byte[1024];
int len;
while ((len = fis.read()) != -1){
fos.write(bys,0,len);
}
// 4.释放资源
fos.close();
fis.close();
}
// 字节缓冲流一次读写一个字节
public static void method3() throws IOException {
// 1.根据数据源创建字节输入流对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\itcast\字节流复制图片.avi"));
// 2.根据目的地创建字节输出流对象
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\字节流复制图片.avi"));
// 3.读写数据，复制视频
int by;
while ((by = bis.read()) != -1){
bos.write(by);
}
// 4.释放资源
bos.close();
bis.close();
}
// 字节缓冲流一次读写一个数组
public static void method4() throws IOException {
// 1.根据数据源创建字节输入流对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\itcast\字节流复制图片.avi"));
// 2.根据目的地创建字节输出流对象
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\字节流复制图片.avi"));
// 3.读写数据，复制视频
byte[] bys = new byte[1024];
int len;
while ((len = bis.read()) != -1){
bos.write(bys,0,len);
}
// 4.释放资源
bos.close();
bis.close();
}
}
案例六: 复制Java文件
需求: 把模块目录下的"ConversionStreamDemo.java"复制到模块目录下的"Copy.java"
思路: 1.根据数据源创建字符输入流对象
2.根据目的地创建字符输出流对象
3.读写数据，复制文件
4.释放资源
package test;
import java.io.*;
public class Test71 {
public static void main(String[] args) throws IOException {
// 1.根据数据源创建字符输入流对象
InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\ConversionStreamDemo.java"));
// 2.根据目的地创建字符输出流对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\Copy.java"));
// 3.读写数据，复制文件
// 一次读写一个字符数据
int ch;
while ((ch = isr.read()) != -1){
osw.write(ch);
}
// 一次读写一个字符数组数据
char[] chs = new char[1024];
int len;
while ((len = isr.read()) != -1){
osw.write(chs,0,len);
}
// 4.释放资源
osw.close();
isr.close();
}
}
案例七: 复制Java文件(改进)
需求: 把模块目录下的"ConversionStreamDemo.java"复制到模块目录下的"Copy.java"
分析: 1.转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的,所以，为了简化书写，转换流提供了对应的子类
2.FileReader: 用于读取字符文件的便捷类
FileReader(String fileName)
3.FileWriter: 用于写入字符文件的便捷类
FileWriter(String fileName)
4.数据源和目的地的分析
数据源: myCharStream\ConversionStreamDemo.java---读数据---Reader---InputStreamReader---FileReader
目的地: myCharStream\Copy.java---写数据---Writer---OutputStreamWriter-FileWriter
思路: 1.根据数据源创建字符输入流对象
2.根据目的地创建字符输出流对象
3.读写数据
4.释放资源
package test;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Test72 {
public static void main(String[] args) throws IOException {
// 1.根据数据源创建字符输入流对象
FileReader fr = new FileReader("myCharStream\ConversionStreamDemo.java");
// 2.根据目的地创建字符输出流对象
FileWriter fw = new FileWriter("myCharStream\\Copy.java");
// 3.读写数据
int ch;
while ((ch = fr.read()) != -1){
fw.write(ch);
}
char[] chs = new char[1024];
int len;
while ((len = fr.read()) != -1){
fw.write(chs);
}
// 4.释放资源
fw.close();
fr.close();
}
}
案例八: 复制Java文件(字符缓冲流改进版)
需求: 把模块目录下的"ConversionStreamDemo.java"复制到模块目录下的"Copy.java"
思路: 1.根据数据源创建字符缓冲输入流对象
2.根据目的地创建字符缓冲输出流对象
3.读写数据,复制文件
4.释放资源
package test;
import java.io.*;
public class Test73 {
public static void main(String[] args) throws IOException {
// 1.根据数据源创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("myCharStream\ConversionStreamDemo.java"));
// 2.根据目的地创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\Copy.java"));
// 3.读写数据,复制文件
// 一次读写一个字符数据
int ch;
while ((ch = br.read()) != -1){
bw.write(ch);
}
// 一次读写一个字符数组
char[] chs = new char[1024];
int len;
while ((len = br.read(chs)) != -1){
bw.write(chs,0,len);
}
// 4.释放资源
bw.close();
br.close();
}
}
案例九: 复制Java文件(字符缓冲流特有功能改进版)
需求: 把模块目录下的"ConversionStreamDemo.java"复制到模块目录下的"Copy.java"
思路: 1.根据数据源创建字符缓冲输入流对象
2.根据目的地创建字符缓冲输出流对象
3.读写数据,复制文件
使用字符缓冲流特有功能实现
4.释放资源
package test;
import java.io.*;
public class Test74 {
public static void main(String[] args) throws IOException {
// 1.根据数据源创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("myCharStream\ConversionStreamDemo.java"));
// 2.根据目的地创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\Copy.java"));
// 3.读写数据,复制文件
// 使用字符缓冲流特有功能实现
String line;
while ((line = br.readLine()) != null){
bw.write(line);
}
// 4.释放资源
bw.close();
br.close();
}
}
