Java一文认识IO操作流

Posted 2022-08-24 意愿三七

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java一文认识IO操作流相关的知识，希望对你有一定的参考价值。

快速上手IO流

一、什么是文件？
二、什么是文件流
三、常用的文件操作
四、IO流原理及流的分类

一、什么是文件？

这个我想大家都知道，ppt啊，world文件，都是文件

二、什么是文件流

文件是在程序中已流的形式来操作的

实在不行你们就理解为下面的（杯子是文件）（水是数据）

水到胃就是输入流，往肚子里面输，
胃到水就是输出流，往肚子外吐。

三、常用的文件操作

1.创建文件

方式一

public static void main(String[] args) throws IOException 
        //方式1
        String filePath = "e:\\\\news1.txt"; //声明存放的地方，和文件名
        File file = new File(filePath); //把信息放出来
        file.createNewFile();			//创建文件
        System.out.println("创建成功");

方式二（根据父目录（就是存放路径）+子路径（就是文件名））

  public static void main(String[] args) throws IOException 
        File filePath = new File("E:\\\\test");  //存放路径
        String fileName = "news2.txt";          //文件名称
        File file = new File(filePath,fileName);
        file.createNewFile();
        System.out.println("创建成功");

有人在想为什么有第一个File对象，下面还有一个？

其实在计算机，如果有File对象，只是在内存中有这么一个对象，但是在硬盘里面还没有，我们需要createNewFile（）这个操作，把这个对象放进去硬盘。

相当于：孩子妈肚子里有孩子，但是没有出来，需要createNewFile（），才可以出来。

方式三

 public static void main(String[] args) throws IOException 
        String filePath = "E:\\\\test";  //存放路径
        String fileName = "news3.txt";          //文件名称
        File file = new File(filePath,fileName);
        file.createNewFile();
        System.out.println("创建成功");

也是上面差不多，只不过上面的是File 对象，加String
这个是2个String

要注意存放路径 \\\\ ，也可以使用一个/

2.获取文件的相关信息

public static void main(String[] args) 
        String filePath = "e:\\\\news1.txt";
        File file = new File(filePath);
        System.out.println("得到文件名"+file.getName());
        System.out.println("得到文件绝对路径"+file.getAbsolutePath());
        System.out.println("得到文件父级目录"+file.getParent());
        System.out.println("得到文件大小（按字节）"+file.length());  //utf-8 一个英文1个字节1个汉字3个字节
        System.out.println("文件是否存在"+file.exists());
        System.out.println("是不是一个文件"+file.isFile());
        System.out.println("是不是一个目录"+file.isDirectory());

输出

3.目录的创建和文件删除

判断e:\\news1.txt文件是否存在，存在就删除

delete方法返回的是布尔值

 public static void m1()
        String filePath = "e:\\\\news1.txt";
        File file = new File(filePath);
        if (file.exists())
           if (file.delete())
               System.out.println("删除成功");
           else
               System.out.println("删除失败");
           
        else
            System.out.println("文件不存在");

需要注意java中目录也是一个特殊的文件也可以进行操作

 public static void m2()
        String filePath = "E:\\\\del";  //这里是目录
        File file = new File(filePath);
        if (file.exists())
            if (file.delete())
                System.out.println("删除成功");
            else
                System.out.println("删除失败");
            
        else
            System.out.println("目录不存在");

需注意：目录里面有文件 delete删除不了

判断目录是否存在，没有就创建

需注意mkdirs()是创建多级目录，创建一级目录（就是一个文件夹）使用mkdir()，不正确使用会报错

public static void m3()
        String DirectoryPath = "E:\\\\del\\\\a\\\\b\\\\c";
        File file = new File(DirectoryPath);
        if (file.exists())
            System.out.println("目录存在");
        else
            if (file.mkdirs())
                System.out.println("该目录创建成功");
            else
                System.out.println("创建失败");

四、IO流原理及流的分类

1.流的分类和原理：

1）按照数据单位不同分为：

字节流（8 bit），字符流

注意字符流并不可以确定是多大单位，因为是要看编码格式的，
它们的效率谁好，那肯定字符流，因为字节流读取单位小，

应用场景：

那为什么要字节流，字节流可以操作二进制文件，比如音乐，视频，可以进行无损操作。

字符流用来操作文本文件这样的比较好。

2）按照数据流的流向分为：

输入流

输出流

3）按照流的角色不同分为：

节点流，处理流/包装流

字节流和字符流 分别对应两种流

字节流的两大类：字节输入流，字节输出流

它们2个的顶级父类，分别是InputSream 和OutputStream 都是抽象类

使用的时候要实现它们的子类才可以

字符流的两大类：字符输入流，字符输出流

它们2个的顶级父类，分别是Reader 和Writer 都是抽象类

使用的时候要实现它们的子类才可以

Java的IO有40多个类，实际上非常规则，都是从上面4个抽象类派生出来的

由这四个类派生出来的子类名称都是以其父类名当子类名后缀。

IO流体系图：

文件 vs 流：

我们通过画图来看清楚流到底是什么：

物品（数据）通过外卖小哥（流）来传达到用户（程序）手上

反之一样

2.常用的类

2.1 字节流的常用流

FileInputStream：文件输入流
BufferedInputStream：缓冲字节输入流
ObjectInputStream：对象字节输入流

来看看关系，发现BufferedInputStream的父类其实是FilterInputStream，但是这个父类也是InputStream的子类

2.1.1 FileInputStream常用类

构造方法：

那些参数是什么意思呢，其实我们看第一个就比较形象了，File对象是个文件（这里当物品/东西），FileInputStream 是外卖小哥，小哥拿着物品去送出去，物品和小哥之间有一定的联系。

开始操作：

使用read()无参数构造方法，读取完毕返回-1

public static   void readFile01()
        String filepath = "E:\\\\test\\\\hello.txt";
        FileInputStream fileInputStream = null;  //如果定义在try里面 finally使用不了
        int readDate = 0;
        try 
            //创建FileInputStream对象用于读取文件
             fileInputStream = new FileInputStream(filepath);
            //read() 返回-1代表读取完毕
            while((readDate =  fileInputStream.read()) != -1)   //为什么要循环因为读取的内容可能不是一次
                System.out.print((char)readDate);
            
         catch (IOException e) 
            e.printStackTrace();
        finally 
            //关闭流 流是一种资源，不关闭会造成浪费
            try 
                fileInputStream.close();
             catch (IOException e) 
                e.printStackTrace();

使用read无参构造方法，其实还是有不好的单个效率太低，我们可以使用read的其他构造参数。

使用read()字符数组构造方法，读取完毕返回-1，未结束反复字符数组的长度，

public static   void readFile02()
        //字节数组
        byte[] buf = new byte[8];//一次读8个字节
        int readDate = 0; //接收字符的长度
        String filepath = "E:\\\\test\\\\hello.txt";

        FileInputStream fileInputStream = null;  //如果定义在try里面 finally使用不了
        try 
            //创建FileInputStream对象用于读取文件
            fileInputStream = new FileInputStream(filepath);
            //read() 返回-1代表读取完毕
            while((readDate =  fileInputStream.read(buf)) != -1)   //为什么要循环因为读取的内容可能不是一次
                System.out.print(new String(buf,0,readDate));//
            
         catch (IOException e) 
            e.printStackTrace();
        finally 
            //关闭流 流是一种资源，不关闭会造成浪费
            try 
                fileInputStream.close();
             catch (IOException e) 
                e.printStackTrace();

2.1.2 FileOutputStream常用类

构造方法：

类图：

题目：

public static void writerFile()
         //创建一个FileOutPutStream
        String filePath = "E:\\\\test\\\\a.txt";
        FileOutputStream fileOutputStream = null;

        try 
            //得到FileOutputStream对象
            fileOutputStream = new FileOutputStream(filePath);
            //写入一个字节
            //fileOutputStream.write('a');
            //写入一个字符串
            String str = "hello,world";
            fileOutputStream.write(str.getBytes());
             // String的方法，把字符串转为字符数组,write() 会覆盖
            System.out.println("写入成功");
         catch (IOException e) 
            e.printStackTrace();
        finally 
            try 
                fileOutputStream.close();
             catch (IOException e) 
                e.printStackTrace();

Write ()会覆盖，如果不想覆盖就，第二个参数变成true，追加到文字后。

2.1.3 使用字节输入输入出流拷贝一个文件

public static void main(String[] args) 
        //src 原目标文件   dest 拷贝到什么位置
        String srcfilePath = "C:\\\\Users\\\\Administrator\\\\Pictures\\\\Saved Pictures\\\\QQ图片20210806104237.jpg";
        String destfilePath = "D:\\\\A1\\\\QQ.jpg";
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;

        try 
            fileInputStream = new FileInputStream(srcfilePath);  //先图片输入到程序
            fileOutputStream = new FileOutputStream(destfilePath); //在从程序输出到文件夹
            //定义字节数组提高效率
            byte []  buf =  new byte[1024];
            int readLen = 0;
            while ((readLen = fileInputStream.read(buf))!= -1)
                //读取到程序就由程序写出去 通过fileOutputStream
                //边读边写
                fileOutputStream.write(buf,0,readLen);
                //一定使用这个方法 带这些参数 为什么呢？因为怕其他的冗余数据进去 破坏文件 1039个字节，一次1024 还有剩余可能会有问题
            
            System.out.println("拷贝OK");
         catch (IOException e) 
            e.printStackTrace();
        finally 
            //关闭输入输出流
            if(fileInputStream != null)
                try 
                    fileInputStream.close();
                 catch (IOException e) 
                    e.printStackTrace();
                
            
            if(fileOutputStream != null)
                try 
                    fileOutputStream.close();
                 catch (IOException e) 
                    e.printStackTrace();

2.2 字符流的常用流

FileReader：

类图：

FileWriter：

类图：

2.2.1 FileReader常用类

public static void main(String[] args) 
        String filePath = "E:\\\\test\\\\story.txt";
        //1.创建一个对象
        FileReader fileReader = null;
        int date = 0;
        try 
            fileReader = new FileReader(filePath);
            while((date = fileReader.read())!=-1)
                System.out.print((char) date);
            

         catch (IOException e) 
            e.printStackTrace();
        finally 
            try 
                fileReader.close();
             catch (IOException e) 
                e.printStackTrace();

使用字符数组来

 public static void main(String[] args) 
        String filePath = "E:\\\\test\\\\story.txt";
        //1.创建一个对象
        FileReader fileReader = null;
        int readLen = 0;
        char [] buf = new char[1024];
        try 
            fileReader = new FileReader(filePath);
            //循环读取 使用read(buf) ,返回实际读取到的字符数，返回-1 文件结束
            while((readLen = fileReader.read(buf))!=-1)
                System.out.print(new String(buf,0,readLen));
            

         catch (IOException e) 
            e.printStackTrace();
        finally 
            try 
                fileReader.close();
             catch (IOException e) 
                e.printStackTrace();

new String(buf,0,readLen) 从什么数组，从几下标开始，取多少个

2.2.2 FileWriter常用类

 public static void main(String[] args) 
        String FilePath = "E:\\\\test\\\\a.txt";
        FileWriter fileWriter = null;
        char [] chars = 'y','y';
        try 
            fileWriter = new FileWriter(FilePath);
            //写入单个字符
            fileWriter.write('H');
            //写入指定的数组
            file以上是关于Java一文认识IO操作流的主要内容，如果未能解决你的问题，请参考以下文章 
 一文理解Java IO/NIO/AIO
 java IO包装流如何关闭
 一文吃透：Java IO流(输入与输出）轻松掌握核心思路
 Java IO流中先关闭输出流还是先关闭输入流？为什么？
 Java IO流中先关闭输出流还是先关闭输入流？为啥？
 一文搞定Java的输入输出流等常见流