java笔记_IO

IO操作是为了实现数据持久化存储,需要把内存中的数据存储到内存以外的其他持久化设备上。IO是输入(input)和输出(output)的意思;输入是指把持久化设备上的数据读取到内存中,而输出是指把内存中的数据存储到持久化设备上

知识点关系图

总结了一些常用的IO流操作,知识结构如下所示:

File类

File文件和目录路径名的抽象表示形式。即,Java中把文件或者目录(文件夹)都封装成File对象。也就是说如果我们要去操作硬盘上的文件,或者文件夹只要找到File这个类即可

三种创建File对象的方法

public class demo {
    public static void main(String[] args) {
        /*
         * 第一种: File(String pathname) 
         * 直接指定文件名路径,默认为当前项目src文件夹下
         * */
        File file1 = new File("word.txt");


        /*
         * 第二种: File(String parent, String child)
         * 参数一: 文件夹路径
         * 参数二:文件名/目录
         * */
        File file2 = new File("E:\\06_java_study\\javaProject\\","word.txt");

        /*
         * 第三种:File(File f, String child)
         * 参数一:文件夹路径对象
         * 参数二:文件名/目录
         * */
        File dir = new File("E:\\06_java_study\\javaProject\\");
        File file3 = new File(dir,"word.txt");

        System.out.println(file1.getAbsolutePath());
        System.out.println(file2.getAbsolutePath());
        System.out.println(file3.getAbsolutePath());
    }
}

显示的结果:

获取文件信息的方法

public class demo {
    public static void main(String[] args) {

        File file = new File("word.txt");

        System.out.println("获取文件的名称: " + file.getName());
        System.out.println("获取文件是否可读: " + file.canRead());
        System.out.println("判断文件是否可被写入: " + file.canWrite());
        System.out.println("判断文件是否存在: " + file.exists());
        System.out.println("获取文件的长度(以字节为单位):" + file.length());
        System.out.println("获取文件的绝对路径: " + file.getAbsolutePath());
        System.out.println("获取文件的父路径: " + file.getParent());
        System.out.println("判断文件是否存在: " + file.isFile());
        System.out.println("判断文件是否为一个目录: " + file.isDirectory());
        System.out.println("判断文件是否为隐藏文件: " + file.isHidden());
        System.out.println("获取文件最后修改时间:" + file.lastModified());
    }
}

显示结果:

其他方法

1)创建功能

public boolean createNewFile()  // 创建文件 如果存在这样的文件,就不创建了
public boolean mkdir()          // 创建文件夹 如果存在这样的文件夹,就不创建了
public boolean mkdirs()         // 创建文件夹,如果父文件夹不存在,会帮你创建出来

2)删除功能

public boolean delete()

注意:

  • 如果创建文件或者文件夹忘了写盘符路径,则默认在项目路径下
  • Java中的删除不会到回收站
  • 要删除一个文件夹,该文件夹内不能包含文件或者文件夹

3)重命名功能

public boolean renameTo(File dest)
  • 路径名相同,则是改名
  • 路径名不同,则是改名并剪切

4)获取功能

public String[] list()     // 获取指定目录下的所有文件或者文件夹的名称数组
public File[] listFiles()  // 获取指定目录下的所有文件或者文件夹的File数组

示例:

public class demo {
    public static void main(String[] args) {

        File file = new File("E:\\");

        // public String[] list() // 获取指定目录下的所有文件或者文件夹的名称数组
        String[] strArray = file.list();
        for(String s : strArray) {
            System.out.println(s);
        }

        System.out.println("---------------------");

        // public File[] listFiles() // 获取指定目录下的所有文件或者文件夹的File数组
        File[] fileArray = file.listFiles();
        for(File f : fileArray) {
            System.out.println(f.getName());
        }
    }
}

结果展示:

注意:在获取指定目录下的文件或者文件夹时必须满足下面两个条件

  1. 指定的目录必须是存在的,
  2. 指定的必须是目录。否则容易引发返回数组为null,出现NullPointerException

文件输入/输出流

使用文件的输入/输出流,可以和文件建立连接,从而能将数据永久的保存在文件中。

FileInputStream和FileOutputStream类

FileInputStream和FileOutputStream类提供了对字节和字节数组的读取方法,对于汉字的读取会出现乱码,所以这两个类比较适合用于读取需求较为简单且不读取汉字的方式。

public class demo {
    public static void main(String[] args) {

        File file = new File("word.txt");

        // 将数据写入到文件中
        try {
            FileOutputStream out = new FileOutputStream(file);
            byte[] byt = "welcome to come wjqixige.cn".getBytes();
            out.write(byt);
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 从文件中读取数据
        try {
            FileInputStream in = new FileInputStream(file);
            byte[] byt = new byte[1024];
            int len = in.read(byt);
            System.out.println("读取文件中的信息为: " + new String(byt, 0, len));
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果:

FileReader和FileWriter类

FileReader和FileWriter类可以有效的避免,读取占用两个字节的汉字出现乱码的问题。

public class demo {
    public static void main(String[] args) {

        File file = new File("word.txt");

        // 将数据写入到文件中
        try {
            FileWriter writer = new FileWriter(file);
            String s = "欢迎来到前端栖溪阁,我的个人学习博客。";
            writer.write(s);
            writer.close();
        } catch (IOException e1) {
            e1.printStackTrace();
        }

        // 从文件中读取数据
        try {
            FileReader read = new FileReader(file);
            char[] byt = new char[1024];
            int len = read.read(byt);
            System.out.println(new String(byt,0,len));
            read.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

显示结果:

带缓存的输入/输出流

缓存流为I/O流增加了缓存区,通过减少与内存的读写次数来提高输入和输出的速度。

BufferedInputStream和BufferedOutputStream类

缓存输入流:

public class demo {
    public static void main(String[] args) {

        File file = new File("E:\\07_java_source\\随书附带资源库使用说明.doc");
        FileInputStream in = null;

        BufferedInputStream bi = null;

        long start = System.currentTimeMillis();
        try {
            in = new FileInputStream(file);
            bi = new BufferedInputStream(in);
            byte[] byt = new byte[1024];
            while( bi.read(byt) != -1) {

            }
            long end = System.currentTimeMillis();
            System.out.println("运行所需要的毫秒数: "+ (end - start));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if( in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if( bi != null) {
                try {
                    bi.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

测试结果,在不包装缓存输入流所要花费的时间为16毫秒,添加缓存区运行所需要的时间为2毫秒,速度得到了很大的提升。此处省略截图

缓存输出流:

public class demo2 {
    public static void main(String[] args) {
        File f = new File("word.txt");

        FileOutputStream out = null;
        BufferedOutputStream bo = null;

        try {
            out = new FileOutputStream(f);
            bo = new BufferedOutputStream(out);
            String str = "天生我材必有用,千金散尽还复来。";
            byte[] byt = str.getBytes();
            bo.write(byt);
            bo.flush(); //刷新,强制将缓冲区的数据写入文件中,即使没有写满
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bo!=null) {
                try {
                    bo.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

BufferedReader和BufferedWriter类

可以以 为单位进行输入/输出

缓存输出流:

public class demo {
    public static void main(String[] args) {
        File file = new File("word.txt");

        FileWriter fw = null;
        BufferedWriter bw = null;

        try {
            fw = new FileWriter(file);
            bw = new BufferedWriter(fw);

            String str1 = "欢迎来到我的博客";
            String str2 = "栖息阁晓生";

            bw.write(str1);
            bw.newLine();
            bw.write(str2);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {  // 先创建的后关闭
            if( bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if( fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

缓存输入流:

public class demo {
    public static void main(String[] args) {
        File file = new File("word.txt");

        FileReader fr = null;
        BufferedReader br = null;

        try {
            fr = new FileReader(file);
            br = new BufferedReader(fr);
            String tmp = null;
            int i = 0;
            while((tmp=br.readLine()) != null) {
                System.out.println("第" + i + "行: " + tmp);
                i++;
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if( br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if( fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

数据输入/输出流

数据流,也称数据过滤流。可以从流中读取或写入java的基本数据类型。

public class Example_01 {
    public static void main(String[] args) {

        File f = new File("word.txt");

        // 数据输出流
        FileOutputStream out = null;
        DataOutputStream dos = null;
        try {
            out = new FileOutputStream(f);
            dos = new DataOutputStream(out);  //将文件流包装成数据流

            dos.writeUTF("写入字符串数据");
            dos.writeInt(123);
            dos.writeDouble(3.1415926);
            dos.writeBoolean(false);
        } catch (Exception e) {
            e.printStackTrace(); // 输出异常信息
        } finally {
            if( dos != null) {
                try {
                    dos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if( out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        // 数据输入流
        DataInputStream di = null;
        FileInputStream in = null;

        try {
            in = new FileInputStream(f);
            di = new DataInputStream(in);

            System.out.println("readUTF()读取数据: " + di.readUTF());
            System.out.println("redInt()读取数据:" + di.readInt());
            System.out.println("redDouble()读取数据:" + di.readDouble());
            System.out.println("redBoolean()读取数据:" + di.readBoolean());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if( di != null) {
                try {
                    di.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if( in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

显示的结果如下:

参考资料

1、《java入门到精通》(第5版)明日科技著 清华大学出版社

-------------本文结束感谢您的阅读-------------
Mr.wj wechat
欢迎您扫一扫上面的微信公众号,订阅我的博客!