0502-JavaIO

JAVA全栈
字数统计: 3.8k字   |   阅读时长≈ 15分钟

第一章 File

1.1 File概述

        File是对系统中的文件的抽象：将电脑中的文件（file）、文件夹（directory）、路径（path）封装为一个File类，用于对电脑中的文件和文件夹进行操作：①创建文件或文件夹②删除文件或文件夹③判断文件夹或文件夹状态④获取文件信息；

1.2 系统路径

  • 相对路径 : 查看路径是参照当前文件的路径为参照
  • 绝对路径 : 查看路径是参照当系统根路径为参照

1.3 File类API

1. 静态常量

静态成员变量 描述
String pathSeparator 与系统有关的字符串的路径分隔符
char pathSeparatorChar 与系统有关的字符的路径分隔符 分隔符
String separator 与系统有关的默认字符串的名称分隔符
charseparatorChar 与系统有关的默认字符的名称分隔符

2. 构造方法

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

3. 获取文件信息

方法 描述
File getAbsoluteFile() 返回此路径名的绝对路径名形式
String getAbsolutePath() 返回此路径名的绝对路径名字符串
File getCanonicalFile() 返回此路径名的规范形式
String getCanonicalPath() 返回此路径名的规范路径名字符串
String getName() 返回由此路径名表示的文件或目录的名称
String getParent() 返回此路径名父目录的路径名字符串或null。
File getParentFile() 返回此路径名父目录的路径名或null
String getPath() 将此路径名转换为一个路径名字符串
long lastModified() 返回此路径名表示的文件最后一次被修改的时间
long length() 返回由此路径名表示的文件的长度
String[] list() 返回此路径名表示的目录中的文件和目录的字符串数组
File[] listFiles() 返回此路径名表示的目录中的文件和目录的文件数组
String[] list(FilenameFilter filter) 满足指定过滤器的文件和目录的字符串数组
File[] listFiles(FileFilter filter) 满足指定过滤器的文件和目录的文件数组
File[] listFiles(FilenameFilter filter) 满足指定过滤器的文件和目录的文件数组
long getTotalSpace() 返回此抽象路径名指定的分区大小
ong getFreeSpace() 返回此路径指定的分区中未分配的字节数

4. 文件判断

方法 描述
boolean canExecute() 测试应用程序是否可以执行此路径表示的文件
boolean canRead() 测试是否可以读取此路径表示的文件
boolean canWrite() 测试是否可以修改此路径表示的文件。
boolean exists() 测试此路径表示的文件或目录是否存在。
boolean isAbsolute() 测试此路径是否为绝对路径名
boolean isDirectory() 测试此路径表示的文件是否是一个目录
boolean isFile() 测试此路径表示的文件是否是一个标准文件
boolean isHidden() 测试此路径名指定的文件是否是一个隐藏文件。

5. 文件的创建

  • static File createTempFile(String prefix, String suffix)
    • 创建一个空文件，使用给定前缀和后缀生成其名称
  • static File createTempFile(String prefix, String suffix, File directory)
    • 创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称
方法 描述
boolean createNewFile() 当且仅当不存在具有此路径名指定名称的文件时创建一个新的空文件
boolean mkdir() 创建此路径名指定的目录
boolean mkdirs() 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录

4. 文件的修改

方法 描述
boolean delete() 删除此路径名表示的文件或目录
void deleteOnExit() 在虚拟机终止时，请求删除此路径名表示的文件或目录
boolean renameTo(File dest) 重新命名此路径名表示的文件
boolean setExecutable(boolean executable) 设置此路径名所有者执行权限
boolean setExecutable(boolean e, boolean o) 设置此路径的所有者或所有用户的执行权限
boolean setLastModified(long time) 设置此路径名指定的文件或目录的最后一次修改时间
boolean setReadable(boolean readable) 设置此路径名所有者读权限
boolean setReadable(boolean r, boolean o) 设置此路径名的所有者或所有用户的读权限
boolean setReadOnly() 标记此路径指定的文件或目录只能对其进行读操作
boolean setWritable(boolean writable) 设置此路径名所有者写权限
boolean setWritable(boolean w, boolean o) 设置此路径名的所有者或所有用户的写权限

5. 其他

方法 描述
int compareTo(File pathname) 按字母顺序比较两个抽象路径名
boolean equals(Object obj) 测试此抽象路径名与给定对象是否相等
long getUsableSpace() 返回此抽象路径名指定的分区上可用于此虚拟机的字节数
int hashCode() 计算此抽象路径名的哈希码
String toString() 返回此抽象路径名的路径名字符串
URI toURI() 构造一个表示此抽象路径名的 file: URI

第二章 I/O流

2.1 IO流概述

  1. 什么是IO

            在电脑操作系统内，所有文件都是以二进制的形式存储在磁盘中，所以在操作系统中数据传输始终是二进制的数据流在磁盘或网络中通过应用程序进行传输；

            在Java程序中操作文件中数据流过程是：通过程序将磁盘中文件加载到内存中，程序操作内存中数据然后在写回到磁盘中；在这个过程中把数据加载到内存的过程称为输入流（InputStream），把内存中数据写入到磁盘称为输出流（OutputStream）；

  2. IO流分类

    • 以程序为中心按流的方向：分为输入流和输出流

    • 根据程序操作的流的内容：分为字节流和字符流：一切皆字节

      输入流：Input 输出流：Output
      字节流：Stream 字节输入流 InputStream 字节输出流 OutPutStream
      字符流：read和write 字符输入流 Reader 字符输出流 Writer
      R37Rat.png R372VI.png

  1. IO设计模式-装饰器

    • IO流的装饰作用是为了提高IO流的操作性能

    • 装饰器模式相关对象

      • 抽象组件：定义需要装饰的抽象类
      • 具体组件：是抽象组件的具体实现，是需要被装饰的类
      • 抽象装饰类：包含了具体组件，是对抽象类的实现是由被装饰组件实现，并对原有实现进行的增强
      • 具体装饰类：被装饰的对象

    • 核心代码

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      public class 装饰器类 implements 抽象组件{
          private 被装饰器类 decorator;
          public 装饰器类(被装饰器类 decorator){
          	this.decorator = decorator
          }
          
          @OverRide
          public void 增强方法(){
              decorator.增强方法() + 方法的增强;
          }
      }

  2. try新语法with -resource

    1
    2
    3
    4
    5
    6
    7
    8
    // 流无需手动关闭
    try(
        流的声明
    ){
        
    }cache(){
        
    }

  3. Java IO流体系

    RFJe0O.jpg

2.2 文件字节流

  1. 文件字节流概述：包括文件字节输入流（FileInputStream）：作用是从本地磁盘的文件中读取数据；文件字节输出流（FileOutputStream）：作用是将流中的字节写入到磁盘的文件中；

  2. 常用API说明

    FileInputStream 描述
    read() 从输入流中读取一个字节的数据，返回读取到的字节如果是文件末尾返回-1
    read(byte b[]) 从输入流中读取的字节保存到字节数组b中，返回读取到的长度；
    skip(long n) 跳过并丢弃输入流中的n个数据，返回实际跳过的字节数
    available() 可以从此输入流中读取的剩余字节数
    getChannel() 返回与此文件输入流关联的通道
    close() 关闭流
    FileOutputStream 描述
    write(int b) 将单个字节写入到输出流中
    write(byte b[]) 将字节数组中字节写入到输出流中
    write(byte b[], int off, int len) 将字节数组中字节写入到输出流中；指定起始偏移量，和写入长度
    close() 关闭流

  3. 案例演示

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    public class Demo01FileStreamTest {
        File file = new File("Demo01FileStreamTest.txt");

        @Test
        public void testFileOutputStream() {
            String fileMsg = "Hello Java IO";
            try (
                    OutputStream os = new FileOutputStream(file)
            ) {
                os.write(fileMsg.getBytes());
            } catch (Exception e) {
                log.error("e=", e);
            }
        }

        @Test
        public void testFileInputStream01() {

            try (
                    InputStream is = new FileInputStream(file)
            ) {
                int c = is.read();
                log.info("read()读取到一个字节={}", (char) c);
            } catch (Exception e) {
                log.error("e=", e);
            }
        }

        @Test
        public void testFileInputStream02() {
            try (
                    InputStream is = new FileInputStream(file)
            ) {
                int c;
                while ((c = is.read()) != -1) {
                    log.info("read()读取到一个字节={}", (char) c);
                }
            } catch (Exception e) {
                log.error("e=", e);
            }
        }

        @Test
        public void testFileInputStream03() {
            try (
                    InputStream is = new FileInputStream(file)
            ) {
                int len;
                byte[] buf = new byte[4];
                while ((len = is.read(buf)) > 0) {

                    log.info("read()读取到长度 = {}, buf = {}", len, new String(buf));
                }
            } catch (Exception e) {
                log.error("e=", e);
            }
        }
    }

2.3 缓存字节流

  1. 缓冲流概述：BufferedInputStream和BufferedOutputStream这两个类分别是FilterInputStream和FilterOutputStream的子类，作为装饰器子类，使用它们可以防止每次读取/发送数据时进行实际的写操作：带缓冲的流，可以一次读很多字节，但不向磁盘中写入，只是先放到内存里。等凑够了缓冲区大小的时候一次性写入磁盘，这种方式可以减少磁盘操作次数，速度就会提高很多！

  2. 缓存流API

    BufferedInputStream 描述
    close() 关闭流
    BufferedOutputStream 描述
    flush() 强行将缓冲区中的数据写出，否则可能无法写出数据
    close() 强行将缓冲区中的数据写出，并关闭流

  3. 案例演示

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public class Demo02BufferStreamTest {
        File file = new File("Demo01FileStreamTest.txt");
        @Test
        public void testBufferInputStream() {
            try (
                    InputStream is = new FileInputStream(file);
                    BufferedInputStream bis = new BufferedInputStream(is)
            ) {
                int len;
                byte[] buf = new byte[3];
                while ((len = bis.read(buf)) > 0) {
                    log.info("len={},buf={}", len, new String(buf));
                }
            } catch (Exception e) {
                log.error("e=", e);
            }
        }
    }

2.4 数据字节流

  1. 数据字节流概述：DataInputStream 和 DataOutputStream 是数据字节流，分别继承自 FilterInputStream 和 FilterOutputStream 和 实现了 DataInput 和 DataOutput。用来装饰其他的字节流。

    • DataInputStream：数据字节输入流，用来装饰其他的输入流，允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用 DataOutputStream (数据字节输出流)写入由 DataInputStream (数据字节输入流)读取的数据。
    • DataOutputStream ：数据字节输出流，用来装饰其他输出流，将 DataOutputStream 和 DataInputStream 输入流配合使用，允许应用程序以与机器无关方式从底层输入流中读写基本 Java 数据类型。

  2. 数据字节流API

    DataInputStream 描述
    read() 读取一个字节并返回读取到的字节，如果读取不到返回-1
    read(byte[] b) 读取输入字节到数据b中，并返回读取到的长度；
    read(byte b[], int off, int len) 读取输入字节到数组b中，最多读取长度为len
    readBoolean() 读取一个输入字节：返回true该字节不为0，返回false该字节为0
    readByte() 读取一个输入字节并返回一个byte值
    readChar() 读取两个字节并返回一个char值
    readShort() 读取两个输入字节并返回一个short值
    readInt() 读取四个输入字节并返回一个int值
    readFloat() 读取四个输入字节并返回一个float值
    readLong() 读取八个输入字节并返回一个long值
    readDouble() 读取八个输入字节并返回一个double值
    readUTF() 读取已经使用UTF-8格式编码的字符串
    DataOutputStream 描述
    wrte(int b) 写入一个字节
    write(byte b[], int off, int len) 写入长度为len的字节数组
    writeBoolean(boolean v)
    writeByte(int v)
    writeShort(int v)
    writeChar(int v)
    writeChars(String s)
    writeInt(int v)
    writeLong(long v)
    writeFloat(float v)
    writeDouble(double v)

  3. 案例代码

    1

2.5 对象字节流

  1. 对象字节流概述：也称序列化和反序列化，前体是类必须实现 Seriaizable；

  2. 对象字节流API

    ObjectInputStream 描述
    readObject()
    ObjectOutputStream 描述
    writeObject(Object o)

2.6 管道字节流

2.7 数组字节流

2.8 文件字符流

  1. 文件字符流概述：读取磁盘中本文文件并转为字符流；FileReader和FileWriter

  2. 文件字符流API

    FileReader 描述
    read() 读取一个字符
    FileWriter 描述
    write()

  3. 案例代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    @Slf4j
    public class Demo06BufferedReaderTest {

        private static final String FILE = "Demo06BufferedReaderTest.txt";
        @Test
        public void testFileReader() throws Exception {
            try (
                FileReader fr = new FileReader(FILE);
            ) {
                log.info("read={}", (char) fr.read());
            } catch (Exception e) {
                log.error("e=", e);
            }
        }
    }

2.9 缓存字符流

  1. 缓存字符流概述：带缓冲区的字符流，是FileReader或FileWriter的处理流，主要作用是新增文本操作相关的API，方便处理文本文件；BufferedReader和BufferedWriter

  2. 缓存字符流API

    BufferedReader 描述
    lines() 将文件中所有的行封装为一个Stream流
    readLine() 读取文件中一行数据（换行符标识），读不到返回null
    BufferedWriter 描述
    newLine() 表示是一个换行符

  3. 案例代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    @Slf4j
    public class Demo06BufferedReaderTest {

        private static final String FILE = "Demo06BufferedReaderTest.txt";

        @Test
        public void testWriter() {
            try (
                    FileWriter fw = new FileWriter(FILE);
                    BufferedWriter bw = new BufferedWriter(fw)
            ) {
                bw.write("写的第一行文本");
                bw.newLine();
                bw.write("写的第二行文本");
                bw.newLine();
            } catch (Exception e) {
                log.error("e=", e);
            }
        }

        @Test
        public void testRead() {
            try (
                    FileReader fr = new FileReader(FILE);
                    BufferedReader br = new BufferedReader(fr)
            ) {
                log.info("第一行={}", br.readLine());
                log.info("第二行={}", br.readLine());
                log.info("第三行={}", br.readLine());
            } catch (Exception e) {
                log.error("e=", e);
            }
        }
    }

2.10 字符转换流

  1. 转换流概述：提供字节流与字符流之间的转换；InputStreamReader :将一个字节的输入流转换为字符的输入流；InputStreamWriter:将一个字符的输出流转换为字节的输出流；

  2. 转换流API：重点是构造方法中可以指定转换的字符集

    InputStreamReader 描述
    InputStreamReader(InputStream i) 封装InputStream为转换流，使用系统默认字符集
    InputStreamReader(InputStream i, Charset c) 封装InputStream为转换流，并指定字符集
    InputStreamWriter 描述
    OutputStreamWriter(OutputStream o, Charset c) 将输出流以指定字符集进行输出

  3. 案例代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    @Slf4j
    public class Demo05StreamReaderTest {

        private final static String FILE = "Demo05StreamReaderTest.txt";
        private final static Charset GBK = Charset.forName("GBK");
        private final static Charset UTF = StandardCharsets.UTF_8;

        /**
         * 使用OutputStreamWriter将一段字符串写入到以GBK编码格式的文件
         */
        @Test
        public void testWriter() {
            try (
                    OutputStream os = new FileOutputStream(FILE);
                    OutputStreamWriter osw = new OutputStreamWriter(os, GBK)
            ) {
                osw.write("English and 中文测试输出");
            } catch (Exception e) {
                log.error("e=", e);
            }
        }

        /**
         * 使用InputStreamReader读取GBK编码文件并用UTF8格式编码 会乱码
         */
        @Test
        public void testReadUtf8() {
            try (
                    InputStream is = new FileInputStream(FILE);
                    InputStreamReader isr = new InputStreamReader(is, UTF);
                    BufferedReader br = new BufferedReader(isr)
            ) {
                String line = br.readLine();
                log.info("读取文件utf格式,结果={}", line);
            } catch (Exception e) {
                log.error("e=", e);
            }
        }

        /**
         * 使用InputStreamReader读取GBK编码文件并用GBK格式编码
         */
        @Test
        public void testReadGbk() {
            try (
                    InputStream is = new FileInputStream(FILE);
                    InputStreamReader isr = new InputStreamReader(is, GBK);
                    BufferedReader br = new BufferedReader(isr)
            ) {
                String line = br.readLine();
                log.info("读取文件gbk格式,结果={}", line);
            } catch (Exception e) {
                log.error("e=", e);
            }
        }
    }

第三章 IO工具包

3.1 commons-io

3.2 HuTool

打赏
  • 版权声明： 本博客所有文章除特别声明外，均采用 Apache License 2.0 许可协议。转载请注明出处！
  • © 2020-2022 xiaoliuxuesheng
  • PV: UV:

老板,来一杯Java

支付宝
微信