Java IO流

captain_dong

已于 2022-05-29 14:00:01 修改

阅读量122

点赞数 1

文章标签：学习 java idea 开发语言

于 2022-05-22 23:25:38 首次发布

本文链接：https://blog.csdn.net/m0_63064861/article/details/124918713

版权

File类：

File：是文件和目录路径名的抽象表示。文件和目录是可以通过File封装成对象的。

构造方法：

>>>File(String pathname):通过将给定的路径名字符转换为抽象路径名来创建新的File 实例；

File(String parent,String chile):通过父路径名字符串和子路径字符串创建新的File实例；

File(File parent,String child):从父抽象路径名和子路径名字符串创建新的File实例。

File f1=new File("E:\\develop\\java.txt");

File f2=new File("E:\\develop","java.txt");

;;;;

File f3=new File("E:\\develop");

File f4=new File(f3,"java.txt");

File类创建功能：

>>>public boolean creatrNewFile() :当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件。如果文件不存在，就创建文件，返回true；

如果文件存在，就不创建，返回false；

.

>>>public boolean mkdir() :创建由此抽象路径名命名的目录；

如果目录不存在，就创建目录，返回true；

如果目录存在，就不创建目录，返回false；

；

>>>public boolean mkdirs() ：创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录。//可以创建多级目录。

如果目录不存在，就创建目录，返回true；

如果目录存在，就不创建目录，返回false；

1：在E:\\develop目录下创建一个文件java.txt

File f1=new File("E:\\develop\\java.txt"); //创建对象

System.out.println(f1.creatNewFile()); //输出true,创建成功！

2：在E:\\develop目录下创建一个目录javaSE：

File f2=new File("E:\\develop\\javaSE");

System.out.println(f2.mkdir()); //输出true，E:\\develop下多了个目录javaSE；

；

3：在E:\\develop目录下创建一个多级目录javaSE\\HTML

File f3=new File("E:\\develop\\javaWEB\\HTML");

System.out.println(f3.mkdirs()); //输出true 创建一个多级目录

4：在E:\\develop目录下创建一个文件javase.txt //创建文件用创建文件的方式

File f4=new File("E:\\develop\\javase.txt");

//System.out.println(f4.mkdir()); //只是创建了目录

System.out.println(f4.creatNewFile()); //输出true

1-访问文件名相关方法：

String getName():返回File对象所对应的路径名

String getPath() :返回File对象的绝对路径

File getAbsoluteFile() :返回此File对象的绝对路径

String getAbsolutePath() :返回File对象所对应的绝对路径

String getParent() :返回此File 对象所对应的的目录（最后一级子目录）的父目录名

boolean renameTo(File newName) :重命名此File对象所对应的文件或目录，如果重命名成功，则返回true，否则返回false。

2-文件检测相关的方法：

boolean exists() :判断File对象所对应的文件或目录是否存在。

boolean canWrite() ：判断File对象所对应的文件或目录是否可写；

boolean canRaed() ：判断File 对象所对应的文件或目录是否可读；

boolean isFile() ：判断File 对象所对应的是否是文件而不是目录；

boolean isDirectory() ：判断File 对象所对应的是否是目录而不是文件；

boolean isAbsolute() ：判断File 对象所对应的文件或目录是否是绝对路径。

3-获取常规文件信息：

long lastModified() ：返回文件的最后修改时间；

long length() ：返回文件内容的长度。

Java IO 流：

1-输入流和输出流：

输入流：只能从中读取数据，而不能向其写入数据；

输入流：只能向其写入数据，而不能从中读取数据。

2-字节流和字符流：

字节流操作的数据单元是8位的字节，而字符流操作的数据单元是16位的字符·；

字节流主要由InputStream和OutputStream作为基类；

字符流主要由Reader和Writer作为基类。

3-节点流和处理流：

节点流：可以从\向有关特定的IO设备（如磁盘、网络）读\写数据的流。节点流也被称为低级流。

处理流：用于对一个已经存在的流进行连接或封装，通过封装后的流来实现数据的读\写功能。处理流也被称为高级流。

处理流功能体现：

>>>性能的提高：主要以增加缓冲的方式来提高输入\输出的效率。

>>>操作的便捷：处理流可能提供了一系列便捷的方法来一次输入\输出大批量的内容，而不是输入\输出一个或多个“水滴”，对于字节流，每个“水滴”是字节；对于字符流，该水滴是字符。

字节流和字符流:

>>>InputStream和Reader：

InputStream里包含3个方法：

>>>int read() ：从输入流中读取单个字节，返回所读取的字节数据（字节数据可直接转换为int类型）。

>>>int read(byte[] b) ：从输入流中读取最多b.length个字节的数据，并将其存储在数组b中，返回实际读取的字节数。

>>>int read(byte[] b,int off,int len) ：从输入流中最多读取len个字节的数据，并将其存储在数组b中；放入数组b中时，并不是从数组起点开始，而是从off位置开始，返回实际读取的字节数。

Reader里包含3个方法：

>>>int read () ：从输入流中读取单个字符，返回所读取的字符数据（字符数据可直接转换为int类型）。

>>>int read(char[] cbuf) ：从输入流中读取最多b.length个字符的数据，并将其存储在字符数组cbuf中，返回实际读取的字符数。

>>>int read(char[] cbuf,int off,int len) ：输入流中最多读取len个字符的数据，并将其存储在字符数组cbuf中；放入数组cbuf中时，并不是从数组起点开始，而是从off位置开始，返回实际读取的字符数。

程序如何判断取水取到最后呢？直到 read(char[] cbuf) 或read(char[] cbuf,int off,int len) 方法返回-1，即表明到了输入流的结束点。（-1可以作为循环结束的标志）。

InputStream和Read都是抽象类，无法创建实例，但是它们分别有一个用于读取文件的输入流：FileInputStream和FileRead，它们都是节点流------会直接和指定文件关联。如下：

public class FileInputStreamTest
{
    public static void mian(String[] args)
    {
        //创建节点输入流
        FileInputStream fis=new  FileInputStream(" FileInputStreamTest.java");
        //创建一个长为1024的“竹筒”
        byte[] bbuf=new byte[1024];
        //用于保存实际读取的字节数
        int hasRead=0;
        //使用循环来重复“取水”过程
        while((hasRead=fis.read(bbuf))>0)
        {
            //取出"竹筒"中的水滴（字节），将字节数组转换为字符串输入
            System.out.println(new String(bbuf,0,hasRead));
        }
        //关闭文件输入流，放在finally块里更安全
        fis.close();
    }
}

使用fis.close()来关闭该文件的输入流，程序里打开的文件IO资源不属于内存里的资源，垃圾回收机制无法回收该资源，所有应该显式关闭文件IO资源。

也可以通过自动关闭资源的try语句来关闭这些IO流。如下：

public class FileReaderTest 
{
    public static void mian(String[] args)
    {
        try(

         //创建节点输入流
        FileReader fr=new  FileReader(" FileReaderTest.java");
        //创建一个长为1024的“竹筒”
        char[] cbuf=new char[32];
        //用于保存实际读取的字节数
        int hasRead=0;
        //使用循环来重复“取水”过程
        while((hasRead=fr.read(cbuf))>0)
        {
            //取出"竹筒"中的水滴（字节），将字节数组转换为字符串输入
            System.out.println(new String(cbuf,0,hasRead));
        }
      catch(IOException ex)
        {
            ex.printStackTrace();
        }
    }
}

>>>OutputStream和Writer:

两个流都提供了如下3个方法：
>>>void write(int c) :将指定的字节数组\字符数组中的数据输出到输出流中，其中c既可以代表字节又可以代表字符。
>>>void write(byte[]/char[] buf) ：将字节数组/字符数组中数据输出到指定输出流中。
>>>void write(byte[] char[] buf,int off,int len) ：将字节数组/字符数组中从off位置开始，长度为len的字节/字符输出到输出流中。

>>>>因为字符流直接以字符作为操作单位，所以Writer可以用字符串来代替字符数组，即以String对象作为参数。Writer里还包含如下两个方法：

>>>void write(String str) ：将str字符串里包含的字符输出到指定输出流中。
>>>void write(String str,int off,int len) ：将str字符串里从off位置开始，长度为len的字符输出到指定输出流中。如下程序使用FileInputStream 来执行输入，并使用FileOutputStream来执行输出，用以实现复制FileOutStreamText.java文件的功能。

public class FileOutputStreamTest
{
    public static void main(String[] args)
    {
        try(
                //创建字节输入流
                FileInputSream fis=new FileInputStream("FileOutputStreamText.java");
                //创建字节输出流
                FileOutputStream fos=new  FileOutputStream("newFile.txt");
            )
        {
            byte[] bbuf=new byte[32];
            int hasRead=0;
            //循环从输入流中取出数据
            while((hasRead=fis.read(bbuf))>0)
            {
                //每读取一次，即写入文件输出流，读了多少，就写多少
                fos.write(bbuf,0,hasRead);
            }
        }
        catch(IOException ioe)
        {
            ioe.printStackTrace();
        }
    }
}

运行是买你的程序，将看到系统当前路径下多了一个文件：newFile.txt，该文件的内容和FileOutputStreamTest.java文件的内容完全一样。

注意：使用 Java 的 IO 流执行输出时，不要忘记关闭输出流，关闭输出流除了可以保证流的物理资源被回收之外,可能还可以将输出流缓冲区中的数据 flush 到物理节点里(因为在执行 close())方法之前，自动执行输出流的 flush()方法）。 Java 的很多输出流默认都提供了缓冲功能，要正常关闭所有的输出流即可保证程序正常。

>>>如果希望字节输出字符串内容，则可以使用Writer会有更好的效果：

public class FileWriterTest
{
    public static void main(String[] args)
    {
        try(
                FileWriter fw =new FileWriter("poem.txt")
            )
           {
                fw.write("锦瑟---李商隐\r\n");
                fw.write("锦瑟无端五十弦，一弦一柱思华年。\r\n");
                fw.write("庄生晓梦迷蝴蝶，望帝春心托杜鹃。\r\n");
                fw.write("沧海月明中有泪，蓝田日暖玉生烟。\r\n");
                fw.write("此情可待成追忆，只是当时已惘然。\r\n");
            }
        catch(IOException ioe)
        {
            ioe.printStackTrace();
        }
    }
}

运行上面的程序，将会在当前目录下输出一个poem.txt文件，文件内容就是程序中输出的内容。

注意：Windows平台的换行符：\r\n ；如果是UNIX\Linux\BSD等平台，则使用\n作为换行符。

输入\输出流体系：

处理流的用法：使用处理流来包装节点流，程序通过处理流来执行输入\输出功能，让节点流与底层的I/O设备、文件交互。
使用PrintStream处理流来包装OutputStream,使用处理流后的输出流在输出时更加方便。

public class PrintStreamTest
{
    public static void main(String[] args)
    {
        try(
                FileOutputStream fos=new FileOutputStream("test.txt");
                PrintStream ps=new PrintStream(fos)
            )
            {
                //使用PrintStream执行输出
                ps.println("普通字符串");
                //直接使用PrintStream输出对象
                ps.println(new PrintStreamTest());
            }
            catch(IOException ioe)
                  {
                    ioe.printStackTrace();
                  }
    }
}

由于PrintStream类的输出功能非常强大，通常如果需要输出文本内容，都应该将输出流包装成PrintStream后进行输出。

转换流：

两个转换流用于实现将字节流转换成字符流，其中InputStreamReader将字节输入流转换成字符输入流，OutputStream将字节输出流转换成字符输出流。

将System.in包装成BufferReader, BufferReader流具有缓冲功能，它可以一次读取一行文本——以换行符作为标志；如果没有读到换行符，则程序阻塞，直到读到换行符为止。由于BufferReader具有一个readLine()方法，可以非常方便地一次读入一行内容，所以经常把读取文本内容的输入流包装成BufferReader，用来方便地读取输入流的文本内容。