一文吃透：Java IO流(输入与输出）轻松掌握核心思路

Posted 2021-05-15 Java_Pluto

1.File Class

File类代表一个文件或者文件目录

构造器：

• File(String pathname)
• File(String pathname,String child)
• File(String parent,String child)

parent目录路径 child表示从parent的下一层目录

File file = new File("C:\\\\Users\\\\cw\\\\Desktop\\\\Project\\\\Java\\\\study\\\\src\\\\com\\\\cwstd\\\\iostream\\\\123.txt");
        File file1=new File("123.txt");
        File file2=new File("C:\\\\Users\\\\cw\\\\Desktop\\\\Project\\\\Java\\\\study\\\\src\\\\com\\\\cwstd\\\\iostream","123.txt");
        File file3=new File("C:\\\\Users\\\\cw\\\\Desktop\\\\Project\\\\Java\\\\study\\\\src\\\\com\\\\cwstd","iostream");

1.1 File类的获取方法

• getAbsolutePath()获取绝对路径
• getAbsoluteFile()获取绝对路径表示的文件
• getPath()获取路径
• getParent()获取上一层文件目录路径，若无返回null length()获取文件长度（字节数）
• lastModified() 获取最后一次修改时间
• String [] list()获取目录下所有文件和文件夹的名称数组,返回String数组
• File[] listFiles()获取指定目录下的所有文件夹和文件目录File数组

//获取绝对路径
        System.out.println(file.getAbsolutePath());
        //获取绝对路径表示的文件
        System.out.println(file.getAbsoluteFile());
        //获取路径
        System.out.println(file.getPath());
        //获取上一层文件目录路径，若无返回null
        System.out.println(file.getParent());
        //获取文件长度（字节数），不能获取目录的大小
        System.out.println(file.length());
        //获取最后一次修改时间
        System.out.println(file.lastModified());
        //获取目录下所有文件和文件夹的名称数组,返回String数组
        String []filenames=file3.list();
        for (String o:filenames)
        {
            System.out.println(o);
        }
        //获取指定目录下的所有文件夹和文件目录File数组
        File [] filenames2=file3.listFiles();
        for (File files : filenames2)
        {
            System.out.println(files.getName());
        }

1.2 File类的重命名与创建文件功能

renameTo()把文件重命名为指定的文件路径

file2.renameTo(new File("C:\\\\Users\\\\cw\\\\Desktop\\\\Project\\\\Java\\\\study\\\\src\\\\com\\\\suanfa\\\\binarytree\\\\123.txt"));

createNewFile() 创建文件，若文件存在，则不创建，返回false

mkdir() 创建文件目录，如果此文件存在，就不创建，如果上级目录不存在也不创建

mkdirs() 创建文件目录，上级目录不存在也会创建

//创建文件，若文件存在，则不创建，返回false
        file1.createNewFile();
        //创建文件目录，如果此文件存在，就不创建，如果上级目录不存在也不创建
        file4.mkdir();
        //创建文件目录，上级目录不存在也会创建
        file4.mkdirs();

2.Java IO流

2.1 Java IO流的概念

Java程序中输入与输出都是以流的方式的进行，I/O技术是用于处理设备之间的数据传输。在java中把不同的输入/输出源（键盘，文件，网络连接等）抽象表述为“流”(stream)。通过流的形式允许java程序使用相同的方式来访问不同的输入/输出源。stram是从起源（source）到接收的（sink）的有序数据。

主要的IO流

2.2 节点流

Java重要的节点流有FileInputStream FileOutputStream（字节流）和FileReader FileWriter（字符流）

注意：字符流是对字节流进行封装，字符流的底层也是字节流，进行封装转化，更方便简单处理字符文档（可以用记事本打开的）

例子:使用FileInputStream FileOutputStream（字节流）进行文件复制

• 第一步：创建流 输入流输出流分别指向
• 第二步：操作流 创建一个中转站（字节数组），在使用输入流read方法将字节流读入数组，直到文件复制完成。
• 第三步：关闭流 需要使用try–catch–finally捕获异常

/***
 * 使用FileInputStream和FileOutputStream实现文件复制
 */
public class TestFileStream {
    public static void main(String[] args) {
        //1.创建流
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try{
            fis = new FileInputStream("C:\\\\Users\\\\cw\\\\Desktop\\\\Project\\\\Java\\\\study\\\\src\\\\com\\\\cwstd\\\\iostream\\\\123.txt");
            fos = new FileOutputStream("C:\\\\Users\\\\cw\\\\Desktop\\\\Project\\\\Java\\\\study\\\\src\\\\com\\\\cwstd\\\\iostream\\\\12345.txt");
            //2.使用流
            //2.1使用一个中转站
            byte [] buf=new byte[1024];
            int len;//记录每次读取字节长度
            while((len=fis.read(buf))>=0)
            {
                fos.write(buf,0,len);//将读取的字节，写入新的文件中

            }
        }catch(Exception e)
        {
            e.printStackTrace();
        }finally {
            //3.关闭流
            if(fis!=null)
            {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fos!=null)
            {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}

2.3缓冲流

作用：缓冲流分为缓存字节流和缓存字符流，目的是提高访问速度，提高便捷。

原理：分别开辟一个输入流缓冲区，和输出流缓冲区，不用每次读取写入都直接操作硬盘，中转站会先从缓冲区读取或写入数据，如果缓冲区没有或者缓存写满，这时缓冲区才会操作硬盘，大大减少操作硬盘次数，节约时间。

注意：

• 缓冲流BufferedInputStream BufferedOutputStream 和 BufferedReader
  BufferedWriter是高层流，资源回收时，只需要关闭高层流，低层流会自动的关闭。
• 何时缓冲区写入硬盘，三种情况：缓冲区满、关闭缓冲流、手动使用flush函数。

例子1:使用FileInputStream FileOutputStream（字节流）进行文件复制，并使用BufferedInputStream BufferedOutputStream缓冲流提高速度。

public class TestDataInputStream {
    public static void main(String[] args) {
        DataInputStream dain=null;
        DataOutputStream daou=null;
        try{
            //创建数据流
            dain=new DataInputStream(new FileInputStream("C:\\\\Users\\\\cw\\\\Desktop\\\\Project\\\\Java\\\\study\\\\src\\\\com\\\\cwstd\\\\iostream\\\\Data.txt"));
            daou=new DataOutputStream(new FileOutputStream("C:\\\\Users\\\\cw\\\\Desktop\\\\Project\\\\Java\\\\study\\\\src\\\\com\\\\cwstd\\\\iostream\\\\Data.txt"));
            daou.writeBoolean(true);
            daou.writeChar('伟');
            daou.writeInt(12);
            daou.writeUTF("hhhhhhh");
            //读取数据
            System.out.println(dain.readBoolean());
            System.out.println(dain.readChar());
            System.out.println(dain.readInt());
            System.out.println(dain.readUTF());

        }catch (Exception e)
        {
            e.printStackTrace();
        }finally {
            if(dain!=null)
            {
                try {
                    dain.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(daou!=null)
            {
                try {
                    daou.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

对象流 ObjectInputStream和ObjectOutputStream
注意：

使用对象流写入和读取对象时，需要将类继承Serialization（序列化）或者DeSerialization（反序列化）

对象(内存)---->字节数组（外存，网络）---->（对象）内存

• static 修饰不参加序列化，可以使用transient使类的变量属性不参加序列化
• 序列化后不能修改类的内容（除非在创建类的时候，生成类的序列号）
• 如果对象写入文件，不仅要保证对象序列化，也要保证对象成员变量序列化

public class TestObjectInputStream {
    public static void main(String[] args) {
        ObjectInputStream dain=null;
        ObjectOutputStream daou=null;
        try{
            //创建数据流
            daou=new ObjectOutputStream(new FileOutputStream("C:\\\\Users\\\\cw\\\\Desktop\\\\Project\\\\Java\\\\study\\\\src\\\\com\\\\cwstd\\\\iostream\\\\Data.txt"));
            dain=new ObjectInputStream(new FileInputStream("C:\\\\Users\\\\cw\\\\Desktop\\\\Project\\\\Java\\\\study\\\\src\\\\com\\\\cwstd\\\\iostream\\\\Data.txt"));
            daou.writeBoolean(true);
            daou.writeChar('伟');
            daou.writeInt(12);
            daou.writeUTF("hhhhhhh");
            daou.writeObject(new Person(0,"cwstd",22));

            //读取数据
            System.out.println(dain.readBoolean());
            System.out.println(dain.readChar());
            System.out.println(dain.readInt());
            System.out.println(dain.readUTF());
            System.out.println(dain.readObject().toString());

        }catch (Exception e)
        {
            e.printStackTrace();
        }finally {
            if(dain!=null)
            {
                try {
                    dain.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(daou!=null)
            {
                try {
                    daou.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

看到这的小伙伴，给个一键三连吖 欢迎大家在评论区畅所欲言