黑马程序员——IO流——递归,字节流,字符流

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong>package cn.bolg;

public class Demo {

/**
* 递归求5的阶乘
* 分析：就是求1*2*3*4*5
* 可以看做	5*4的阶乘,4的阶乘就是4*3的阶乘依次类推
* 我们就可以定义求阶乘的方法了
*/
public static void main(String[] args) {
//调用方法
int num = method(5);
System.out.println(num);

}

public static int method(int n){
//确定阶乘出口如果n==1,就返回1
if(n==1){
return 1;
}
//返回n的阶乘的值
return n*method(n-1);

}

}</strong></span>

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong>package cn.bolg;

/*
* 求斐波那契数列第15项的值.斐波那契数列前10项为 1,1,2,3,5,8,13,21,34,55
*
* 分析：1.根据斐波那契数列前10项的值可以得出规律
* 		从第3项开始:  	当前项的值	=  当前项的前一项的值  +  当前项的前一项的前一项值
*
* 	   2.我们使用递归方式求斐波那契数列第n项的值
* 		使用递归我们必须要定义递归方法的出口：
* 								当是第1项和第2项时，返回1
*
*/
public class Demo2 {

public static void main(String[] args) {
// 调用方法获得第15项对应的值
int value = method(15);
// 输出结果
System.out.println("第15项的值为：" + value);
}

// 使用递归方式定义方法,方法中参数为当前的项数
public static int method(int n) {
// 递归出口(当是第1项和第2项时，返回1)
if (n == 1 || n == 2) {
return 1;
}
// 递归调用(当前项的值=当前项的前一项的值 +当前项的前一项的前一项值)
return method(n - 1) + method(n - 2);
}

}
</strong></span>

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong>package cn.bolg;

import java.io.File;

public class Demo3 {

/**
* 递归删除带内容的目录
*/
public static void main(String[] args) {
//创建文件对象
File file = new File("F:\\a");
//调用方法删除目录
delete(file);
}

public static void delete(File file){
//判断文件有无内容
if (file.isDirectory()) {
//将文件对象转成数组
File[] listFiles = file.listFiles();
//遍历文件数组
for (File file2 : listFiles) {
//使用递归操作文件对象
delete(file2);
}
}else{
//如果是文件,直接删除
file.delete();
}
//空文件夹直接删除
file.delete();
}

}
</strong></span>

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong>package cn.bolg;

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

public class Demo4 {

/**
* 使用字节流四种复制方式分别复制文件
* @throws IOException
*/
public static void main(String[] args) throws IOException {
//调用方法进行复制
method1();
method2();
method3();
method4();
}

// 方法一:使用普通字节流一次一个字节复制文件
public static void method1() throws IOException {
// 创建流对象
FileInputStream fis = new FileInputStream("a.txt");
FileOutputStream fos = new FileOutputStream("b.txt");
// 读取数据
int b;
while ((b = fis.read()) != -1) {
// 写出数据
fos.write(b);
}
// 关闭流
fos.close();
fis.close();

}

// 方法二:使用普通字节流一次一个字节数组复制文件
public static void method2() throws IOException {
// 创建流对象
FileInputStream fis = new FileInputStream("a.txt");
FileOutputStream fos = new FileOutputStream("b.txt");
// 读取数据
int len;
byte[] bytes = new byte[1024];
while ((len = fis.read(bytes)) != -1) {
// 写出数据
fos.write(bytes, 0, len);
}
// 关闭流
fos.close();
fis.close();
}

// 方法三:使用缓冲区字节流一次一个字节复制文件
public static void method3() throws IOException {
// 创建流对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.txt"));
// 读取数据
int b;
while ((b = bis.read()) != -1) {
// 写出数据
bos.write(b);
}
// 关闭流
bos.close();
bis.close();
}

// 方法四:使用缓冲区字节流一次一个字节数组复制文件
public static void method4() throws IOException {
// 创建流对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.txt"));
// 读取数据
int len;
byte[] bytes = new byte[1024];
while ((len = bis.read(bytes)) != -1) {
// 写出数据
bos.write(bytes, 0, len);
}
// 关闭流
bos.close();
bis.close();
}

}
</strong></span>

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong>package cn.bolg;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo5 {

/**
* 使用字符流五种复制方式分别复制文本文件
* @throws IOException
*/
public static void main(String[] args) throws IOException {
//调用方法对文本文件进行复制
method1();
method2();
method3();
method4();
method5();
}

// 方法一:使用普通字符流一次一个字符复制文件
public static void method1() throws IOException {
// 创建流对象
FileReader fr = new FileReader("a.txt");
FileWriter fw = new FileWriter("b.txt");
// 读取数据
int c;
while ((c = fr.read()) != -1) {
// 写出数据
fw.write(c);
}
// 关闭流
fw.close();
fr.close();

}

// 方法二:使用普通字符流一次一个字符数组复制文件
public static void method2() throws IOException {
// 创建流对象
FileReader fr = new FileReader("a.txt");
FileWriter fw = new FileWriter("b.txt");
// 读取数据
int len;
char[] chars = new char[1024];
while ((len = fr.read(chars)) != -1) {
// 写出数据
fw.write(chars, 0, len);
}
// 关闭流
fw.close();
fr.close();
}

// 方法三:使用缓冲区字符流一次一个字符复制文件
public static void method3() throws IOException {
// 创建流对象
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
// 读取数据
int c;
while ((c = br.read()) != -1) {
// 写出数据
bw.write(c);
}
// 关闭流
bw.close();
br.close();
}

// 方法四:使用缓冲区字符流一次一个字符数组复制文件
public static void method4() throws IOException {
// 创建流对象
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
// 读取数据
int len;
char[] chars = new char[1024];
while ((len = br.read(chars)) != -1) {
// 写出数据
bw.write(chars, 0, len);
}
// 关闭流
bw.close();
br.close();
}

// 方法五:使用缓冲区字符流一次一行复制文件
public static void method5() throws IOException {
// 创建流对象
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
// 读取数据
String line;
while ((line = br.readLine()) != null) {
// 写出数据
bw.write(line);
//换行
bw.newLine();
}
// 关闭流
bw.close();
br.close();
}

}
</strong></span>

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong>package cn.bolg;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class Test {

/**
* 把集合中的数据存储到文本文件
* @throws IOException
*/
public static void main(String[] args) throws IOException {
//创建字符输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
//创建集合对象
ArrayList<String> al = new ArrayList<String>();
//向集合中添加元素
al.add("奔跑吧兄弟");
al.add("欢乐喜剧人");
al.add("极限挑战");
al.add("极速前进");

//遍历集合
for (String string : al) {
//写入文件中
bw.write(string);
//换行
bw.newLine();
}

//关闭流
bw.close();
}

}
</strong></span>

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong>package cn.bolg;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

public class Test2 {

/**
* 把文本文件中的数据读取到集合并遍历集合
* @throws IOException
*/
public static void main(String[] args) throws IOException {

//创建字符输出流
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
//创建集合
ArrayList<String> al = new ArrayList<String>();

//读取数据
String line;
while ((line= br.readLine())!=null) {
al.add(line);
}

//遍历集合
for (String string : al) {
System.out.println(string);
}

//关闭流
br.close();
}

}
</strong></span>

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong>package cn.bolg;

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

public class Test3 {

/**
* 复制单级文件夹
* @throws IOException
*/
public static void main(String[] args) throws IOException {

//创建两个文件夹对象
File srcDir= new File("a");
File destDir = new File("b");
//调用方法复制单级文件
copyFile(srcDir,destDir);
}

public static void copyFile(File srcDir,File destDir) throws IOException{
//首先判断目标文件夹是否存在
if(!destDir.exists()){
destDir.mkdirs();
}
//将源文件对象转化为文件对象数组
File[] listFiles = srcDir.listFiles();
//遍历文件对象数组,进行复制
for (File file : listFiles) {
//获取源文件和目标文件
File srcFile = file;
File destFile = new File(destDir, srcFile.getName());

//创建流对象
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);

//读取文件数据
int b;
while ((b=fis.read())!=-1) {
//写入文件数据
fos.write(b);
}
//关闭流
fos.close();
fis.close();
}

}

}
</strong></span>

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong>package cn.bolg;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Test4 {

/**
* 复制多级文件夹
* @throws IOException
*/
public static void main(String[] args) throws IOException {
//创建文件对象
File srcDirs = new File("a");
File destDirs = new File("c");

//调用方法复制多级文件夹
copyDirs(srcDirs,destDirs);
}
//定义复制文件夹方法copyDirs
public static void copyDirs(File srcDirs,File destDirs) throws IOException{

if (srcDirs.isDirectory()) {
//首先创建目标文件
File newForld = new File(destDirs,srcDirs.getName());
newForld.mkdirs();
//将源文件文件对象转成文件对象数组
File[] files = srcDirs.listFiles();
//遍历files
for (File file : files) {

copyDirs(file,newForld);
}
}else{
File srcFile = srcDirs;
File destFile = new File(destDirs,srcFile.getName());
copyFile(srcFile,destFile);
}

}

//定义复制文件方法copyFile
public static void copyFile(File srcFile,File destFile) throws IOException{
//创建流对象
BufferedReader  br = new BufferedReader(new FileReader(srcFile));
BufferedWriter bw = new BufferedWriter(new FileWriter(destFile));
//复制文件
//读取数据
int len;
char[] chars = new char[1024];
while ((len= br.read(chars))!=-1) {
//写入数据
bw.write(chars, 0, len);
}

//关闭流
bw.close();
br.close();

}

}
</strong></span>

<span style="font-family:FangSong_GB2312;font-size:18px;"><strong>package cn.bolg;

import java.io.IOException;
import java.io.Reader;

/**
* 用Reader模拟BufferedReader的特有功能
*/
public class Test5 {
//将Reader作为成员变量进行使用
private Reader reader;
//有参构造方法
public Test5(Reader reader) {
super();
this.reader = reader;
}
//定义一次读取一行的方法
public String myReadLine() throws IOException{
//使用字符串缓冲区接收读到的数据
StringBuilder sb = new StringBuilder();
//使用一次读取一个字符的方式
int c;
while ((c=reader.read())!=-1) {
//当字符读出来的是\r时,使用continue语句跳出不做添加
if (c=='\r') {
continue;
}
//当读到\n时,一行读取完毕,返回字符串缓冲区
if(c=='\n'){
return sb.toString();
}
//将读取到的内容存到缓冲区中
sb.append(c);
}
//如果最后一行数据没有\r\n,但是有内容,使用缓冲区长度进行判断,不等于0就返回
if (sb.length()!=0) {
return sb.toString();
}
//最后没有内容就返回null
return null;

}
//定义关闭流的方法
public void close() throws IOException{
reader.close();
}

}
</strong></span>