黑马程序员_IO流（2）

------- android培训、java培训、期待与您交流！ ----------

File类常见需求：

    (1)文件名过滤:列出给定目录的所有.java文件

        publicvoid showFileName(File file)

        {

            String[]filenames = file.list(new FilenameFilter()//匿名内部类

            {

                public boolean accept(Filedir,String name)//复写唯一方法

                {

                    returnname.endsWith(".java");//列出所有.java文件

                }

            });

        }

    (2)列出指定目录下的所有文件和文件夹(递归)

    **示例1：不带层次递归：

    public staticvoid showDir(File dir)

    {

        File[]files = dir.listFile();

        for(int i= 0;i<files.length;i++)

        {

            if(files[i].isDirectory&&!files[i].isHidden())

                showDir(files[i]);

            else

                sop(files[i]);

        }

    }

    **示例2：带层次递归：

    public staticvoid showDir(File dir,int level)

    {

        sop(getLevel(level)+C);//进来先打印层次和目录

        level++;

        File[] files= dir.listFile();

        for(int i= 0;i<files.length;i++)

        {

            if(files[i].isDirectory&&!files[i].isHidden())

                showDir(files[i]);

            else

                sop(getLevel(level)+files[i]);//是文件就打印层次和目录

        }

    }

    public staticString getLevel(int level)

    {

        sop("|--");

        StringBuildersb = new StringBuilder();

        for(inti=0;i<level;i++)

        {

            sb.inset(0."|  ")

        }

        returnsb.toString();

    }

    (3)需求：删除带内容的目录：

    public staticvoid removeDir(File dir)

    {

        File[]files = file.listFile();

        for(int i= 0;i<files.length;i++)

        {

            if(files[i].isDirectory&&!files[i].isHidden())

                removeDir(files[i]);//如果是文件夹则继续调用函数

            else//如果是文件则删除。注意删除的时候打印删除的结果，防止误删或者重删的情况

                sop(files[i].toString()+"::"+files[i].delete());

        }

        sop(dir+"::"+dir.delete());

    }

    (4)需求：将制定目录下的java文件的绝对路径存储到文本文件中。

       思路：

       **对指定目录进行递归

       **获取递归过程中所有java文件的路径

       **将这些路径存储到集合中

       **将集合中的数据写入文件中

     //对指定目录进行递归并将所以Java文件存储到集合中

    public staticvoid getFileName(File file,ArrayList<File> arraylist){

        File[]files = file.listFiles();

        for (inti = 0; i < files.length; i++) {

            if(files[i].isDirectory()&&!files[i].isHidden()){

                getFileName(files[i],arraylist);

            }else{

                if(files[i].getName().endsWith(".java")){

                    arraylist.add(files[i]);

                }

            }

        }

    }

    //将集合中所有数据存储到新文件中

    public staticvoid saveFileToNewDir(ArrayList<File> arraylist,File newDir){

        BufferedWriterbufw = null;

        try {

            bufw= new BufferedWriter(new FileWriter(newDir));

            for(File file : arraylist) {

                StringfileAbsolutePath = file.getAbsolutePath();

                bufw.write(fileAbsolutePath);

                bufw.newLine();

                bufw.flush();  

            }

        } catch(Exception e) {

            System.out.println("文件写入失败");

        }finally{

            try {

                if(bufw!=null)

                    bufw.close();

            }catch (Exception e2) {

                System.out.println("文件写入流关闭失败");

            }

        }

IO流常见需求：

****字符流：

       (1)需求1：在硬盘上创建一个文件并写入信息

              用字符写入流：FileWriter

              FileWriterfw = new FileWriter("g:\\filewriter.txt");

              fw.write("输入信息");

              fw.write("也可以写入字符数组".toCharArray());

              fw.flush();

              fw.close();

       (2)需求2：在原有文件上续写数据

              FileWriterfw = new FileWriter("g:\\filewriter.txt",true);

              fw.write("还可以续写信息");

              fw.write("也可以写入字符数组".toCharArray());

              fw.flush();

              fw.close();

       (3)需求3：读取硬盘上的文本文件，并将数据打印在控制台

              FileReaderfr = new FileReader("g:\\filewriter.txt");

              **第一种读取方法：一个一个字节的读

              intch = 0;

              ch= fr.read();

              sop((char)ch);

              fr.close();

              **第二种读取方法：利用数组来提高效率

              char[]buf = new char[1024];

              intlen = 0;

              while((len= fr.read(buf))!=-1)

              {

                     sop(newString(buf,0,len));

              }

              fr.close();

       (4)需求4:拷贝文本文件

              利用缓冲区提高数据读写效率

              (无缓冲区就相当于一滴一滴的喝水，有缓冲区就相当于一杯一杯的喝水)

              BufferedReaderbufr = new BufferedReader(new FileReader("g:\\filewriter.txt"));

              BufferedWriterbufw = new BufferedWriter(new FileWriter("d:\\copyfilewriter.txt"));

              Stringline = null;

              while((line= bufr.readLine())!=null)

              {

                     burw.write(line);

                     bufw.newLine();

                     bufw.flush();

              }

              bufr.close();

              bufw.close();

****字节流：字节流写入时没有刷新

       (1)需求1：在硬盘上创建一个文件并写入信息(字节流写入时没有刷新)

              FileOutputStreamfos = new FileOutputStream("g:\\filestream.txt");

              fos.write(97);//写入一个字节,int：97代表写入char：a

              fos.write("也可以写入字节数组".getBytes());//通常使用此种方式写入，直观！

              fos.close();

       (2)需求2：在硬盘已有文件上续写数据(字节流写入时没有刷新)

              FileOutputStreamfos = new FileOutputStream("g:\\filestream.txt",true);

              fos.write("创建字节写入流时，传进去一个true参数就可以继续写入信息".getBytes());

              fos.close();    

       (3)需求3：读取硬盘上的文件

              FileInputStreamfis = new FileInputStream("g:\\filestream.txt");

              **第一种读法：一个字节一个字节的读(此种读法慢)

              intch = 0;

              while((ch= fis.read())!=-1)

              {

                     sop((char)ch);

              }

              **第一种读法：利用字节数组读(此种读法效率有一定提高)

              byte[]buf = new byte[1024];

              intlen = 0;

              while((len= fis.read())!=-1)

              {

                     sop(newString(buf,0,len));

              }

       (4)需求4:拷贝字节文件，如图片或者MP3或者电影

              **第一种拷贝：不带缓冲区(慢，还是效率问题)

              FileInputStreamfis = new FileInputStream("g:\\1.mp3");

              FileOutputStreamfos = new FileOutputStream("g:\\copy1.mp3");

              byte[]buf = new byte[1024];

              intlen = 0;

              while((len= fis.read(buf))!=-1)

              {

                     fos.(buf,0,len);//字节流写入无需刷新

              }

              fis.close();

              fos.close();

              **第二种拷贝：带缓冲区，高效

              BufferedInputStreambufi = new BufferedInputStream(new FileInputStream("g:\\1.mp3"));

              BufferedOutputStreambufo = new BufferedOutputStream(newFileOutputStream("g:\\copy1.mp3"));

              intch = 0;

              while((ch= bufi.read())!=-1)

              {

                     bufo.write(ch);

              }

              bufi.close();

              bufo.close();

****转换流：

       (1)需求1：读取一个键盘录入

              InputStreamin = System.in;//创建一个键盘录入流，流不关则可以一直录入

              intby1 = in.read();//一次读一个字节

              intby2 = in.read();//一次读一个字节

              sop(by1);//假设键盘录入的是abcd,则打印a

              sop(by2);//假设键盘录入的是abcd,则打印b

              in.close();      

       (2)需求2：键盘录入一行数据打印一行数据，如果录入的是over则结束录入

              InputStreamin = System.in;

              StringBuildersb = new StringBuilder();

              while(true)

              {

                     intch = in.read();

                     if(ch=='\r')

                            continue;

                     if(ch=='\n')

                     {

                            Stringline = sb.toString();

                            if("over".equals(line))

                                   break;

                            sop(line.toUpperCase());//输出大写

                            sb.delete(0.sb.length());//清除上一行录入的数据

 

                     }

                     else

                            sb.append((char)ch);

              }

              in.close();

       (3)需求3：发现需求2中其实就是读一行的原理，故引入字节通向字符的桥梁：InputStreamReader

              为提高效率加入缓冲区：

              BufferedReaderbufr = new BufferedReader(new InputStreamReader(System.in));

              Stringline = null;

              while((line= bufr.readLine())!=null)

              {

                     if("over".equals(line))

                            break;

                     sop(line.toUpperCase());//输出大写

              }

              bufr.close();

       (4)需求4：键盘录入数据并打印到控制台

              BufferedReaderbufr = new BufferedReader(new InputStreamReader(System.in));

              BufferedWriterbufw = new BufferedWriter(new OntputStreamWriter(System.out));

              Stringline = null;

              while((line= bufr.readLine())!=null)

              {    

                     if("over".equals(line))

                            break;

                     bufw.write(line.toUpperCase());

                     bufw.newLine();

                     bufw.flush();  

              }

              bufr.close();

              bufw.close();

       (5)需求5:将键盘录入的数据存储到硬盘文件

              则只需将(4)中的

              BufferedWriterbufw = new BufferedWriter(new OntputStreamWriter(System.out));

              改为：

              BufferedWriterbufw = new BufferedWriter(new OntputStreamWriter(newFileWriter("g:\\demo.txt")));

              即：

              BufferedReaderbufr = new BufferedReader(new InputStreamReader(System.in));

              BufferedWriterbufw = new BufferedWriter(new OntputStreamWriter(newFileWriter("g:\\demo.txt")));

              Stringline = null;

              while((line= bufr.readLine())!=null)

              {    

                     if("over".equals(line))

                            break;

                     bufw.write(line.toUpperCase());

                     bufw.newLine();

                     bufw.flush();  

              }

              bufr.close();

              bufw.close();

       (6)需求6：将硬盘文件的数据打印到控制台

              则只需将(4)中的

              BufferedReaderbufr = new BufferedReader(new InputStreamReader(System.in));

              改为：

              BufferedReaderbufr = new BufferedReader(new InputStreamReader(new FileReader("g:\\demo.txt")));

              即：

              BufferedReaderbufr = new BufferedReader(new InputStreamReader(newFileReader("g:\\demo.txt")));

              BufferedWriterbufw = new BufferedWriter(new OntputStreamWriter(System.out));

              Stringline = null;

              while((line= bufr.readLine())!=null)

              {    

                     if("over".equals(line))

                            break;

                     bufw.write(line.toUpperCase());

                     bufw.newLine();

                     bufw.flush();  

              }

              bufr.close();

              bufw.close();