day20 递归 IO流
----------------------------------------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
------------------------------------------知识点1----------------------------------------------
package cn.itcast_01;
/*
-
递归：方法定义中条用本身的现象
-
方法的嵌套调用，这不是递归
-
public void show(){
-
if(n<=0){ -
System.exit(0); -
} -
System.out.println(n); -
Show(--n); -
}
-
注意事项：
-
a.递归一定要有出口，否则就是死递归
-
b.递归的次数不能太多，否则就会内存溢出
-
c.构造方法不能递归使用。
-
举例：
-
*/
public class DiGuiDemo {
public static void main(String[] args) {}
}
package cn.itcast_02;
/*
-
需求：请用代码实现求5的阶乘
-
5！ = 12345
-
5！= 5*4！
-
实现方法：
-
1.循环实现
-
2.递归实现
-
*/
public class DiGuiDemo {
public static void main(String[] args) {
int jc = 1;
for(int x=2;x<=5;x++){
jc *=x;
}
System.out.println(“5的阶乘是：”+jc);
System.out.println("------------------");System.out.println("5的阶乘是："+jieCheng(5)); }// 定义递归实现方法
public static int jieCheng(int n){
if(n==1){
return 1;
}else{
return njieCheng(n-1);
}
}
}
------------------------------------------知识点2----------------------------------------------
package cn.itcast_02;
/ -
有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后有生了一对兔子，
-
假如兔子都不死，第20个月的兔子对数是多少。
-
兔子对数 -
第一个月： 1
-
第二个月： 1
-
第三个月： 2
-
第四个月： 3
-
第五个月: 5
-
第六个月： 8
-
…
-
由此可见兔子对象的数据是：
-
1,1,2,3,5,8... -
规则：
-
从第三项其，每一项是前两项之和 -
实现方法：
-
数组实现 -
变量的变化实现 -
递归方法实现 -
*/
public class DiGuiDemo2 {
public static void main(String[] args) {
// 定义一个数组
int [] arr = new int [20];
arr[0]=1;
arr[1]=1;
for(int x=2;x
}
System.out.println(“第20个月兔子的对数：”+arr[19]);
System.out.println("--------------------------");// 变量的变化实现 int a =1; int b =1; for(int x=0;x<18;x++){ int temp =a; a= b; b=temp+b; } System.out.println("第20个月兔子的对数："+b); System.out.println("第20个月兔子的对数："+DiGui(20));}
// 递归实现
/*- 方法：返回值类型：int 参数列表 int n 出口条件：第一个月是1，第二个月是1 规律：从第三个月开始，每个月是前两个月之和。
- */
public static int DiGui(int month){
if(month1|month2){
return 1;
}else{
return DiGui(month-1)+DiGui(month-2);
}
}
}
------------------------------------------知识点3----------------------------------------------
package cn.itcast_03;
import java.io.File;
/*
-
需求：
-
删除带内容的目录 -
目录以给定：demo
-
分析：
-
1.封装目录 -
2.获取该目录下的所有文件或者文件夹的File数组 -
3.遍历该File数组，得到每个File对象 -
4.判断该File对象是否是文件夹 -
是：就回到2 -
否：就删除 -
*/
public class FileDeleteDemo {
public static void main(String[] args) {
// 封装目录
File scrFolder = new File(“Demo”);DeleteFile(scrFolder);}
private static void DeleteFile(File scrFolder) {
// 得到该文件夹下所有文件或文件夹数组
File [] arr = scrFolder.listFiles();// 遍历数组 for(File file:arr){ if(file.isDirectory()){ DeleteFile(file); }else{ System.out.println(file.getName()+"---"+file.delete()); } } System.out.println(scrFolder.getName()+"---"+scrFolder.delete());}
}
------------------------------------------知识点4----------------------------------------------
package cn.itcast_03;
import java.io.File;
/*
-
需求： F:\JAVA\javaSE Workspace下的所有的java结尾的文件的
-
绝对路径输出在控制台。 -
分析：
-
1.封装目录 -
2.获取该目录下所有的文件或者文件夹的File数组 -
3.遍历该File数组，得到每个File对象 -
4.判断该File对象是否是文件夹 -
是：就输出该文件的绝对路径 -
否：不搭理 -
*/
public class FilePathDemo {
public static void main(String[] args) {
// 封装目录
File scrFolder = new File(“F:\JAVA\javaSE Workspace”);// 递归实现功能 getAllJavaFilePaths(scrFolder);}
private static void getAllJavaFilePaths(File scrFolder) {
// 得到该文件夹下所有文件或文件夹数组
File [] arr = scrFolder.listFiles();// 遍历该File数组，得到每个File对象 for(File f:arr){ if(f.isDirectory()){ getAllJavaFilePaths(f); }else{ if(f.getName().endsWith(".java")){ System.out.println(f.getAbsolutePath()); } } }}
}
------------------------------------------知识点5----------------------------------------------
package cn.itcast_01;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import javax.swing.plaf.synth.SynthScrollPaneUI;
/*
-
IO流的分类：
-
流向： -
输入流:读取数据 -
输出流：写出数据 -
数据类型：
-
字节流： -
字节输入流 读取数据 InputStream -
字节输出流 写出数据 OutputStream -
字符流： -
字节输入流 读取数据 Reader -
字符输出流 写出数据 Writer -
注意：一般我们在探讨IO流的时候，如果没有明确说明按照哪种分类来说，
-
默认情况下是按照数据类型来分的。 -
字符流： -
需求：我们要往一个文本文件中输入一句话：hello，io。
-
分析:
-
1.这个操作最好采用字符流来做。但是由于字符流是出现在字节流之后，所以先使用字节流。 -
2.由于我们要在文件中写一句话，所以我们采用字节流输出。 -
字节流输出: FileOutputStream
-
注意：每种基类的子类都是以父类名作为后缀名。
-
XxxOutputStream -
XxxInputStream -
XxxReader -
XxxWriter -
查看FileOutputStream的构造方法：
-
FileOutputStream(File file) -
FileOutputStream(String name) -
*/
public class FileOutputStreamDemo {
public static void main(String[] args) throws IOException {
// 创建字符输出流对象
// FileOutputStream(File file)
//File file = new File(“file.txt”);
//FileOutputStream fos = new FileOutputStream(file);
// FileOutputStream(String name)
FileOutputStream fos2 = new FileOutputStream(“file2.txt”);// 写数据 fos2.write("hello,io".getBytes()); fos2.write("haha".getBytes()); // 释放资源 // 关闭此文件输出流并释放与此流有关的所有系统资源 /* * 释放资源的目的是： * 1.让流对象成为垃圾，这样才可以被垃圾回收器回收 * 2.通知系统释放相关的资源 * * */ fos2.close(); // java.io.IOException: Stream Closed // fos2.write("haha".getBytes()); // 读数据 FileInputStream fis = new FileInputStream("file2.txt"); System.out.println(fis.read()); fis.close();}
}
------------------------------------------知识点6----------------------------------------------
package cn.itcast_01;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
-
字节输出流操作：
-
1.创建字节输出流对象
-
2.调用write()方法
-
3.释放资源
-
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{
// 常见字节输出流对象
FileOutputStream fos = new FileOutputStream(“fos.txt”);// 调用write()方法 // public void write(int b) fos.write(97); // 97 --底层二进制数据--通过记事本打开--找97对应的字符值--a // public void write(byte[] b) byte [] arr = {97,98,99,100}; fos.write(arr); // public void write(byte[] b,int off,int len) fos.write("javaee,hello,world".getBytes(),1,4);}
}
------------------------------------------知识点7----------------------------------------------
package cn.itcast_01;
import java.io.FileNotFoundException;
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”,true);// 写数据 for(int x=0;x<10;x++){ fos.write(("hello"+x).getBytes()); fos.write("\r\n".getBytes()); } // 释放资源 fos.close();}
}
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) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
//
// try {
// fos.write(“java”.getBytes());
// } catch (IOException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// try {
// fos.close();
// } catch (IOException e) {
// // TODO Auto-generated catch block
// 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();
// }
// 改进版
FileOutputStream fos=null;
try{
fos = new FileOutputStream("fos4.txt");
fos.write("java".getBytes());
}catch(FileNotFoundException e){
e.printStackTrace();
}catch(IOException e){
e.printStackTrace();
}finally{
// 保证close()一定会执行，就放到这里了
if(fos!=null){
try {
fos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
------------------------------------------知识点8----------------------------------------------
package cn.itcast_02;
import java.io.FileInputStream;
import java.io.IOException;
/*
- 字节输入流步骤：
- 1.创建字节输入流对象
- 2.创建read()方法读取数据，并把数据显示在控制台
- 3.释放资源
- 读取数据的方式：
-
1.int read():一次读取一个字节 -
2.int read(byte [] b):一次性读取一个字节数组 - */
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException {
// 创建字节输入流对象
FileInputStream fis = new FileInputStream(“fis.txt”);
// // 创建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);
//
// 用循环改进
// int by = fis.read();
// while(by!=-1){
// System.out.print(fis.read());
// System.out.print((char)by);
// by = fis.read();
// }
// System.out.println();
System.out.println("----------------");
// 最终版
int by1 =0;
// 读取，赋值，判断
while((by1 = fis.read())!=-1){
System.out.print((char)by1);
}
// 释放资源
fis.close();
}
}
------------------------------------------知识点9----------------------------------------------
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(“file2.txt”);// 读取数据 // 定义一个字节数组
// byte [] bys = new byte[5];
// int len = fis.read(bys);
// System.out.println(len);
// System.out.print(new String(bys));
//
// len = fis.read(bys);
// System.out.println(len);
// System.out.print(new String(bys));
//
//
// len = fis.read(bys);
// System.out.println(len);
// System.out.print(new String(bys));
//
//
// len = fis.read(bys);
// System.out.println(len);
// System.out.print(new String(bys));
//
//
// len = fis.read(bys);
// System.out.println(len);
// System.out.print(new String(bys));
// 改进版
// byte [] bys = new byte[10];
// int len = 0;
// while((len = fis.read(bys))!=-1){
// System.out.print(new String(bys,0,len));
// //System.out.println(new String(bys));
// }
// 最终代码
// 数组的长度一般是1024或者1024的倍数
byte [] bys = new byte[4];
int len = 0;
while((len = fis.read(bys))!=-1){
System.out.print(new String(bys,0,len));
// System.out.print(new String(bys));
}
// 释放资源
fis.close();
}
}
------------------------------------------知识点10----------------------------------------------
package cn.itcast_03;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
-
赋值文本文件
-
数据源:从哪里来
-
a.txt
-
目的地：到哪里去
-
b.txt
-
java.io.FileNotFoundException: a.txt (系统找不到指定的文件。)
-
*/
public class CopeFileDemo {
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); } // 读取目的地数据 FileInputStream fis2 = new FileInputStream("b.txt"); int by2 =0; while((by2 = fis2.read())!=-1){ System.out.print((char)by2); } // 释放资源 fis.close(); fos.close();}
}
------------------------------------------知识点11----------------------------------------------
package cn.itcast_03;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
-
将E:\ 下的111.jpg文件复制到mn.jpg
-
分析：
-
1.封装数据源 -
2.进行复制操作 -
3.释放资源 -
*/
public class CopeImageDemo {
public static void main(String[] args) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream(“E:\111.jpg”);FileOutputStream fos = new FileOutputStream("mn.jpg"); // 复制操作 int by =0; while((by=fis.read())!=-1){ fos.write(by); } // 释放资源 fis.close(); fos.close();}
}
------------------------------------------知识点12----------------------------------------------
package cn.itcast_03;
import java.util.Arrays;
/*
-
计算机是如何识别什么时候该把两个字节转换成一个中文呢。
-
在计算机中中文的存储分两个 字节：
-
第一个字节肯定是负数 -
第二个字节常见的是负数，可能有正数，但是没影响。 -
*/
public class StringDemo {
public static void main(String[] args) {
String s = “我爱你中国”;byte [] bys = s.getBytes(); System.out.println(Arrays.toString(bys));}
}
package cn.itcast_04;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
-
需求：把E:\a.txt内容复制到F:\b.txt中
-
*/
public class CopeFileDemo {
public static void main(String[] args) throws IOException {
// 封住数据源
FileInputStream fis = new FileInputStream(“E:\a.txt”);
FileOutputStream fos = new FileOutputStream(“F:\b.txt”);// 复制操作 方式1
// int flag =0;
// while((flag=fis.read())!=-1){
// fos.write(flag);
// }
// 复制操作 方式2
byte [] bys =new byte[1024];
int len =0;
while(((len =fis.read(bys)) != -1)){
fos.write(bys,0,len);
}
// 释放资源
fis.close();
fos.close();
}
}
------------------------------------------知识点13----------------------------------------------
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 {
// public BufferedInputStream(InputStream in)
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(“bos.txt”));// 读取数据 方式1
// int flag =0;
// while((flag=bis.read()) !=-1){
// System.out.print((char)flag);
// }
// System.out.println();
// System.out.println("-----------------");
// 读取数据 方式2
byte [] bys = new byte [1024];
int len =0;
while((len=bis.read(bys)) != -1){
System.out.print(new String(bys,0,len));
}
// 释放资源
bis.close();
}
}
------------------------------------------知识点14----------------------------------------------
package cn.itcast_05;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
-
通过定义数组的方式确实比以前一次读取一个字节数据快很多，因此提供了带缓冲区的字节类。
-
这种类被称为：缓冲区类（高效类）
-
构造方法指定了缓冲区的大小，但是我们一般用不上，因为默认缓冲区的大小就足够了。
-
为什么不传递一个具体的文件或者文件路径，而是传递一个OutPputStream对象呢
-
原因很简单：字节缓冲区仅仅提供缓冲区，为高效而设计，但是呢，真正的读写操作还得靠基本的流对象实现。 -
写数据：BufferedOutputStream
-
读数据：BufferedInputStream
-
*/
public class BufferOutputStreamDemo {
public static void main(String[] args) throws IOException {
// public 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(); bos.close();}
}
------------------------------------------知识点15----------------------------------------------
package cn.itcast_06;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
-
需求：将E:\烟花视频.mp4复制到当前目录下Copy.mp4中
-
字节流四种方式复制文件：
-
基本字节流一次读写一个字节
-
基本字节流一次读写一个字节数组
-
高效字节流一次读写一个字节
-
高效字节流一次读写一个字节数组
-
*/
public class CopeMp4Demo {
public static void main(String[] args) throws IOException {
// 方式1 基本字节流一次读写一个字节
method1(“E:\烟花视频.mp4”,“Copy1.mp4”);// 方式 2 基本字节流一次读写一个字节数组 method2("E:\\烟花视频.mp4","Copy2.mp4"); // 方式3 高效字节流一次读写一个字节 method3("E:\\烟花视频.mp4","Copy3.mp4"); // 方式4 高效字节流一次读写一个字节数组 method4("E:\\烟花视频.mp4","Copy4.mp4");}
// 方式1 基本字节流一次读写一个字节
public static void method1(String srcString,String destString) throws IOException{
// 开始时间
long start = System.currentTimeMillis();
System.out.println(“正在复制文件…”);
FileInputStream fis1 = new FileInputStream(srcString);
FileOutputStream fos1 = new FileOutputStream(destString);// 复制数据 int bys = 0; while((bys=fis1.read()) !=-1){ fos1.write(bys); } // 释放资源 fis1.close(); fos1.close(); long end = System.currentTimeMillis(); System.out.println("复制文件结束"); System.out.println("方式1总共消耗时间为："+(end-start)+"毫秒"); System.out.println("---------------------------------");}
// 方式2 基本字节流一次读写一个字节数组
public static void method2(String srcString,String destString) throws IOException{
// 开始时间
long start = System.currentTimeMillis();
System.out.println(“正在复制文件…”);
FileInputStream fis2 = new FileInputStream(srcString);
FileOutputStream fos2 = new FileOutputStream(destString);// 复制数据 byte [] bys = new byte [1024]; int len =0; while((len=fis2.read(bys)) !=-1){ fos2.write(bys,0,len); } // 释放资源 fis2.close(); fos2.close(); long end = System.currentTimeMillis(); System.out.println("复制文件结束"); System.out.println("方式2总共消耗时间为："+(end-start)+"毫秒"); System.out.println("---------------------------------");}
// 方式3 高效字节流一次读写一个字节
public static void method3(String srcString,String destString) throws IOException{
// 开始时间
long start = System.currentTimeMillis();
System.out.println(“正在复制文件…”);
BufferedInputStream bis3 = new BufferedInputStream (new FileInputStream(srcString));
BufferedOutputStream bos3 = new BufferedOutputStream(new FileOutputStream(destString));// 复制数据 int bys =0; while((bys=bis3.read()) !=-1){ bos3.write(bys); } // 释放资源 bis3.close(); bos3.close(); long end = System.currentTimeMillis(); System.out.println("复制文件结束"); System.out.println("方式3总共消耗时间为："+(end-start)+"毫秒"); System.out.println("---------------------------------");}
// 方式3 高效字节流一次读写一个字节数组
public static void method4(String srcString,String destString) throws IOException{
// 开始时间
long start = System.currentTimeMillis();
System.out.println(“正在复制文件…”);
BufferedInputStream bis4 = new BufferedInputStream (new FileInputStream(srcString));
BufferedOutputStream bos4 = new BufferedOutputStream(new FileOutputStream(destString));// 复制数据 byte [] bys = new byte [1024]; int len = 0; while((len=bis4.read(bys)) !=-1){ bos4.write(bys,0,len); } // 释放资源 bis4.close(); bos4.close(); long end = System.currentTimeMillis(); System.out.println("复制文件结束"); System.out.println("方式4总共消耗时间为："+(end-start)+"毫秒"); System.out.println("---------------------------------"); }
}