Java IO流 File类学习总结 文件的读取，写入和复制

IO流

File类

测试用例

public class Dkdir1 {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\JavaIdea\\te728\\mkdir");
        System.out.println(file.exists());  //判断是否是存在
        // System.out.println(file.createNewFile());
        System.out.println(file.mkdir());      //创建目录 只能创建一个
        File file2 = new File("E:\\JavaIdea\\te728\\mkdir\\java\\hello");
        System.out.println(file2.mkdirs());       //创建多级目录
        System.out.println(file.getName());     //获取当前文件或者目录名
        System.out.println(file.getAbsolutePath());   //获取当前绝对目录名
        System.out.println(file.getParent());          //获取父目录绝对目录名
        // System.out.println(file.getParentFile());
        File file1 = new File("E:\\JavaIdea\\te728\\mkdir\\java.txt");
        System.out.println(file1.createNewFile());
        System.out.println(".".repeat(20));
        String[] list = file.list();  //将该文件下的所有文件名和目录名 返回字符串数组
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println(".".repeat(20));
        File[] files = file.listFiles();   //将该文件下的所有文件返回File数组
        for (File f:files){
            System.out.println(f.getName());
        }

    }
}

结果
true
false
false
mkdir
E:\JavaIdea\te728\mkdir
E:\JavaIdea\te728
false
....................
java
java.txt
sdfdsf
....................
java
java.txt
sdfdsf

遍历一个文件夹下所有内容 和删除文件夹下所有内容

public class Dkfir2 {
    public static void main(String[] args) {
        File filen = new File("E:\\JavaIdea\\te728\\mkdir");
        allfile(filen);
    }
    public static void allfile(File file){
        File[] files = file.listFiles();
        for (File f:files){
            if (f.isFile()){
                System.out.println(f.getAbsolutePath());
                //f.delete();                删除文件
            }
            else if (f.isDirectory()){
                allfile(f);
            }
        }
        System.out.println(file.getName());
        //file.delete();         删除文件夹
    }
}

修改文件名 移动文件

IO流概述和分类

IO流概述：

• IO ：输入/输出(Input/Output)

• 流 ：是一种抽象概念，是对数据传输的总称，也就是说数据在设备间的传输称为流，流的本质是数据是数据传输

• IO流就是用来处理设备间数据传输问题的

  常见的应用：文件复制；文件上传；文件下载

IO流分类

• 按照数据的流向

  • 输入流：读数据
  • 输出流：写数据

• 按照数据类型来分

  字节流： 字节输入流；字节输入流

  字符流： 字符输入流；字符输出流

一般来说，我们说IO流的分类是按照数据类型来分的

两种流的使用

• 如果数据通过Window自带的记事本软件打开，我们还可以读懂里面的内容，就使用字符流，否则使用字节流，如果你不知道该使用那种类型的流，就使用字节流

字节流写数据

字节流抽象基类

• InputStream：这个抽象类是表示输入流所有类的超类
• OutputStream：这个抽象类是表示字节输出流所有类的超类
• 子类名特点：子类名称都是以其父类名作为子类名的后缀

输出流写数据示例 三种方法

public class FileOutStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fileOutputStream=new FileOutputStream("E:\\JavaIdea\\te728\\mkdir\\java.txt");
        fileOutputStream.write(97);   //写入的第一种方法 写一个字节
        byte []  b={97,98,99};
        fileOutputStream.write(b);           //写一个字节数组
        byte[] bytes = "yangshunhui".getBytes();
        fileOutputStream.write(bytes);
        fileOutputStream.write(bytes,0,bytes.length);    //写入一个字节数组  第二个参数是从字节数组的第几个开始写 第三个参数是写入字节数组多少位
        fileOutputStream.close();    //关闭字节流 防止占用资源
    }
}
//输出结果 aabcyangshunhuiyangshunhu
//注意此时重复运行程序文本内容不会增加 只会覆盖文本内容

写入字节流常见问题

字节流实现换行

• window：\r\n
• linux : \n
• mac : \r

写入数据从末尾写入

创建FileOutputStream 第二个参数为true 是写入文件的末尾而不是开头

代码示例

public class FileOutStreamDemo1 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fileOutputStream=new FileOutputStream("E:\\JavaIdea\\te728\\mkdir\\java.txt",true);
        for (int i=0;i<6;i++){
            fileOutputStream.write("ysh".getBytes());
            fileOutputStream.write("\r\n".getBytes());
        }
        fileOutputStream.close();

    }
}

对代码加入异常处理

public static void main(String[] args) {
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream("E:\\JavaIdea\\te728\\mkdir\\java.txt");
            byte[] bytes = "yangshunhui".getBytes();
            fileOutputStream.write(bytes);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

读取字节流示例

public class FileInStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("E:\\JavaIdea\\te728\\mkdir\\java.txt");
        /*int read = fileInputStream.read();       //读出第一个字符
        System.out.println(read);                  //读出第一个字符的编码值
        System.out.println((char) read);*/
        /*while (read>0){                       //读出文件所有内容
            System.out.print((char) read);
            read=fileInputStream.read();
        }*/
        int r = 0;
        while ((r = fileInputStream.read()) != -1) {       //优化读取代码
            System.out.print((char) r);
        }
    }
}

读取字节流

        int i = 0;
        byte[] bytes = new byte[1024];
        while ((i = filer.read(bytes)) != -1) {
            System.out.print(new String(bytes, 0, i));  第二个是从什么开始 第三是复制多少位
        }

案例实现图片的复制

public class CopyP {
    public static void main(String[] args) throws IOException {
        FileInputStream filer = new FileInputStream("E:\\JavaIdea\\te728\\mkdir\\pok.jpg");
        FileOutputStream filew = new FileOutputStream("E:\\JavaIdea\\te728\\mkdir\\ysh.jpg");  //mkdir目录下没有照片是系统自动建立的 复制文本也不需要建立文件
        int i=0;
        byte[] bytes=new byte[1024];
        while ((i=filer.read(bytes))!=-1){
            filew.write(bytes,0,i);
        }
        filer.close();
        filew.close();
    }
}

新版本的异常处理直接写入try里面 系统会自动关闭资源

Java9.0 新版复制 快速复制

readALLBytes 一次读完 如果文件太大导致卡死

transferTo() 传输流 缓冲流写入

字节流缓冲流

缓冲流案例

public class BufferedCopyP {
    public static void main(String[] args) throws IOException {
        try (BufferedInputStream breade = new BufferedInputStream(new FileInputStream("E:\\JavaIdea\\te728\\mkdir\\pok.jpg"));
             BufferedOutputStream bwrite = new BufferedOutputStream(new FileOutputStream("E:\\JavaIdea\\te728\\mkdir\\yyy.jpg"));) {
            int i=0;
            byte[] bytes=new byte[1024];
            while ((i=breade.read(bytes))!=-1){
                bwrite.write(bytes,0,i);
            }
        }
        //BufferedWriter bwr=new BufferedWriter(new FileWriter("E:\\java")); 字符缓冲流一样 把名字换一下 字节数组换成字符数组  字节流转换为字符流
    }
}

字符流

代码案例写入数据

public class FileChar {
    public static void main(String[] args) {
       // OutputStreamWriter owrite=new OutputStreamWriter(new FileOutputStream("C:\\ja"))  OutputStreamWriter处理流 把字节流转换为字符流  也可以直接写字符流
        try (FileWriter fileWriter = new FileWriter("E:\\JavaIdea\\te728\\mkdir\\java.txt");) {
            fileWriter.write(97);  //int c 写入一个字符   结果为a
            fileWriter.append("早上好");   //追加写入
            char[] ch={97,98,99};
            fileWriter.write(ch,0,2);    //char[] 写入字符数组 第二个参数开始位置 第三个是写入数组长度
            String str="我爱中国阿";
            fileWriter.write(str,0,str.length());  //写入一个字符串 参数同上
            fileWriter.flush(); //刷新流  try with 写法系统会自动关闭流
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

读取字符流的两种方法

代码案例

public static void main(String[] args) {
        try(FileReader fileReader=new FileReader("E:\\JavaIdea\\te728\\mkdir\\java.txt")) {
            /*int ch=fileReader.read();
            System.out.println((char) ch);  //读取一个字符*/
            /*int ch=0;
            while ((ch=fileReader.read())!=-1){
                System.out.print((char) ch);    //一个一个读取
            }*/
            int ch=0;
            char[] chars=new char[1024];
            while ((ch=fileReader.read(chars))!=-1){
                System.out.println(new String(chars,0,ch));
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

字符缓冲流特有功能

BufferedWriter

• void newLine(); 写一行行分割号，行分割字符串由系统定义

BufferedReader

• public String readLine() : 读一行文字。包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到达，则为null

IO流小结

小案例汇总

判断两个文件是否相同

public class SameFile {
    public static void main(String[] args) throws IOException {
        /*try (FileInputStream fis = new FileInputStream("E:\\JavaIdea\\te728\\mkdir\\java.txt");
           FileOutputStream fos = new FileOutputStream("E:\\JavaIdea\\te728\\mkdir\\jvm.txt")) {
            int len;
            byte[] buffer = new byte[4096];
            while ((len = fis.read(buffer)) > 0) {
                fos.write(buffer, 0, len);
            }
        } catch (IOException e) {
            // ... handle IO exception
        }*/
        FileInputStream fis = new FileInputStream("E:\\JavaIdea\\te728\\mkdir\\java.txt");
        FileInputStream fis1 = new FileInputStream("E:\\JavaIdea\\te728\\mkdir\\jvm.txt");
        //int i;
        //byte[] bytes=new byte[1024];
        System.out.println(".".repeat(30));
        byte[] b1 = fis.readAllBytes();
        byte[] b2 = fis1.readAllBytes();
        // System.out.println(new String(b1));
        //System.out.println(new String(b2));
        if (Arrays.equals(b1, b2)) {                        //b1.equals(b2) 错误比较方法 比较的是对象数组
            System.out.println("两个文件文件相同");
        } else {
            System.out.println("两个文件不同");
        }
        System.out.println(".".repeat(30));
        if (fis.available() == fis1.available()) {   //判断文件中字节的个数
            System.out.println("两个文件相同");
        }
       /* System.out.println(".".repeat(30));
        int by1=0;
        byte[] by = new byte[20];
        by1=fis1.read(by);
        System.out.println(new String(by,0,by1));*/
    }
}