14.IO流

m0_50982601

已于 2022-07-17 19:00:51 修改

阅读量63

点赞数

分类专栏：交流学习文章标签： java linux 前端

于 2021-08-17 16:11:25 首次发布

本文链接：https://blog.csdn.net/m0_50982601/article/details/119759351

版权

交流学习专栏收录该内容

11 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的I/O流，包括文件输入/输出流、数据写入、File类的使用以及常见流对象。通过实例展示了如何使用FileInputStream和FileOutputStream进行文件读写，并探讨了如何通过缓冲区提高读写效率。

摘要由CSDN通过智能技术生成

IO流

I/O ：输入/输出
- I：Input，指的是接收数据
- O：Output，指的是发送数据
文件IO：Input 是读文件，Output 是写文件
网络IO：Input是接收数据，Output是发送数据

文件IO

来自java.io.*
最常见的几个类：

InputStream / FileInputStream
OutputStream / FileOutputStream
Writer
Reader

了解文件：

文件，是计算机系统中的一个实体
文件中存储的数据
不同类型的文件存储不同类型的数据：例如：.txt .html .mp4 .jpg

什么是数据

无论何种类型的文件，里面存储的数据，而数据就是一堆字节，即文件大小。即文件字节 byte[]。

小结：

对于普通用户来说，文本文件里是文本，图片文件里是图片，视频文件里是视频。
对于程序员来说，任何文件里都只是字节数据。

数据的写入

数据，在Java里用byte[] 表示

例如：

byte[] data = {0,2,4,6,8,10,12,14};//其中，data定义了8个字节的数据

将数据写入到文件：

File file = new File("example.123");
OutputStream outputStream = new FileOutputStream(file);
outputStream.write(data,0,8);
outputStream.close();//关闭流
//其中，File仅表示文件路径，FileOutputStream才是真的创建文件

案例：

package IOStream;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class TestWrite {
    public static void main(String[] args) throws Exception {
        //数据
        byte[] data = {0,2,4,6,8,10,12,14};

        //写入文件
        File file = new File("example.123");//文件后缀名为 .123
        OutputStream outputStream = new FileOutputStream(file);//创建目标文件
        outputStream.write(data,0,8);//8个字节：data[0]-->data[7]
        outputStream.close();

        System.out.println("Exit.");
    }
}
//运行结果生成了一个名为：example.123 的文件，里面存入了十六进制的数组数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Iy8umn47-1629187866967)(C:\Users\LXK\AppData\Roaming\Typora\typora-user-images\image-20210808130730161.png)]

要点与细节：

文件名的后缀名可以自由定义，例如：*.txt *.123 *.abc都行

打开文件

outputStream = new FileOutputStream(file);
//如果目标文件不存在，则创建新的文件
//如果目标文件已经存在，则覆盖文件内容

第一个入门IO流案例

package IOStream;

import java.io.FileInputStream;

public class Test02 {
    public static void main(String[] args) {
        //1.创建字节输入流对象
        FileInputStream fis = null;
        try{
           fis = new FileInputStream("d:/A.txt");
           int s1 = fis.read();//打印输入字符A对应的ASCII码值65
            int s2 = fis.read();//打印输入字符B对应的ASCII码值66
            int s3 = fis.read();//打印输入字符C对应的ASCII码值67
            int s4 = fis.read();//由于文件内容已经读取完毕，则返回-1
            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s3);
            System.out.println(s4);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (fis!=null){
                try{
                    fis.close();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
}

改进案例

package IOStream;

import java.io.FileInputStream;

public class Test03 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try{
            //创建自己输入流对象
            fis = new FileInputStream("d:/a.txt");
            StringBuffer sb = new StringBuffer();
            int temp = 0;
            while ((temp = fis.read())!=-1){
                System.out.println(temp);
                sb.append((char) temp);
            }
            System.out.println(sb.toString());//ABC
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (fis != null){
                    fis.close();
                }
            }catch (Exception e){
            }
        }
    }
}

File类的基本使用

操作文件

package IOStream;

import java.io.File;

public class FileDemo {
    public static void main(String[] args) throws Exception {
        // 创建File对象
        File file = new File("d:/b.txt");
        System.out.println( file.createNewFile());//创建了名为：b.txt的文件
//        System.out.println(file.delete());//删除创建的文件
        System.out.println(file.exists());//判断创建的文件是否存在
        System.out.println(file.getName());//获取创建文件的名字
        System.out.println(file.isFile());//判断是否为文件
        System.out.println(file.isHidden());//是否为隐藏文件
    }
}

操作目录

package IOStream;

import java.io.File;

public class DirectoryDemo {
    public static void main(String[] args) {
        //创建File对象
//        File file = new File("d:/a");
//        System.out.println(file.mkdir());//创建单级目录
        File file1 = new File("d:/b/c");
//        System.out.println(file1.mkdirs());//创建多级目录
//        System.out.println(file1.exists());//判断该目录是否存在
//        System.out.println(file1.isDirectory());//true
//        System.out.println(file1.getParent());//获取当前目录的父级目录 打印：d:\b
//        System.out.println(file1.getParentFile());//获取当前目录的父级目录 打印：d:\b
        File file2 = new File("d:/");
        String[] arr = file2.list();
        for (String s : arr) {
            System.out.println(s);//只返回该路径下的所有文件和目录
        }
        System.out.println("---通过listfile---");
        File[] arr2 = file2.listFiles();
        for (File file : arr2) {
            System.out.println(file);//返回结果包含绝对路径
        }
    }
}

常用流对象

文件字节流

fileInputStream通过字节的方式读取文件，适合读取所有类型的文件（图像、视频、文本文件等）。java也提供了FileReader专门读取文本文件。

FileOutputStream通过字节的方式写数据到文件中，适合所有类型的文件。java也提供了FileWriter专门写入文本文件。

文件字节输入流：

package IOStream;

import java.io.FileInputStream;

public class FileStreamDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try{
//创建文件字节输入流对象
            fis = new FileInputStream("C:/Users/LXK/Pictures/FeverLove.jpeg");
            int temp = 0;
            while ((temp = fis.read())!=-1){
                System.out.println(temp);//输出int 型 字节
            }
        }catch (Exception e){

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

            }
        }
    }
}

文件字节输出流：

package IOStream;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class FileStreamDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try{
//创建文件字节输入流对象
            fis = new FileInputStream("C:/Users/LXK/Pictures/FeverLove.jpeg");
            //创建文本字节输出流对象
            fos = new FileOutputStream("d:/xj.jpg");
            int temp = 0;
            while ((temp = fis.read())!=-1){
//                System.out.println(temp);//输出int 型 字节
                fos.write(temp);
            }
            //将数据从内存中写入到磁盘中。
            fos.flush();
        }catch (Exception e){

        }finally {
            try{
                if (fis!=null){
                    fis.close();
                }
                if (fos != null){
                    fos.close();
                }
            }catch (Exception e){
                e.printStackTrace();

            }
        }
    }
}

通过缓冲区提高读写效率

通过创建一个指定长度的字节数组作为缓冲区，以此来提高IO流的读写效率。该方式适用于读取较大图片时的缓冲区定义。注意：缓冲区的长度一定是2的整数幂。一般情况下1024长度较为合适。

package IOStream;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class FileStreamBuffedDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try{
//创建文件字节输入流对象
            fis = new FileInputStream("C:/Users/LXK/Pictures/FeverLove.jpeg");
            //创建文本字节输出流对象
            fos = new FileOutputStream("d:/xj.jpg");
            //创建一个缓冲区，提高读写效率
            byte[] buff = new byte[1024];
            int temp = 0;
            while ((temp = fis.read(buff))!=-1){
//                System.out.println(temp);//输出int 型 字节
                fos.write(buff,0,temp);
            }
            //将数据从内存中写入到磁盘中。
            fos.flush();
        }catch (Exception e){

        }finally {
            try{
                if (fis!=null){
                    fis.close();
                }
                if (fos != null){
                    fos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

  fos.flush();
    }catch (Exception e){

    }finally {
        try{
            if (fis!=null){
                fis.close();
            }
            if (fos != null){
                fos.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

}