23 IO输入(2)

23 IO输入(2)

引言

经过昨天的没收获的表现，今天的收获还好，起码有点入手了，希望再接再厉。

1. 遍历子目录中的内容，通过队列的方式
2. 遍历子目录中的内容，通过递归的方式
3. 讲解递归的使用和注意事项
4. 读取一个文件，通过read()方法
5. 读取一个文件，通过read(byte[])方法
6. 通过自定义缓冲区数组复制文件
7. 通过读写一个字节方式复制文件
8. 写入数据到一个文件
9. 续写和换行
10. IO异常的处理
11. 了解available()方法
12. 通过字节流缓冲区对象复制文件

8.遍历子目录中的内容，通过队列的方式

package cn.itcast.io.a.file;
    
    import java.io.File;
    import java.util.LinkedList;
    
    public class GetAllFileByQueue {
    
        /**
         * @param args
         */
        public static void main(String[] args) {
    
            /*
             * 遍历文件夹，不用递归咋办？ 
             * 思路：
             * 1，可以通过对每一个目录进行for循环，但是目录层级很多，for会死掉。
             * 2，每遍历到一个目录，不对其进行遍历，而是先临时存储起来。 相当于把所有目录（无论同级不同级）都存储起来。
             * 3，遍历容器时取到就是目录，然后对目录遍历即可。 4，从容器中取到目录遍历时发现内部还有目录，一样将这些目录存储到容器中。
             * 5，只要不断的遍历这个容器就哦了。
             * 
             * 通过图解：发现这个容器只要是一个简单的队列就可以解决这个问题。
             */
    
            File dir = new File("E:\\test");
            System.out.println(dir.getName());
            Queue<File> queue = new Queue<File>();
    
            // 1,对dir进行当前目录的遍历。
            File[] files = dir.listFiles();
            for (File file : files) {
                // 2, 如果有子目录，存储到队列中。
                if (file.isDirectory()) {
                    queue.myAdd(file);
                } else {
                    System.out.println(file.getName());
                }
            }
            System.out.println("---------------------");
            //3,遍历队列容器。因为子目录都在队列中。
            while(!queue.isNull()){
    
                File subDir = queue.myGet();//从队列中取出子目录。
                System.out.println(subDir.getName());
                //4,遍历子目录。
                File[] subFiles = subDir.listFiles();
                for(File subFile : subFiles){
                    if(subFile.isDirectory()){//如果子目录中还有子目录，继续存储到队列中。
                        queue.myAdd(subFile);
                    }else{
                        System.out.println(subFile.getName());
                    }
                }
    
    
            }
        }
    
    }
    
    /**
     * 队列结构。先进先出。
     */
    class Queue<E> {
    
        private LinkedList<E> link;
    
        /**
         * 提供了构造队列对象的构造器。
         */
        public Queue() {
            link = new LinkedList<E>();
        }
    
        /**
         * 添加元素的方法。
         */
        public void myAdd(E obj) {
            link.addFirst(obj);
        }
    
        /**
         * 获取的方法。
         */
        public E myGet() {
            return link.removeLast();
        }
    
        /**
         * 判断队列是否有元素。
         */
        public boolean isNull() {
            return link.isEmpty();
        }
    } 

9.遍历子目录中的内容，通过递归的方式

package cn.itcast.io.a.file;
    
    import java.io.File;
    
    public class GetAllFiles {
    
        /**
         * @param args
         */
        public static void main(String[] args) {
            /*
             * File类的listFiles()列出当前目录下文件以及文件夹。
             * 
             * 需求：能不能列出当前目录下的子目录中的所有内容。 思路： 1，在遍历当前目录时，会获取到当前的所有的文件以及文件夹，
             * 2，要遍历子目录需要对获取到的当前的file对象进行判断，只有是目录才可以作为子目录进行继续遍历。
             */
    
            File dir = new File("E:\\test");
    
            listAll(dir);
    
        }
    
        public static void listAll(File dir) {// dir:接收目录以及子目录。
    
            System.out.println("dir:" + dir.getName());
            File[] files = dir.listFiles();
            for (File file : files) {
    
                if (file.isDirectory()) {// 如果遍历到当前的file对象是个目录，继续遍历。
                    listAll(file);
                } else {
                    System.out.println("file:"+file.getName());
                }
            }
    
        }
    
    } 

10.讲解递归的使用和注意事项

package cn.itcast.io.b.digui;
    
    import java.util.Iterator;
    
    public class DiGuiDemo {
    
        /**
         * @param args
         */
        public static void main(String[] args) {
            /*
             * 递归：其实就是功能的重复使用，但是每次该功能被调用参数都变化(使用了上一次运算的结果)。
             * 1，函数自身调用自身。
             * 2，一定要定义条件，否则.StackOverflowError。栈溢出。
             * 3，注意：递归次数过来容易溢出。
             * 
             */
            int sum = getSum(8000);// 4 3 2 1
            System.out.println("sum="+sum);
        }
        public static int getSum(int num){
            if(num == 1){
                return 1;
            }
            return num + getSum(num - 1);
        }
    } 

11.读取一个文件，通过read()方法

package cn.itcast.io.c.bytestream.read;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    
    public class FileInputStreamDemo {
    
        /**
         * @param args
         * @throws IOException 
         */
        public static void main(String[] args) throws IOException {
    //        2,需求：读取文件中的数据，显示在屏幕上。
    
            File file = new File("tempfile\\file.txt");
    
            //创建一个字节输入流对象,必须明确数据源，其实就是创建字节读取流和数据源相关联。
            FileInputStream fis = new FileInputStream(file);
    
            //读取数据。使用 read();一次读一个字节。
            int ch = 0;
            while((ch=fis.read())!=-1){
                System.out.println("ch="+(char)ch);
            }
            /*
            int ch1 = fis.read();
            System.out.println("ch1="+(char)ch1);
            int ch2 = fis.read();
            System.out.println("ch2="+(char)ch2);
            int ch3 = fis.read();
            System.out.println("ch3="+(char)ch3);
            int ch4 = fis.read();
            System.out.println("ch4="+(char)ch4);
            int ch5 = fis.read();
            System.out.println("ch5="+(char)ch5);
            int ch6 = fis.read();
            System.out.println("ch6="+ch6);
            int ch7 = fis.read();
            System.out.println("ch7="+ch7);
            */
    
            // 关闭资源。
            fis.close();
    
    
    
        }
    
    } 

12.读取一个文件，通过read(byte[])方

package cn.itcast.io.c.bytestream.read;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    
    public class FileInputStreamDemo2 {
    
        /**
         * @param args
         * @throws IOException 
         */
        public static void main(String[] args) throws IOException {
            /*
             * 演示第二个读取方法， read(byte[]);
             */
    
            File file = new File("tempfile\\file.txt");
    
            // 创建一个字节输入流对象,必须明确数据源，其实就是创建字节读取流和数据源相关联。
            FileInputStream fis = new FileInputStream(file);
    
            //创建一个字节数组。
            byte[] buf = new byte[1024];//长度可以定义成1024的整数倍。
    
            int len = 0;
            while((len=fis.read(buf))!=-1){
                System.out.println(new String(buf,0,len));
            }
    
            /*int len1 = fis.read(buf);
            System.out.println(len1+":"+new String(buf,0,len1));
            int len2 = fis.read(buf);
            System.out.println(len2+":"+new String(buf,0,len2));
            int len3 = fis.read(buf);
            System.out.println(len3+":"+new String(buf,0,len3));
            int len4 = fis.read(buf);
            System.out.println(len4);
            */
    
            fis.close();
        }
    
    } 

13.通过自定义缓冲区数组复制文件

package cn.itcast.io.c.bytestream.test;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class CopyFileByBufferTest {
    
        /**
         * @param args
         * @throws IOException
         */
        public static void main(String[] args) throws IOException {
    
            File srcFile = new File("E:\\1.mp3");
            File destFile = new File("E:\\copy_1.mp3");
    
            // 2,明确字节流 输入流和源相关联，输出流和目的关联。
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(destFile);
    
            // 3,定义一个缓冲区。
            byte[] buf = new byte[1024];
    
            int len = 0;
            while ((len = fis.read(buf)) != -1) {
                fos.write(buf, 0, len);// 将数组中的指定长度的数据写入到输出流中。
            }
    
            // 4,关闭资源。
            fos.close();
            fis.close();
        }
    
    } 

14.通过读写一个字节方式复制文件

package cn.itcast.io.c.bytestream.test;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class CopyFileTest {
    
        /**
         * @param args
         * @throws IOException 
         */
        public static void main(String[] args) throws IOException {
    
            /*
             * 练习：复制文件。
             * 原理；读取一个已有的数据，并将这些读到的数据写入到另一个文件中。
             */
            //1,明确源和目的。
            File srcFile = new File("E:\\1.mp3");
            File destFile = new File("E:\\copy_2.mp3");
    
            //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();
    
        }
    
    } 

15.写入数据到一个文件

package cn.itcast.io.c.bytestream.write;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class FileOutputStreamDemo {
    
        /**
         * @param args
         * @throws IOException 
         */
        public static void main(String[] args) throws IOException {
            //需求：将数据写入到文件中。
            //创建临时目录，
            File dir = new File("tempfile");
            if(!dir.exists()){
                dir.mkdir();
            }
    
            //创建存储数据的文件。
            File file = new File(dir,"file.txt");
    
            //创建一个用于操作文件的字节输出流对象。一创建就必须明确数据存储目的地。
            //输出流目的是文件，会自动创建。如果文件存在，则覆盖。
            FileOutputStream fos = new FileOutputStream(file);
    
            //调用父类中的write方法。
            byte[] data = "abcde".getBytes();
            fos.write(data);
    
            //关闭流资源。
            fos.close();
    
        }
    } 

16.续写和换行

package cn.itcast.io.c.bytestream.write;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    
    public class FileOutputStreamDemo2 {
    
        private static final String LINE_SEPARATOR = System.getProperty("line.separator");
    
        /**
         * @param args
         * @throws FileNotFoundException 
         */
        public static void main(String[] args) throws Exception {
    
            //需求：将数据续写到已有文件中。
            //FileOutputStream(File file, boolean append) 续写。
            //在下一行写入新的数据。
    
            File file = new File("tempfile\\file.txt");
    
            FileOutputStream fos = new FileOutputStream(file, true);
    
            String str = LINE_SEPARATOR+"itcast";
            fos.write(str.getBytes());
    
            fos.close();
    
        }
    
    } 

17.IO异常的处理

package cn.itcast.io.c.bytestream.write;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class FileOutputStreamDemo3 {
    
        /**
         * @param args
         * @throws FileNotFoundException
         */
        public static void main(String[] args) {
    
            File file = new File("k:\\file.txt");
            FileOutputStream fos = null;
            try {
                fos = new FileOutputStream(file);
                fos.write("abcde".getBytes());
    
            } catch (IOException e) {
                System.out.println(e.toString() + "----");
            } finally {
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (IOException e) {
                        throw new RuntimeException("");
                    }
                }
    
            }
    
        }
    
    } 

18.了解available()方法

package cn.itcast.io.d.bytestream;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    
    public class ByteStreamDemo {
    
        /**
         * @param args
         * @throws IOException 
         */
        public static void main(String[] args) throws IOException {
    
            /*
             * 字节输入流。
             * available();
             */
    
            FileInputStream fis = new FileInputStream("tempfile\\file.txt");
    
    //        System.out.println(fis.available());
            byte[] buf = new byte[fis.available()];//定义了一个刚刚好的数组。 注意：如果文件过大，容易溢出。
                                            //建议缓冲区的长度最好还是1024的整数倍。
    
            fis.read(buf);
            String str = new String(buf);
            System.out.println(str);
    
    
            fis.close();
        }
    
    } 

19.通过字节流缓冲区对象复制文件

package cn.itcast.io.e.bytestreambuffer;
    
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class ByteStreamBufferCopyFileTest {
    
        /**
         * @param args
         * @throws IOException 
         */
        public static void main(String[] args) throws IOException {
    
            //复制文件，通过字节流已有的缓冲区对象。
    
            File srcFile = new File("tempfile\\file.txt");
            File destFile = new File("tempfile\\bufcopy_file.txt");
    
            //1,创建好流对象。
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(destFile);
            //2,创建缓冲区对象并和指定的流相关联
            BufferedInputStream bufis = new BufferedInputStream(fis);
            BufferedOutputStream bufos = new BufferedOutputStream(fos);
    
            byte[] buf = new byte[1024];
    //        int ch = 0;
            int len = 0;
            while((len=bufis.read(buf))!=-1){//缓冲区的read方法从缓冲区中读取一个字节。
                bufos.write(buf,0,len);//将一个字节写入到缓冲区中。
                bufos.flush();//刷新缓冲区，将数据刷到目的地。
            }
    
    
            bufos.close();//缓冲区的关闭方法内部其实调用的是流的关闭方法。
            bufis.close();
        }
    
    }