2019独角兽企业重金招聘Python工程师标准>>>
递归思想
兔子问题
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]);// 6765System.out.println("----------------");int a = 1;int b = 1;for (int x = 0; x < 18; x++) {// 临时变量存储上一次的aint 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");//方式1int by = 0;while((by=fis.read())!=-1) {System.out.print((char)by);}//方式2byte[] 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:BufferedOutputStreamB:BufferedInputStream(7)案例：4种实现A:复制文本文件B:复制图片C:复制视频3:自学字符流IO流分类字节流：InputStreamFileInputStreamBufferedInputStreamOutputStreamFileOutputStreamBufferedOutputStream字符流：ReaderFileReaderBufferedReaderWriterFileWriterBufferedWriter
转载于:https://my.oschina.net/u/2356966/blog/617863
总结
以上是生活随笔为你收集整理的day20-----------IO流（传智视频）的全部内容，希望文章能够帮你解决所遇到的问题。
如果觉得生活随笔网站内容还不错，欢迎将生活随笔推荐给好友。
