这一块的内容主要是有关递归和IO流的内容。
递归
什么是递归
方法定义中调用方法本身的现象
Math.max(Math.max(a,b)) 这不是递归，这仅仅只是方法的嵌套使用
注意
- 要有出口，否则就是死递归
- 次数不能太多，否则就内存溢出
- 构造方法不能递归使用
递归小例子
private static void show(int i){
if(i<=0){
System.exit(0);
}
else{
System.out.println(i);
show(--i);
}
}
public static void main(String[] args) {
show(3);
}
举例求一个5的阶乘
public static void main(String[] args) {
int i =1;
for(int j = 2;j<=5;j++){
i *= j;
}
System.out.println(i);
System.out.println("*************");
System.out.println("使用递归实现");
System.out.println("5的阶乘"+recursionFun(5));
}
private static int recursionFun(int i){
if(i == 1){
return 1;
}else{
return recursionFun(i-1)*i;
}
}
求一个斐波那契数列
数列是这样的：1，1，2，3，5，8，13，21
public static void main(String[] args) {
//1,1,2,3,5,8,13,21
//第三个开始，后面的都是前面两个之和 求第二十个数
int []arr = new int[20];
arr[0] = 1;
arr[1] = 1;
for(int i=2;i<arr.length;i++){
arr[i] = arr[i-2]+arr[i-1];
}
System.out.println(arr[arr.length-1]);
System.out.println("***************");
System.out.println(recursion(20));
}
private static int recursion(int i){
int sum = 0;
if(i==1 || i==2){
return 1;
}else{
sum += recursion(i-1) + recursion(i-2);
}
return sum;
}
递归遍历目录下指定后缀名.jpg结尾的文件名称
public static void main(String[] args) {
/*
获取File对象
获取目录下所有文件和文件夹 的 File数组
遍历数组，得到每一个File对象
判断File是否是文件夹
是：重复第二步
不是：判断是否是.jpg文件结尾
是：输出
不是：跳过
*/
File file = new File("D:\\照片。");
getJpgFile(file);
}
private static void getJpgFile(File file){
File[] files = file.listFiles();
for(File e:files){
if(e.isDirectory()){
getJpgFile(e);
}
else{
if (e.getName().endsWith(".jpg")){
System.out.println(e);
}
}
}
}
递归删除带内容的目录
public static void main(String[] args) {
//递归删除带内容的目录
/*
获取File对象
获取该目录下的所有文件和文件夹组成的file数组
遍历数组得到每一个file对象
判断该file对象是否是文件夹
是：返回第二步
不是：直接删除
*/
File file = new File("D:\\demo1");
deleteFileFun(file);
}
private static void deleteFileFun(File file){
File[] files = file.listFiles();
if(files!=null){
for(File f:files){
if (f.isDirectory()){
deleteFileFun(f);
}
else{
f.delete();
}
}
}
}
IO流
用来解决设备之间数据传输的问题
简单一句话：
如果用电脑的笔记本打开能看懂的东西，就用字符流，
笔记本打开看不懂，就用字节流
IO流的分类
- 流向：
- 输入流 读取数据
- 输出流 写出数据
- 数据类型：
- 字节流：
- 字节输入流 读取数据 InputStream
- 字节输出流 写入数据 OutputStream
- 字符流：
- 字符输入流 读取数据 Reader
- 字符输出流 写出数据 Writer
- 字节流：
写出
往文件中写出一个数据
我们现在尝试着往文件中写入一个数据，使用记事本能看懂的，最好用字符流，但我们这里用的是字节流
字节输出流的操作步骤：
1、创建字节输出流对象
2、写入数据
3、释放资源
我们是通过程序写到文本文件，所以这里用的是OutputStream
public static void main(String[] args) throws IOException {
//创建字节输出流对象
File file = new File("a.txt");//文件如果不存在，自动创建
FileOutputStream fileOutputStream = new FileOutputStream(file);
System.out.println(fileOutputStream);
/*
JVM创建字节输出流对象的时候，做了些什么
1、调用系统功能创建文件
2、创建fileOutputStream对象
3、将fileOutputStream对象指向文件
*/
fileOutputStream.write("大数据".getBytes());
/*
为什么需要close文件
1、让流对象变成垃圾，这样垃圾回收器就可以回收它了
2、通知系统去释放跟该文件相关的资源
*/
fileOutputStream.close();
}
JVM创建字节输出流的时候，都做了些什么
- 调用系统功能创建文件
- 创建fileOutputStream对象
- 将fileOutputStream对象指向该文件
为什么需要close文件
- 让流对象变成垃圾，这样垃圾回收器就可以回收它了
- 通知系统去释放跟该文件相关的资源
三种使用字节输出流往文件中写入数据的方式
- public void write(int b)
- public void write(byte[] b)
- public void write(byte[] b,int off,int len)
public static void main(String[] args) throws IOException {
/*
使用字节输出流写数据的方式
1、创建字节输出流对象
2、使用write方法写入数据
3、释放资源
*/
FileOutputStream fileOutputStream = new FileOutputStream("a.txt");
//public void write(int b)
// fileOutputStream.write(97); //a.txt文件中的内容是a，可以看到这种方式，存入的是97的ASCII码
//public void write(byte[] b)
byte[] b = new byte[]{104,105,106};//a.txt中的内容是hij，存入的也是底层的ASCII码
// fileOutputStream.write(b);
//public void write(byte[] b,int off,int len)
fileOutputStream.write(b,0,2);//偏移量，也是ASCII码
}
往文件中追加数据
我们刚才做的操作都是直接覆盖之前的数据，现在我们想往文件中追加数据
如何实现换行
为什么没有换行或者追加呢？因为我们只写了字节，没有写入换行符号
如何实现：在写字节的时候，添加一个换行符
Mac：\r
Window:\r\n
Linux:\n
如何实现对数据的追加
- 追加：在现有文件的内容上添加一些新的内容
- 覆盖：将现有文件内容删除，再添加新的内容
对数据进行了追加
public static void main(String[] args) throws IOException {
FileOutputStream fileOutputStream = new FileOutputStream("a.txt", true);
for(int i=0;i<10;i++){
fileOutputStream.write("大数据".getBytes());
// fileOutputStream.write("\n".getBytes()); //这样也可以
fileOutputStream.write("\r\n".getBytes());
}
fileOutputStream.close();
}
写入
字节输入流的操作步骤
- 创建字节输入对象
- 调用read方法读取数据，并把数据显示在控制台
- 释放资源
两种字节输入流读取数据的方式
- public int read()
- public int read(byte[] b)
第一种，一次只读取一个字符
public static void main(String[] args) throws IOException {
FileInputStream fileInputStream = new FileInputStream("a.txt");
//public int read() 用read方法读取数据，一次只能显示一个字节，返回的是ASCII码，需要强转
// int read = fileInputStream.read();
// System.out.println((char) read);
//
// int read1 = fileInputStream.read();
// System.out.println((char)read1);
//
// int read2 = fileInputStream.read();
// System.out.println((char)read2);
//这里代码的重复度很高，我们可以使用循环改进
//不知道循环多少次，就使用while循环
// int i = fileInputStream.read();
// while (i!=-1){
// System.out.println((char)i);
// i = fileInputStream.read();
// }
//最终改进
int a = 0;
while ((a= fileInputStream.read())!=-1){
System.out.println((char)a);
}
fileInputStream.close();
}
第二种，一次读取一个字符数组
/*
字节输入流读取数据的第二种方式：一次读取一个字符数组
public int read(byte[] b)
从该输入流读取最多b.length字节的数据到字节数组
此方法将阻塞，直到某些输入可用
*/
FileInputStream fileInputStream = new FileInputStream("a.txt");
//定义一个字节数组
// byte[] bytes = new byte[8];
// //一旦调用这个方法，将数组大小的字节内容保存到数组中，返回的是保存的字节个数
// int read = fileInputStream.read(bytes);
// System.out.println(read); //返回的是保存的字节个数
// System.out.println("*********");
// for(byte b:bytes){
// System.out.println((char) b);
// }
//
// //将字节数组转换成字符串
// System.out.println(new String(bytes));
// System.out.println(new String(bytes,0,bytes.length));
//最终版本
byte[] bytes = new byte[1024];
int length = 0;
while ((length = fileInputStream.read(bytes))!=-1){
System.out.println(new String(bytes,0,length));
}
}
文件的复制
public static void main(String[] args) throws IOException {
/*
复制文件
数据源：从哪里来
a.txt -- 读取数据 -- FileInputStream
目的地：到哪里去
b.txt -- 写出数据 -- FileOutputStream
之前我们都是获取到一个字节数据，如何转换成字符数据，输出到控制台
这次我们虽然也是读取到一个字节，但我们用字节输出流去写文件的时候，没有做任何转换
它会字节转换
*/
//创建字节输入流
FileInputStream fileInputStream = new FileInputStream("a.txt");
//创建字节输出流
FileOutputStream fileOutputStream = new FileOutputStream("aCopy.txt");
int b = 0;
while ((b = fileInputStream.read())!=-1){
System.out.println((char)b);
fileOutputStream.write(b);
}
fileOutputStream.close();
fileInputStream.close();
}
照片的复制
public static void main(String[] args) throws IOException {
FileInputStream fileInputStream = new FileInputStream("D:\\照片。\\祥哥.jpg");
FileOutputStream fileOutputStream = new FileOutputStream("祥哥.jpg");
int b = 0;
while ((b = fileInputStream.read()) != -1){
fileOutputStream.write(b);
}
fileOutputStream.close();
fileInputStream.close();
}
然后就会出现祥哥的照片。
缓冲区类（高效类）
我们可以看到，在使用字节输入输出流的时候，复制照片或者视频的时候，速度非常慢，这里我们使用字节缓冲流
- 字节缓冲输出流
BufferedOutputStream - 字节缓冲输入流
BufferedInputStream
字节缓冲输出流
BufferedOutputStream中要传入一个OutputStream的具体的子类实现对象
public static void main(String[] args) throws IOException{
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("a.txt"));
bufferedOutputStream.write("大数据yyds".getBytes());
bufferedOutputStream.close();
}
字节缓冲输入流
输入到控制台：
public static void main(String[] args) throws IOException {
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("a.txt"));
byte[] bytes = new byte[1024];
int len = 0;
while ((len = bufferedInputStream.read(bytes)) != -1){
System.out.println(new String(bytes,0,len));
}
bufferedInputStream.close();
}
}//大数据yyds
输入到另一个文件：
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("a.txt"));
// byte[] bytes = new byte[1024];
// int len = 0;
// while ((len = bufferedInputStream.read(bytes)) !=-1){
// System.out.println(new String(bytes,0,len));
// }
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("aCopy.txt"));
int len = 0;
while ((len = bufferedInputStream.read()) != -1){
bufferedOutputStream.write(len);
}
bufferedOutputStream.close();
bufferedInputStream.close();
}
}//大数据yyds
感谢阅读，我是啊帅和和，一位大数据专业即将大四学生，祝你快乐。