第二十一天 IO-递归&字节流&字符流【悟空教程】
第21天 IO
递归就是“在一个方法内可以再次调用自身”,如下,method方法又调用了method方法。
public class Demo {
public static void main(String[] args) {
method();
}
private static void method() {
System.out.println("调用method()");
method();
}
}
上面的程序运行后,控制台会一直打印:调用method();当然,运行不久就会看到JVM抛出“堆栈溢出异常”——它类似于“无限循环”,但它比循环更消耗内存;
递归方法开始调用后,在内存中会存在多个method方法,每个method方法均会等待它调用的method方法执行完毕,自己才会执行完毕。
/*
* 递归: 方法自己调用自己 .
* public void fun(){
* fun();
* }
*/
public class Demo {
public static void main(String[] args) {
story();
}
static int count = 0;
public static void story() {
count++;
System.out.println("从前有座山");
System.out.println("山里有个庙");
System.out.println("庙里有个老和尚给小和尚讲故事");
System.out.println("讲什么呢? ");
System.out.println(count);
story();
}
}
public static void main(String[] args) {
int max = 5;
int num = 1;
int result = 1;
while(num <= max){
result *= num;
num++;
}
System.out.println("result = " + result);
}
算法分析:
5! = 5 * 4!;
4! = 4 * 3!;
3! = 3 * 2!;
2!= 2 * 1!;
1! = 1;
先求1的阶乘,再求2的阶乘......求5的阶乘;
代码:
public static void main(String[] args) {
System.out.println("递归结果:" + jieCheng(5));
}
public static int jieCheng(int num){
if(num == 1){
return 1;
}
return num * jieCheng(num - 1);
}
递归分为两种,直接递归和间接递归。
直接递归称为方法自身调用自己。间接递归可以A方法调用B方法,B方法调用C方法,C方法调用A方法。
public class DiGuiDemo {
public static void main(String[] args) {
//计算1~num的和,使用递归完成
int n = 5;
int sum = getSum(n);
System.out.println(sum);
}
public static int getSum(int n) {
if(n == 1){
return 1;
}
return n + getSum(n-1);
}
}
注意:递归一定要有条件限定,保证递归能够停止下来,否则会发生栈内存溢出。
在递归中虽然有限定条件,但是递归次数不能太多。否则也会发生栈内存溢出。
编写一个方法用来打印指定目录中的文件路径,并进行方法的调用
要求:若指定的目录有子目录,那么把子目录中的文件路径也打印出来
步骤:
public class FileDemo2 {
public static void main(String[] args) {
File file = new File("d:\\test");
getFileAll(file);
}
//获取指定目录以及子目录中的所有的文件
public static void getFileAll(File file) {
File[] files = file.listFiles();
//遍历当前目录下的所有文件和文件夹
for (File f : files) {
//判断当前遍历到的是否为目录
if(f.isDirectory()){
//是目录,继续获取这个目录下的所有文件和文件夹
getFileAll(f);
}else{
//不是目录,说明当前f就是文件,那么就打印出来
System.out.println(f);
}
}
}
}
回想之前写过的程序,数据都是在内存中,一旦程序运行结束,这些数据都没有了,等下次再想使用这些数据,可是已经没有了。那怎么办呢?能不能把运算完的数据都保存下来,下次程序启动的时候,再把这些数据读出来继续使用呢?其实要把数据持久化存储,就需要把内存中的数据存储到内存以外的其他持久化设备(硬盘、光盘、U盘等)上。
当需要把内存中的数据存储到持久化设备上这个动作称为输出(写)Output操作。
当把持久设备上的数据读取到内存中的这个动作称为输入(读)Input操作。
因此我们把这种输入和输出动作称为IO操作。
按照流向分:输入流与输出流,每个IO流对象均要绑定一个IO资源
按照类型分:常以字节流与字符流区分
分类关系如下:
在数据传输过程中,一切数据(文本、图像、声音等)最终存储的均为一个个字节,即二进制数字。所以数据传输过程中使用二进制数据可以完成任意数据的传递。
我们向一个文件中存储一定数据(一些数字),如果使用文本方式打开,则会以文本的方式解释数据。如果以视频的方式打开,则会以视频的方式解释数据。音频、可行执行文件等亦是如此。所以,在文件传输过程中,我们要时刻明确,传输的始终为数据。
输出流:OutputStream(抽象类):FileOutputStream(基本输出流)
构造方法:需要绑定IO资源
public FileOutputStream(String name) 创建覆盖写出对象
public FileOutputStream(String name,boolean append) 创建指定是否追加写出对象
其他方法: 写出时,如果没有该文件对象,会自动创建文件对象
write(int n):输出一个字节;(使用int替代了byte)
write(byte[] b):输出一个字节数组;
write(byte[] b, int off , int len):输出字节数组的一部分;
flush():刷新此输出流并强制写出所有缓冲的输出字节;
close(): 由于每个IO流都需要绑定一个IO资源,在使用时,需要回收资源
OutputStream有很多子类,其中子类FileOutputStream可用来写入数据到文件。
FileOutputStream类,即文件输出流,是用于将数据写入 File的输出流。
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 字节输出流
* FileOutputStream(File file) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
* FileOutputStream(String name) 创建一个向具有指定名称的文件中写入数据的输出文件流。
*
*/
public class Demo2 {
public static void main(String[] args) throws IOException {
//创建 字节输出流 对象.
FileOutputStream fos = new FileOutputStream("aaa.txt");
// 写出数据
fos.write(97);
// 关闭资源 , 必须做.
fos.close();
}
}
public class FileOutputStreamDemo {
public static void main(String[] args) throws IOException {
//需求:将数据写入到文件中。
//创建存储数据的文件。
File file = new File("c:\\file.txt");
//创建一个用于操作文件的字节输出流对象。一创建就必须明确数据存储目的地。
//输出流目的是文件,会自动创建。如果文件存在,则覆盖。
FileOutputStream fos = new FileOutputStream(file);
//调用父类中的write方法。
byte[] data = "abcde".getBytes();
fos.write(data);
//关闭流资源。
fos.close();
}
}
我们直接new FileOutputStream(file)这样创建对象,写入数据,会覆盖原有的文件,那么我们想在原有的文件中续写内容怎么办呢?
继续查阅FileOutputStream的API。发现在FileOutputStream的构造函数中,可以接受一个boolean类型的值,如果值true,就会在文件末位继续添加。
public class FileOutputStreamDemo2 {
public static void main(String[] args) throws Exception {
File file = new File("c:\\file.txt");
FileOutputStream fos = new FileOutputStream(file, true);
String str = "\r\n"+"fdm";
fos.write(str.getBytes());
fos.close();
}
}
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 1.创建流对象
* 2.写出数据
* 3.关闭流资源
*
* 当使用流对象 ,写出数据到一个文件时, 原来文件中的内容会被清掉.新的数据 写出.
*
* 为了解决这个问题.
* FileOutputStream(String name, boolean append) 创建一个向具有指定 name 的文件中写入数据的输出文件流。
*/
public class Demo3 {
public static void main(String[] args) throws IOException {
//fun();
//fun2();
//追加数据
//创建流对象
FileOutputStream fos = new FileOutputStream("ccc.txt" , true ); // true 表示可以追加 .
//写出数据
fos.write(65);
// 关闭 资源
fos.close();
}
private static void fun2() throws FileNotFoundException, IOException {
// * 1.创建流对象
FileOutputStream fos = new FileOutputStream("ccc.txt");
// * 2.写出数据
String s = "hello io " ;
byte[] bytes = s.getBytes();
fos.write(bytes);
// * 3.关闭流资源
fos.close();
}
private static void fun() throws FileNotFoundException, IOException {
// 1.创建流对象
FileOutputStream fos = new FileOutputStream("bbb.txt");
// 2.写出数据
fos.write(98);
fos.write(99);
fos.write(100);
fos.write(101);
// 3.关闭流资源
fos.close();
}
}
输入流:InputStream(抽象类):FileInputStream(基本输入流)
构造方法:需要绑定IO资源
public FileInputStream(String name)
其他方法:读取时,返回数据时,使用int替代了byte
int read():读取一个字节, 返回的是字节内容本身,读取到末尾返回-1
int read(byte[] b):读取一个字节数组
close(): 由于每个IO流都需要绑定一个IO资源,在使用时,需要回收资源
InputStream有很多子类,其中子类FileInputStream可用来读取文件内容。
FileInputStream 从文件系统中的某个文件中获得输入字节。
在读取文件中的数据时,调用read方法,实现从文件中读取数据
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
* 字节输入流
* 构造方法 FileInputStream(String name)
*
* 字节流在读取数据的时候,字节类型的数据会被提升为int类型, 读取到文件结尾,返回 -1.
*/
public class Demo {
public static void main(String[] args) throws IOException {
//fun();
//创建 字节输入流
FileInputStream fis = new FileInputStream("bbb.txt");
// 读取数据
int i = fis.read();
System.out.println((char) i);
i = fis.read();
System.out.println((char) i);
i = fis.read();
System.out.println((char) i);
i = fis.read();
System.out.println((char) i);
i = fis.read();
System.out.println(i);
i = fis.read();
System.out.println(i);
i = fis.read();
System.out.println(i);
i = fis.read();
System.out.println(i);
// 关闭资源
fis.close();
}
private static void fun() throws FileNotFoundException, IOException {
//创建 字节输入流
FileInputStream fis = new FileInputStream("aaa.txt");
// 读取一个字节
int i = fis.read();
System.out.println(i); // i 就表示你读取到数据.
char ch =(char)i; // 基本的类型强制转换.
System.out.println(ch);
// 关闭资源
fis.close();
}
}
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
* 循环读取文件.
*
* 1.创建输入流对象
* 2.读取文件 read
* 3.关闭资源
*/
public class Demo2 {
public static void main(String[] args) throws IOException {
// * 1.创建输入流对象
FileInputStream fis = new FileInputStream("ccc.txt");
// * 2.读取文件 read
//定义 变量.保存读取的字节数据.
int i ;
while ((i=fis.read())!=-1) {
System.out.println((char)i);
}
// * 3.关闭资源
fis.close();
}
}
在读取文件中的数据时,调用read方法,每次只能读取一个,太麻烦了,于是我们可以定义数组作为临时的存储容器,这时可以调用重载的read方法,一次可以读取多个字符。
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
* 使用字节数组读取文件. 提高读取的效率
*
* 使用数组读取,每一个都把数据添加到数组中返回, 返回值 len ,表示当前次读取到的有效字符数.
*/
public class Demo3 {
public static void main(String[] args) throws IOException {
// 创建输入流对象
FileInputStream fis = new FileInputStream("aaa.txt");
// 使用字节数组读取.
byte[] b = new byte[2];
int len = fis.read(b); // 每一次读取, 会向 字节数组中,添加2个字节
//打印 读取的数据
System.out.print((char)b[0]);
System.out.println((char)b[1]);
System.out.println(len);
System.out.println("===========");
len = fis.read(b);
System.out.print((char)b[0]);
System.out.println((char)b[1]);
System.out.println(len);
System.out.println("===========");
len = fis.read(b);
System.out.print((char)b[0]);
System.out.println((char)b[1]);
System.out.println(len);
// 关闭资源
fis.close();
}
}
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* len 有效字节数组 ,
*
*/
public class Demo4 {
public static void main(String[] args) throws IOException {
// 创建流对象
FileInputStream fis = new FileInputStream("aaa.txt");
FileOutputStream fos = new FileOutputStream("aaa2.txt");
// 操作数据
byte[] b = new byte[2]; // 建议 1024的整数倍. 2,4, 8 .
int len; // 有效字节 数. 如果是文件结尾 返回 -1
while (( len = fis.read(b))!=-1) {
fos.write(b , 0 , len); // b 表示 存数据的数组, 0 表示开始的位置, len 有效字符个数
}
// 关闭资源
fos.close();
fis.close();
}
}
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 边读边写,复制文本文件.
*
* 1.创建流对象. 输入和输出流
* 2.操作数据 . 读取数据和写出数据
* 3.关闭资源 . 关两个流.
*/
public class Demo {
public static void main(String[] args) throws IOException {
// copy_txt();
// copy_pic();
// copy_pic2();
// 创建 流对象
FileInputStream fis = new FileInputStream("hi.jpg");
FileOutputStream fos = new FileOutputStream("hi2.jpg");
// 读写数据, 使用 数组 .
byte[] b = new byte[1024];
int len ;
// 循环读取
while ((len = fis.read(b))!=-1) {
fos.write(b, 0, len);
}
// 关闭资源
fos.close();
fis.close();
System.out.println("高效复制完毕");
}
private static void copy_pic2() throws FileNotFoundException, IOException {
FileInputStream fis = new FileInputStream("hi.jpg");
FileOutputStream fos = new FileOutputStream("hi_copy.jpg");
int b;
while ((b = fis.read()) != -1) {
fos.write(b);
}
fos.close();
fis.close();
System.out.println("复制图片完毕");
}
private static void copy_pic() throws FileNotFoundException, IOException {
FileInputStream fis = new FileInputStream("aa.jpg");
FileOutputStream fos = new FileOutputStream("aa_copy.jpg");
int b;
while ((b = fis.read()) != -1) {
fos.write(b);
}
fos.close();
fis.close();
System.out.println("复制图片完毕");
}
private static void copy_txt() throws FileNotFoundException, IOException {
// 创建流对象
FileInputStream fis = new FileInputStream("ccc.txt");
FileOutputStream fos = new FileOutputStream("E:\\ccc.txt");
// 操作数据
int i;
// 读取数据
while ((i = fis.read()) != -1) {
// 写出数据
fos.write(i);
}
// 关闭资源 . 后开先关, 先开后关.
fos.close();
fis.close();
System.out.println("复制文件完毕");
}
}
原理;读取一个已有的数据,并将这些读到的数据写入到另一个文件中。
public class CopyFileTest {
public static void main(String[] args) throws IOException {
//1,明确源和目的。
File srcFile = new File("c:\\YesDir\test.JPG");
File destFile = new File("copyTest.JPG");
//2,明确字节流 输入流和源相关联,输出流和目的关联。
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
//3, 使用输入流的读取方法读取字节,并将字节写入到目的中。
int ch = 0;
while((ch=fis.read())!=-1){
fos.write(ch);
}
//4,关闭资源。
fos.close();
fis.close();
}
}
上述代码输入流和输出流之间是通过ch这个变量进行数据交换的。
上述复制文件有个问题,每次都从源文件读取一个,然后在写到指定文件,接着再读取一个字符,然后再写一个,一直这样下去。效率极低。
上述代码复制文件效率太低了,并且频繁的从文件读数据,和写数据,能不能一次多把文件中多个数据都读进内容中,然后在一次写出去,这样的速度一定会比前面代码速度快。
public class CopyFileByBufferTest {
public static void main(String[] args) throws IOException {
File srcFile = new File("c:\\YesDir\test.JPG");
File destFile = new File("copyTest.JPG");
// 明确字节流 输入流和源相关联,输出流和目的关联。
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
//定义一个缓冲区。
byte[] buf = new byte[1024];
int len = 0;
while ((len = fis.read(buf)) != -1) {
fos.write(buf, 0, len);// 将数组中的指定长度的数据写入到输出流中。
}
// 关闭资源。
fos.close();
fis.close();
}
}
在IO开发过程中,我们传输最频繁的数据为字符,而以字节方式传输字符需要每次将字符串转换成字节再处理,而且也丧失了程序员对数据内容的判断(因为程序员只认识字符,不认识字节)。所以,为了让程序员方便对字符进行操作,Java提供了专门以字符作为操作单位的类——字符流,其底层仍然为字节流。
显然,字符流只能操作字符,无法操作其他数据,如声音、视频等。
既然有专门用于读取字符的流对象,那么肯定也有写的字符流对象,查阅API,发现有一个Writer类,Writer是写入字符流的抽象类。其中描述了相应的写的动作。
查阅FileOutputStream的API,发现FileOutputStream 用于写入诸如图像数据之类的原始字节的流。要写入字符流,请考虑使用 FileWriter。
打开FileWriter的API介绍。用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节高效区大小都是可接受的。
public class Demo01FileWriter {
public static void main(String[] args) throws IOException {
//创建输出流对象
FileWriter fw = new FileWriter("d:\\a.txt");
/*
* 创建输出流对象做了哪些事情:
* A:调用系统资源创建了一个文件
* B:创建输出流对象
* C:把输出流对象指向文件
*/
//调用输出流对象的写数据的方法
//写一个字符串数据
fw.write("IO流你好");
//数据没有直接写到文件,其实是写到了内存缓冲区
fw.flush();
//释放资源
//通知系统释放和该文件相关的资源
fw.close();
//while(true) {}
}
}
flush():将流中的高效区高效的数据刷新到目的地中,刷新后,流还可以继续使用。
close():关闭资源,但在关闭前会将高效区中的数据先刷新到目的地,否则丢失数据,然后在关闭流。流不可以使用。如果写入数据多,一定要一边写一边刷新,最后一次可以不刷新,由close完成刷新并关闭。
public class Demo02FileWriter {
public static void main(String[] args) throws IOException {
//创建输出流对象
//FileWriter fw = new FileWriter("d:\\a.txt");
FileWriter fw = new FileWriter("a.txt");
//调用输出流对象的写数据方法,并刷新缓冲区
fw.write("helloworld");
fw.flush();
fw.write("java");
fw.flush();
//释放资源
fw.close();
//Stream closed
//fw.write("javaee");
//fw.flush();
}
}
public class Demo03FileWriter {
public static void main(String[] args) throws IOException {
//创建输出流对象
FileWriter fw = new FileWriter("b.txt");
//void write(String str):写一个字符串数据
fw.write("abcde");
//void write(String str,int index,int len):写一个字符串中的一部分数据, index:开始索引,len:写几个
fw.write("abcde",0,5);
fw.write("abcde",1,3);
//void write(int ch):写一个字符数据,这里写int类型的好处是既可以写char类型的数据,也可以写char对应的int类型的值。'a',97
fw.write('a');
fw.write(97);
//void write(char[] chs):写一个字符数组数据
char[] chs = {'a','b','c','d','e'};
//fw.write(chs);
//void write(char[] chs,int index,int len):写一个字符数组的一部分数据, index:开始索引,len:写几个
fw.write(chs,0,5);
fw.write(chs,2,3);
//释放资源
fw.close();
}
}
true:可以续写
false:不能续写,覆盖之前的文件
public class Demo01FileReader {
public static void main(String[] args) throws IOException {
//创建输入流对象
//FileReader fr = new FileReader("fr.txt");
FileReader fr = new FileReader("Demo01FileWriter.java");
//调用输入流对象的读数据方法
//int read():一次读取一个字符
int ch;
/*
* while循环的条件表达式一共做了3件事情
* 1:fr.read() 读取一个字符
* 2:ch=fr.read() 把读取的字符赋值给ch
* 3:ch != -1 判断ch是否为-1
*/
while((ch=fr.read())!=-1) {
//System.out.println(ch);
//System.out.println((char)ch);
System.out.print((char)ch);
}
//释放资源
fr.close();
}
}
查阅FileInputStream的API,发现FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流,请考虑使用 FileReader。
打开FileReader的API介绍。用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节高效区大小都是适当的
public class CharStreamDemo {
public static void main(String[] args) throws IOException {
//给文件中写中文
writeCNText();
//读取文件中的中文
readCNText();
}
//读取中文
public static void readCNText() throws IOException {
FileReader fr = new FileReader("D:\\test\\cn.txt");
int ch = 0;
while((ch = fr.read())!=-1){
//输出的字符对应的编码值
System.out.println(ch);
//输出字符本身
System.out.println((char)ch);
}
}
//写中文
public static void writeCNText() throws IOException {
FileOutputStream fos = new FileOutputStream("D:\\test\\cn.txt");
fos.write("a奋斗蒙教程".getBytes());
fos.close();
}
}
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/*
* 字符流 :读取文本文件
*
* 字符输入流 Reader 的子类, FileReader .
*/
public class Demo {
public static void main(String[] args) throws IOException {
//fun();
// 循环读取
FileReader fr = new FileReader("ddd.txt");
int c ;
while (( c = fr.read())!=-1) {
System.out.print((char)c);
}
fr.close();
}
private static void fun() throws FileNotFoundException, IOException {
//创建字符输入流对象
FileReader fr = new FileReader("ddd.txt");
// 读取数据
int c = fr.read(); // 读取一次,返回一个字符.
System.out.println((char)c); //20320 你
c = fr.read();
System.out.println((char)c); //22909 好
c = fr.read();
System.out.println(c);
// 关闭资源
fr.close();
}
}
public class Demo01CopyFile {
public static void main(String[] args) throws IOException {
//创建输入流对象
FileReader fr = new FileReader("Demo01FileWriter.java");
//创建输出流对象
FileWriter fw = new FileWriter("Copy.java");
//读写数据
int ch;
while((ch=fr.read())!=-1) {
fw.write(ch);
}
//释放资源
fw.close();
fr.close();
}
}
public class Demo02FileReader {
public static void main(String[] args) throws IOException {
//创建输入流对象
//FileReader fr = new FileReader("fr2.txt");
FileReader fr = new FileReader("FileWriterDemo.java");
//调用输入流对象的读数据方法
//int read(char[] cbuf):一次读取一个字符数组的数据,返回的是实际读取的字符个数
char[] chs = new char[1024]; //这里可以是1024及其整数倍
int len;
/*
* while循环的条件表达式一共做了3件事情
* 1:fr.read(chs) 把数据读取到数组中
* 2:len=fr.read(chs) 把读取的有效个数赋值给len
* 3:len != -1 判断读取的有效个数是否为-1
*/
while((len=fr.read(chs))!=-1) {
System.out.print(new String(chs,0,len));
}
//释放资源
fr.close();
}
}
public class Demo02CopyFile {
public static void main(String[] args) throws IOException {
//创建输入流对象
FileReader fr = new FileReader("Demo01FileWriter.java");
//创建输出流对象
FileWriter fw = new FileWriter("Copy.java");
//读写数据
char[] chs = new char[1024];
int len;
while((len=fr.read(chs))!=-1) {
fw.write(chs, 0, len);
}
//释放资源
fw.close();
fr.close();
}
}
题目:
1) 定义类Test1,定义main()方法,按以下要求编写代码:
2) 定义类Test2,定义main()方法,按以下要求编写代码:
3) 定义类Test3,定义main()方法,按以下要求编写代码:
题目:
1) 定义类Test4,定义main()方法,按以下要求编写代码:
2) 定义类Test5,定义main()方法,按以下要求编写代码:
题目:
1) 定义类Test6,定义main()方法,按以下要求编写代码:
2) 定义类Test7,定义main()方法,按以下要求编写代码:
定义类Test1,定义main()方法,按以下要求编写代码:
定义类Test2,定义main()方法,按以下要求编写代码:
定义类Test3,定义main()方法,按以下要求编写代码:
a文件夹下有多个文件,没有文件夹,将a文件夹中的所有内容,复制到b文件夹中即可。
建议方法声明:
public static void copyDir(File srcDir,File destDir) {
将srcDir文件夹的内容,复制到destDir文件夹中
}
注意:a文件夹中还会有2级、3级、n级目录,每级目录内容均要被复制。
定义类,定义main()方法,按以下要求编写代码:
package day10_Test基础练习题;
import java.io.File;
public class Test001 {
/*
* 7)定义类,定义main()方法,按以下要求编写代码:
l构造一个File对象,指向你D盘的某个目录;
l使用递归的方式获取这个目录下所有的子目录的名字;
*/
public static void main(String[] args) {
File file = new File("D:\\Haozip");
dayin(file);
}
public static void dayin(File file){
File[] files = file.listFiles();
for (File file2 : files) {
if(file2.isDirectory()){
dayin(file2);
}else{
System.out.println(file2);
}
}
}
}
答案:
public class Prog21{
public static void main(String[] args){
long sum = 0;
for(int i=0;i<20;i++)
sum += factorial(i+1);
System.out.println(sum);
}
//阶乘
private static long factorial(int n){
int mult = 1;
for(int i=1;i<n+1;i++)
mult *= i;
return mult;
}
}
答案:
public class CopyTextFile {
public static void main(String[] args) throws IOException {
//数据源
String srcPath = "a.txt";
//目的地
String destPath = "b.txt";
method(srcPath,destPath);
}
//字符流: 一次一个字符数组
public static void method(String srcPath, String destPath) throws IOException {
FileReader fr = new FileReader(srcPath);
FileWriter fw = new FileWriter(destPath);
//读
char[] buffer = new char[1024];
int len = 0;
while((len = fr.read(buffer)) != -1){
//写
fw.write(buffer, 0, len);
}
fr.close();
fw.close();
}
}
答案:
public static void main(String[] args) throws IOException {
//创建ArrayList集合
ArrayList<Integer> arr = new ArrayList<>();
//获取随机数
Random r = new Random();
for (int i = 0; i < 20; i++) {
int nextInt = r.nextInt(900)+100;
arr.add(nextInt);
}
//遍历获取的随机数并存入number.txt文件中
//1.创建字符输出流,FileWriter;
FileWriter fw = new FileWriter("number.txt");
//2.遍历符合条件的数据
for (int i = 0; i < arr.size(); i++) {
//判断条件
if(arr.get(i)%3==0){
//
Integer integer = arr.get(i);
fw.write(integer+",");
fw.flush();
}
}
//关闭流
fw.close();
}
答案:
public static void main(String[] args) throws IOException {
String str = "悟空教程_我是一名程序员";
//将str写入到“srcPath.txt”中,并关流
FileWriter fw = new FileWriter("srcPath.txt");
fw.write(str);
fw.close();
//创建并获取源文件和目的文件路径
FileReader srcPath = new FileReader("srcPath.txt");
FileWriter destPath = new FileWriter("destPath.txt");
//调用copyFile方法
copyFile(srcPath, destPath);
}
public static void copyFile(FileReader srcPath,FileWriter destPath) throws IOException{
char[] ch = new char[1024];
int len = 0;
while((len=srcPath.read(ch))!=-1){
//在索引5取元素,长度为7
destPath.write(ch, 5, 7);
}
//关流
srcPath.close();
destPath.close();
}
package day10_Test拓展三道编程题;
public class Test001 {
//使用递归,遍历 1 至100之间的每个数字
public static void main(String[] args) {
test(100);
}
public static void test(int num){
if(num >= 1){
System.out.println(num);
num--;
test(num);
}
}
}
package day10_Test拓展三道编程题;
import java.io.File;
import java.util.Scanner;
public class Test002 {
//键盘录入一个路径,如果不是文件夹,并且是.java文件,那么把文件更改为.txt文件
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个文件路径:");
String path = sc.nextLine();
//封装为文件对象
File file = new File(path);
if(file.isDirectory()){
System.out.println("这是文件夹");
} else {
String name = file.getAbsolutePath();
//判断文件名
if(name.endsWith(".java")){
//新文件的名字
String newName = name.replace(".java", ".txt");
//创建新文件对象
File newFile = new File(newName);
boolean b = file.renameTo(newFile);
System.out.println("修改成功?" + b);
} else {
System.out.println("不是.java文件");
}
}
}
}
package day10_Test拓展三道编程题;
import java.io.File;
public class Test003 {
//给定一个文件夹,递归打印这个文件夹下的所有.java文件的绝对路径(包含子文件夹)
public static void main(String[] args) {
File file = new File("D:/Java/JavaSE/2016/javahelp0505/day23");
changeJavaToText(file);
}
private static void changeJavaToText(File file) {
//取出当前目录下所有的子级
File[] sons = file.listFiles();
//循环遍历所有子级
for(File son : sons){
//如果是文件夹
if(son.isDirectory()){
changeJavaToText(son);
} else {
String name = son.getAbsolutePath();
if(name.endsWith(".java")){
System.out.println(name);
}
}
}
}
}
答案:
public class CopyVideo {
public static void main(String[] args) throws IOException {
method("D:\\video01.avi", "D:\\video02.avi");
}
//字节流,一次可以一个字节一个字节的读写,但是效率太低,因此在这一次一个字节数组
public static void method(String srcPath, String destPath) throws IOException {
FileInputStream fis = new FileInputStream(srcPath);
FileOutputStream fos = new FileOutputStream(destPath);
//读取数据
byte[] buffer = new byte[1024];
int len = 0;
while( (len=fis.read(buffer)) != -1){
//写数据到目的地
fos.write(buffer, 0, len);
}
fos.close();
fis.close();
}
}
答案:
public class CopyTextFile {
public static void main(String[] args) throws IOException {
//数据源
String srcPath = "a.txt";
//目的地
String destPath = "b.txt";
method(srcPath,destPath);
}
//字节流:
public static void method(String srcPath, String destPath) throws IOException {
FileInputStream fis = new FileInputStream(srcPath);
FileOutputStream fos = new FileOutputStream(destPath);
//读
byte[] buffer = new byte[1024];
int len = 0;
while( (len=fis.read(buffer)) != -1){
//写数据到目的地
fos.write(buffer, 0, len);
}
fis.close();
fos.close();
}
}
答案:
public class CopyDirectory {
public static void main(String[] args) throws IOException {
//封装数据源
File srcPath = new File("E:\\resource");
//封装目的地
File destPath = new File("dest");
//创建目的地文件夹
destPath.mkdirs();
//2:获取到数据源中所有的File对象
File[] files = srcPath.listFiles();
//3:遍历, 得到每一个File对象
for (File file : files) {
//4:复制文件
//得到名字
String name = file.getName();
//组成目的地File对象
File dest = new File(destPath, name);
copyFile(file, dest);
}
}
//复制文件
private static void copyFile(File srcPath, File destPath) throws IOException {
FileInputStream fis = new FileInputStream(srcPath);
FileOutputStream fos = new FileOutputStream(destPath);
//读取数据
byte[] buffer = new byte[1024];
int len = 0;
while( (len=fis.read(buffer)) != -1){
//写数据到目的地
fos.write(buffer, 0, len);
}
fos.close();
fis.close();
}
}