|
第二十一天 IO-递归&字节流&字符流【悟空教程】80
发表时间:2018-09-06 15:50 第二十一天 IO-递归&字节流&字符流【悟空教程】 第21天 IO 第1章 递归1.1 递归的概念递归就是“在一个方法内可以再次调用自身”,如下,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(); } } 1.2 递归的注意事项
1.3 算法案例1.3.1 有些问题可以使用“循环”,也可以使用“递归”解决:求5的阶乘:表示为:1 * 2 * 3 * 4 * 5
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); } 1.4 递归两种方法递归分为两种,直接递归和间接递归。 直接递归称为方法自身调用自己。间接递归可以A方法调用B方法,B方法调用C方法,C方法调用A方法。 1.4.1 递归的代码演示,计算1-n之间的和,使用递归完成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); } } 1.4.2 代码执行流程图解注意:递归一定要有条件限定,保证递归能够停止下来,否则会发生栈内存溢出。 在递归中虽然有限定条件,但是递归次数不能太多。否则也会发生栈内存溢出。 1.5 递归打印所有子目录中的文件路径编写一个方法用来打印指定目录中的文件路径,并进行方法的调用 要求:若指定的目录有子目录,那么把子目录中的文件路径也打印出来 步骤:
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); } } } } 第2章 IO概述回想之前写过的程序,数据都是在内存中,一旦程序运行结束,这些数据都没有了,等下次再想使用这些数据,可是已经没有了。那怎么办呢?能不能把运算完的数据都保存下来,下次程序启动的时候,再把这些数据读出来继续使用呢?其实要把数据持久化存储,就需要把内存中的数据存储到内存以外的其他持久化设备(硬盘、光盘、U盘等)上。 当需要把内存中的数据存储到持久化设备上这个动作称为输出(写)Output操作。 当把持久设备上的数据读取到内存中的这个动作称为输入(读)Input操作。 因此我们把这种输入和输出动作称为IO操作。
2.1 IO流分类按照流向分:输入流与输出流,每个IO流对象均要绑定一个IO资源 按照类型分:常以字节流与字符流区分 分类关系如下:
2.2 字节流2.2.1 一切均为字节在数据传输过程中,一切数据(文本、图像、声音等)最终存储的均为一个个字节,即二进制数字。所以数据传输过程中使用二进制数据可以完成任意数据的传递。 我们向一个文件中存储一定数据(一些数字),如果使用文本方式打开,则会以文本的方式解释数据。如果以视频的方式打开,则会以视频的方式解释数据。音频、可行执行文件等亦是如此。所以,在文件传输过程中,我们要时刻明确,传输的始终为数据。 2.2.2 字节输出流输出流: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资源,在使用时,需要回收资源 2.2.3 FileOutputStream类OutputStream有很多子类,其中子类FileOutputStream可用来写入数据到文件。 FileOutputStream类,即文件输出流,是用于将数据写入 File的输出流。
2.2.3.1 写出一个字节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(); } } 2.2.3.2 FileOutputStream类写入数据到文件中
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(); } }
2.2.4 给文件中续写和换行我们直接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(); } } 2.2.4.1 写出多个数据&追加数据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(); } } 2.2.5 字节输入流输入流:InputStream(抽象类):FileInputStream(基本输入流) 构造方法:需要绑定IO资源 public FileInputStream(String name) 其他方法:读取时,返回数据时,使用int替代了byte int read():读取一个字节, 返回的是字节内容本身,读取到末尾返回-1 int read(byte[] b):读取一个字节数组 close(): 由于每个IO流都需要绑定一个IO资源,在使用时,需要回收资源 2.2.6 FileInputStream类InputStream有很多子类,其中子类FileInputStream可用来读取文件内容。 FileInputStream 从文件系统中的某个文件中获得输入字节。
2.2.7 FileInputStream类读取数据read方法在读取文件中的数据时,调用read方法,实现从文件中读取数据 2.2.7.1 读取一个字节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(); } } 2.2.7.2 循环读取文件(读取字节)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(); } } 2.2.8 读取数据read(byte[])方法在读取文件中的数据时,调用read方法,每次只能读取一个,太麻烦了,于是我们可以定义数组作为临时的存储容器,这时可以调用重载的read方法,一次可以读取多个字符。 2.2.8.1 使用字节数组读取文件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(); } } 2.2.8.2 len有效字节数组(复制文本文件)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(); } } 2.2.8.3 字节数组复制图片文件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("复制文件完毕"); } } 2.2.9 字节流练习2.2.9.1 复制文件原理;读取一个已有的数据,并将这些读到的数据写入到另一个文件中。
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这个变量进行数据交换的。 上述复制文件有个问题,每次都从源文件读取一个,然后在写到指定文件,接着再读取一个字符,然后再写一个,一直这样下去。效率极低。 2.2.9.2 临时数组方式复制文件上述代码复制文件效率太低了,并且频繁的从文件读数据,和写数据,能不能一次多把文件中多个数据都读进内容中,然后在一次写出去,这样的速度一定会比前面代码速度快。 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(); } }
2.3 字符流2.3.1 方便程序员的IO流在IO开发过程中,我们传输最频繁的数据为字符,而以字节方式传输字符需要每次将字符串转换成字节再处理,而且也丧失了程序员对数据内容的判断(因为程序员只认识字符,不认识字节)。所以,为了让程序员方便对字符进行操作,Java提供了专门以字符作为操作单位的类——字符流,其底层仍然为字节流。 显然,字符流只能操作字符,无法操作其他数据,如声音、视频等。 2.3.2 字符输出流FileWirter既然有专门用于读取字符的流对象,那么肯定也有写的字符流对象,查阅API,发现有一个Writer类,Writer是写入字符流的抽象类。其中描述了相应的写的动作。 2.3.3 FileWriter类查阅FileOutputStream的API,发现FileOutputStream 用于写入诸如图像数据之类的原始字节的流。要写入字符流,请考虑使用 FileWriter。 打开FileWriter的API介绍。用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节高效区大小都是可接受的。
2.3.4 FileWirter写数据
2.3.5 FileWriter写入中文到文件中
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) {} } } 2.3.6 FileWriter写数据路径问题及关闭和刷新方法的区别2.3.6.1 路径:
2.3.6.2 close()和flush()方法的区别:
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(); } } 2.3.7 FileWriter写数据的5个方法
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(); } } 2.3.8 FileWriter写数据之换行和追加写2.3.8.1 续写问题
true:可以续写 false:不能续写,覆盖之前的文件 2.3.8.2 换行问题
2.3.9 字符输入流FileReader2.3.10 FileReader读数据
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(); } }
2.3.11 FileReader类查阅FileInputStream的API,发现FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流,请考虑使用 FileReader。 打开FileReader的API介绍。用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节高效区大小都是适当的
2.3.12 FileReader读取包含中文的文件
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(); } }
2.3.12.1 字符流:读取文件,一次读写一个字符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(); } } 2.3.12.2 复制文本文件: 一次读写一个字符复制文本文件
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(); } } 2.3.12.3 FileReader读数据一次一个字符数组
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(); } } 2.3.12.4 FileReader读取数据的两种方式图解
2.3.12.5 复制文本文件: 一次读写一个字符数组复制文本文件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(); } } 第3章 本日自习作业:3.1 知识点相关题3.1.1 知识点:字节输出流FileOutputStream各种方法题目: 1) 定义类Test1,定义main()方法,按以下要求编写代码:
2) 定义类Test2,定义main()方法,按以下要求编写代码:
3) 定义类Test3,定义main()方法,按以下要求编写代码:
3.1.2 知识点:字节输入流FileInputStream各种方法题目: 1) 定义类Test4,定义main()方法,按以下要求编写代码:
2) 定义类Test5,定义main()方法,按以下要求编写代码:
3.1.3 知识点:使用字节流实现文件复制题目: 1) 定义类Test6,定义main()方法,按以下要求编写代码:
2) 定义类Test7,定义main()方法,按以下要求编写代码:
3.1.4 请写出FileWriter的五种输出的方法;3.1.5 字符输出流FileWriter操作定义类Test1,定义main()方法,按以下要求编写代码:
3.1.6 请写出FileRader的两种读取的方法;3.1.7 字符输入流FileReader操作定义类Test2,定义main()方法,按以下要求编写代码:
3.1.8 掌握使用字符流复制文件的方式定义类Test3,定义main()方法,按以下要求编写代码:
3.1.9 使用递归定义方法,求1-N的和3.1.10 字节流复制文件操作3.1.11 使用字节流复制一张图片或者音频(不要过大!),请问是否可以使用字符流完成相同操作,为什么?3.1.12 完成单级文件夹的复制,即:a文件夹下有多个文件,没有文件夹,将a文件夹中的所有内容,复制到b文件夹中即可。 建议方法声明: public static void copyDir(File srcDir,File destDir) { 将srcDir文件夹的内容,复制到destDir文件夹中 } 3.1.13 使用递归求斐波那契数列:给定第几项,求该项的值。3.1.14 复制多级目录,将a文件夹所有内容(包含a文件夹本身),复制到b文件夹中。注意:a文件夹中还会有2级、3级、n级目录,每级目录内容均要被复制。 3.1.15 使用递归的方式获取这个目录下所有的子目录的名字定义类,定义main()方法,按以下要求编写代码:
3.2 代码题3.2.1 求1*2!*3!+...*20!的和答案:
3.2.2 使用字符流,将一个路径下的文本文件复制到另一路径下;答案:
|