Java基础针对自己薄弱环节总结07（递归、IO流）

一、递归

a)        概述

递归是方法中调用方法本身的现象

b)       注意事项

            i.  递归次数不能太多，否则内存溢出

           ii.   一定要有出口，否则死递归

           iii.  构造方法不能递归

c)        小例子：N的阶乘

    public static int jc(int n){

     if(n ==1){

          return 1；

     else

          return n* jc(n -1);

     }

               }

二、IO流

a)        分类

i.             字节流：

1.        输入流：

                 InputStream(抽象类)

                intread()

                 intread(byte[] bys)

                 FileInputStream(常用基本流)

                 BufferedInputStream

2.        输出流：

                  OutputStream(抽象类)

                          write(intby)

                          write(byte[]bys,int index,int len)

                   FileOutputStream(常用基本流)

                   BufferedOutputStream

ii.             字符流：

1.        输入流：

                   Reader(抽象类)

                        intread()

                        intread(char[] chs)

                    FileReader(常用基本流)

                    BufferedReader

                         String readLine()

2.        输出流：

                    Writer(抽象类)

                         write(intch)

                         write(char[]chs,int index,int len)

                     FileWriter(常用基本流)

                     BufferedWriter

                           write(String line)

                           void newLine()

 

三、递归和IO流结合使用操作文件的例子

a)        删除文件夹下的所有内容

packagecn.itcast.digui;
importjava.io.File;
/**
 * 用递归删除多级文件
 * @author LBK
 *
 */
public classDiGuiDelete {
       public static void main(String[] args) {
              //封装要删除的目录
              File srcFile =newFile("e:\\java");
              //递归删除
              delete(srcFile);
              System.out.println("删除成功");
       }
 
       public static void delete(File srcFile) {
              //获取文件数组
              File [] files=srcFile.listFiles();
             
              //判断目录是否存在文件
              if(files!=null){
                     //遍历数组
                     for(File file:files){
                            if(file.isDirectory()){
                                   delete(file);
                            }else{
                                   file.delete();
                            }
                     }
              }
              //完成遍历删除该级文件夹
              srcFile.delete();
       }
}

b)       复制多级文件

packagecn.itcast.digui;
importjava.io.BufferedInputStream;
importjava.io.BufferedOutputStream;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
/**
 * 递归复制多级文件夹中的文件
 * @author LBK
 *
 */
public classDiGuiCopy {
       public static void main(String[] args)throws IOException {
              // 封装源目录
              File srcFile = newFile("d:\\test");
 
              // 封装目的目录
              File destFile = newFile("e:\\test");
 
              // 递归复制
              copyFile(srcFile, destFile);
              System.out.println("复制成功");
       }
 
       public static void copyFile(File srcFile,File destFile) throws IOException {
 
              // 检查目的路径是否存在，不存在创建
 
              if (!destFile.exists()) {
                     destFile.mkdirs();
              }
              // 获取源目录中所用的文件到数组中
              File[] ArrayFiles =srcFile.listFiles();
 
              // 遍历文件数组
 
              for (File file : ArrayFiles) {
 
                     // 判断是否是文件夹
                     if (!file.isFile()) {
                            copyFile(file,destFile);
                     } else {
                            // 是文件开始复制
 
                            File newFile = newFile(destFile, file.getName());
 
                            // 创建输入流
                            BufferedInputStreambis = new BufferedInputStream(
                                          newFileInputStream(file));
                            // 创建输出流
                            BufferedOutputStreambos = new BufferedOutputStream(
                                          newFileOutputStream(newFile));
                            byte[] bys = newbyte[1024];
                            int len = 0;
                            while ((len =bis.read(bys)) != -1) {
                                   bos.write(bys,0, len);
                                   bos.flush();
 
                            }
                            bis.close();
                            bos.close();
                     }
              }
 
       }
}