投稿
  1. 首页
  2. java

JAVA IO流

code • 2022-5-13 • java • 阅读 16

JAVA IO流,第1张

JAVA I/O流 I/O流概述

I/O流(Input/Output)流，即输入输出流，是Java中实现输入输出的基础，他可以方便地实现数据的输入输出 *** 作。

I/O流可以简单分为三类

  • 字节流和字符流

    根据流 *** 作的数据单位的不同，可以分为字节流和字符流。字节流以字节为单位进行数据的读写，每次读写一个或多个字节数据；字符流以字符为单位进行数据的读写，每次读写一个或者多个字符数据。

    字符流只能够处理纯文本(中文)数据，其他类型数据不行，但是字符流处理文本要比字节流处理文本要方便。

  • 输入流和输出流

    根据流传输方向的不同，又可分为输入流和输出流。其中输入流只能从流中读取数据，而不能向其写入数据；输出流只能向流中写入数据，而不能从中读取数据。

  • 节点流和处理流

    根据流的功能不同，可以分为节点流和处理流。其中节点流也被称为低级流，是指可以从一个特定的I/O设备（如磁盘）读写数据的流，它只能直接连接数据源，进行数据的读写 *** 作；处理流也被称为高级流，它用于对一个已存在的节点流进行连接和封装，通过封装后的流来实现流的读写能力。当使用处理流时，程序不会直接连接到实际的数据源，而是连接在已存在的流之上。

字节流

字节流：I/O流针对字节的输入输出提供的一系列流，分为字节输入流和字节输出流。

  • inputStream：表示字节输入流所有类的超类
  • OutputStream：表示输出流所有类的超类
  • 子类名特点：子类名称都是以其父类名作为子类名的后缀
FileInputStream和FileOutputStream
  • FileInputStream是InputStream的子类，他是 *** 作文件的字节输入流，专门用于读取文件中的数据
  • FileOutputStream是OutputStream的子类，他是 *** 作文件的字节输出流，专门用于写入文件中的数据
  • FileOutputStream向一个已经存在的文件中写入数据，那么该文件中的数据首先会被清空，再写入新的数据
方法声明功能描述
InputStream
read()从输入流中读取默认8字节，返回表示该字节的整数，当没有字节时返回-1
close()关闭此输入流并释放与该流关联的所有系统资源
OutputStream
write()向输出流写入默认1字节
flush()刷新此输出流并强制写出所有缓冲的输出字节
close()关闭此输入出流并释放与该流关联的所有系统资源

读写文件

package top.dty.io;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class FilePutStream01 {
    public static void main(String[] args) throws IOException {
        //创建一个文件字节输入流来读取文件
        FileInputStream fileInputStream = new FileInputStream("test.txt");
        //定义一个int类型的变量b
        int b = 0;
        //通过循环读取文件，当返回值为-1结束循环
        while ((b = fileInputStream.read())!= -1){
            System.out.println(b);
        }
        //I/O占用系统资源，使用完毕后要及时关闭
        //关闭流
        fileInputStream.close();

        //FileOutputStream向一个已经存在的文件中写入数据，那么该文件中的数据首先会被清空，再写入新的数据
        //创建文件输出流对象，并指定输出文件名称
        FileOutputStream fileOutputStream = new FileOutputStream("out.txt");
        //定义一个字符串
        String str = "hello";
        //将字符串转换为字节流数组进行写入
        fileOutputStream.write(str.getBytes(StandardCharsets.UTF_8));
        //关闭流
        fileInputStream.close();

        //append参数默认为false，控制文件写入是否覆盖，不覆盖为true
        FileOutputStream fileOutputStream1 = new FileOutputStream("out.txt",true);
        //定义一个字符串
        String str1 = " word";
        //将字符串转换为字节数组进行写入 *** 作
        fileOutputStream1.write(str1.getBytes(StandardCharsets.UTF_8));
        //I/O遇到异常close()方法将无法执行
        //为了保证I/O流的方法一定执行一般把关闭流放在finally代码块中
        try {
            if(fileOutputStream1 != null)
                fileOutputStream1.close();
        }catch (Exception e){
            e.printStackTrace();
        }


    }
}

文件拷贝

package top.dty.io;

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

public class FilePutStream02 {
    public static void main(String[] args) throws IOException {
        //创建文件输入流对象读取指定目录写的文件
        FileInputStream in = new FileInputStream("C:\Users\段通瑶\Desktop\截图\java.jpg");
        //创建文件输出流对象将读取到的文件内容写入到指定目录的文件中
        FileOutputStream out = new FileOutputStream("C:\Users\段通瑶\Desktop\截图\666.jpg");
        //定义一个int类型的变量 len
        int len = 0;
        //获取拷贝文件前的系统时间
        long beginTime = System.currentTimeMillis();
        //通过循环将读取到的文件字节信息写入到新文件
        while ((len = in.read()) != -1){
            out.write(len);
        }
        //获取拷贝文件花费时间
        long endTime = System.currentTimeMillis();
        //输出拷贝文件的时间
        System.out.println((endTime-beginTime)+"ms");
        //关闭流
        in.close();
        out.close();
    }
}
字节流缓冲区
  • 一个字节地读取，需要频繁地 *** 作文件，这种效率非常低
  • 为了提供传输效率，可以定义一个字节数组作为缓冲区
  • 一次性读取多个字节的数据，将数据先保存在字节数组中，然后将字节数组中的数据一次性写入到新的文件中
package top.dty.io;

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

public class FilePutStream03 {
    public static void main(String[] args) throws IOException {
        //创建文件输入流对象读取指定目录写的文件
        FileInputStream in = new FileInputStream("C:\Users\段通瑶\Desktop\截图\java.jpg");
        //创建文件输出流对象将读取到的文件内容写入到指定目录的文件中
        FileOutputStream out = new FileOutputStream("C:\Users\段通瑶\Desktop\截图\666.jpg");
        //定义一个int类型的变量 len
        int len = 0;
        //定义一个长度为1024的字节数组
        byte[] buff = new byte[1024];
        //获取拷贝文件前的系统时间
        long beginTime = System.currentTimeMillis();
        //通过循环将读取到的文件字节信息写入到新文件
        while ((len = in.read(buff)) != -1){
            out.write(buff,0,len);
        }
        //获取拷贝文件花费时间
        long endTime = System.currentTimeMillis();
        //输出拷贝文件的时间
        System.out.println((endTime-beginTime)+"ms");
        //关闭流
        in.close();
        out.close();
    }
}
字节缓存流（bufferedInputStream和bufferedOutputStream）
  • BufferInputStream:创建一个内部缓冲区数组，当从内读取和跳过字节时，内部缓冲区根据需要从包含的输入流重新填充，一次多个字节
  • BufferOutputStream:缓冲输出流。程序向底层输出流写字节，不必写每一个字节而导致底层系统的调用
  • 这两个流内部都定义了一个大小为8192的字节数组
  • 构造方法：
    BufferInputStream（InputStream in）：字节缓冲输入流
    BufferOutputStream（OutputStream out）:字节缓冲输出流
package top.dty.io;

import java.io.*;

public class FilePutStream04 {
    public static void main(String[] args) throws IOException {
        //这两个流内部都定义了一个大小为8192的字节数组
        //创建用于输入和输出的字节流缓冲流对象
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("C:\Users\段通瑶\Desktop\截图\java.jpg"));
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("C:\Users\段通瑶\Desktop\截图\666.jpg"));
        //定义一个int类型的变量 len
        int len = 0;
        //获取拷贝文件前的系统时间
        long beginTime = System.currentTimeMillis();
        //通过循环将读取到的文件字节信息写入到新文件
        while ((len = bufferedInputStream.read()) != -1){
            bufferedOutputStream.write(len);
        }
        //获取拷贝文件花费时间
        long endTime = System.currentTimeMillis();
        //输出拷贝文件的时间
        System.out.println((endTime-beginTime)+"ms");
        //关闭流
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }
}
字符流

字符流的两个抽象的顶级父类，分别时Reader和Writer

  • Reader是字符输入流，用于从某个设备读取字符
  • Writer是字符输出流，用于向某个目标设备写入字符
  • FileReader和FileWriter用于读写文件
  • BufferedReader和BufferedWriter是具有缓冲功能的流，使用他们可以提高读写效率
FileReader和FileWriter
  • 用FileReader以字符的形式读取文件中的内容
  • 用FileWriter以字符的形式写入内容到文件中
  • 构造FileWrite时append的值默认为false，当为true是写入是不清空原文件

读写文件

package top.dty.io;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class ReaderWriter01 {
    public static void main(String[] args) throws IOException {
        //创建FileReader对象，并指出需要读取的文件
        FileReader fileReader = new FileReader("test.txt");
        //定义一个int类型的变量len，器初始化值为0
        int len = 0;
        //通过循环来判断是否读取到了文件末尾
        while ((len = fileReader.read()) != -1){
            System.out.print((char) len);
        }
        //关闭流
        fileReader.close();

        //创建自读输出流对象，并指定输出文件
        FileWriter fileWriter = new FileWriter("writer.txt");
        //将定义的字符写入文件
        fileWriter.write("你好！\n");
        fileWriter.write("欢迎来到小段的学习之路!");
        //关闭流
        fileWriter.close();

        //append的值默认为false，当为true是写入是不清空原文件
        FileWriter fileWriter1 = new FileWriter("writer.txt", true);
        fileWriter1.write("\n好好学习哦！");
        fileWriter1.close();

    }
}

文件拷贝

package top.dty.io;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class ReaderWriter02 {
    public static void main(String[] args) throws IOException {
        //创建FileReader对象，并指定需要读取的文件
        FileReader fileReader = new FileReader("test.txt");
        //创建FileWriter对象，并指定写入数据的目标文件
        FileWriter fileWriter = new FileWriter("out.txt");
        int len = 0;
        //定义一个长度为1024的数组
        char[] chars = new char[1024];
        //通过循环判断是否读取到文件末尾
        while ((len = fileReader.read(chars)) != -1){
            fileWriter.write(chars,0,len);
        }
        //关闭流
        //一般先创建的后关闭
        fileWriter.close();
        fileReader.close();
    }
}
字符缓存流（BufferedReader和BufferedWriter）

字符缓冲流和字节缓冲流类似，这里不多讲述

package top.dty.io;

import java.io.*;

public class ReaderWriter03 {
    public static void main(String[] args) throws IOException {
        //创建一个字符输入缓冲流对象
        BufferedReader reader = new BufferedReader(new FileReader("test.txt"));
        //创建一个字符输出缓冲流对象
        BufferedWriter writer = new BufferedWriter(new FileWriter("out.txt"));
        String str = null;
        //循环时每次读取一行文本如果不为null(即到文件末尾)，则继续循环
        while ((str = reader.readLine()) != null){
            //通过缓冲流对象写入文件
            writer.write(str);
            //写入一个换行符，该方法会根据不同的 *** 作系统生成相应的换行符
            writer.newLine();
        }
        //关闭流
        writer.close();
        reader.close();
    }
}
转换流

有时字节流和字符流之间需要进行转换，JDK提供了两个类用于实现将字节流转换为字符流，分别是InputStreamReader和OutputStreamWriter

  • InputStreamReader是Reader的子类，它可以将一个字节输入流转换成字符输入流，方便直接读取字符
  • OutputStreamWriter是Write的子类，它可以将一个字节输出流转换成字符输出流，方便直接写入字符
package top.dty.io;

import java.io.*;

public class ReaderWriter04 {
    public static void main(String[] args) throws IOException {
        //1.创建字节输入流对象，获取资源文件
        FileInputStream inputStream = new FileInputStream("writer.txt");
        //将字节输入流对象转换成字符输入流
        InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
        //创建字符输入缓冲流对象
        BufferedReader reader = new BufferedReader(inputStreamReader);
        //2.创建字节输出流对象，获取资源文件
        FileOutputStream outputStream = new FileOutputStream("out.txt");
        //将字节输出流对象转换为字符输出流对象
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream);
        //创建字符输出缓冲流对象
        BufferedWriter writer = new BufferedWriter(outputStreamWriter);
        String line = null;
        while ((line = reader.readLine()) != null){
            writer.write(line);
            writer.newLine();
        }
        writer.close();
        reader.close();
    }
}
File类

File类主要是JAVA为文件这块的 *** 作(如删除、新增等)而设计的相关类

File类常用的构造方法

方法声明功能描述
File（String Pathnam）通过指定饿一个字符串类型的文件路径来创建一个新的File文件
File（String parent,String child）根据指定的一个字符串类的都路径和一个字符串类型的子类路径（包括文件名称）创建一个File对象

File类的常用方法

方法声明功能描述
exists()判断File对象对应的文件或目录是否存在，若存在返回true，反之false
delete()删除对象对应的文件或目录，若成功删除则返回ture，反之false
createNewFile()当File对象对应的文件不存在时，该方法将创建一个新的File对象，若创建成功则返回true，反之false
getName()返回File对象表示的文件或文件夹名称
getPath()返回File对象对应的路径
getAbsolutePath()返回File对象的绝对路径
getParent()返回File对象对应目录的父目录
canRead()判断File对象对应的文件或目录是否可读，若可读则返回true，反之false
canWrite()判断File对象对应的文件或目录是否可写，若可写则返回true，反之false
isFile()判断File对象对应的是否为文件，若是则返回true，反之false
isDirectory()判断File对象对应的是否为目录，若是则返回true，反之false
isAbsolute()判断File对象对应的文件和目录是否为绝对路径
lastModified()返回File对象最后修改的时间
length()返回文件内容的长度
list()列出指定目录的全部内容，只是列出名称
listFiles()返回一个包含File对象所有子文件和子目录的File数组

主要方法的运用

package top.dty.io;

import java.io.File;

public class TestFile01 {
    public static void main(String[] args) {
        File file = new File("666.txt");
        //获取文件名称
        System.out.println(file.getName());
        //获取文件的相对路径
        System.out.println(file.getPath());
        //获取文件的绝对路径
        System.out.println(file.getAbsolutePath());
        //获取文件的父路径
        System.out.println(file.getParent());
        //当返回值是布尔值的时候可以用(?"":"")语句转换
        System.out.println(file.canRead()?"文件可读":"文件不可读");
        System.out.println(file.canWrite()?"文件可写":"文件不可写");
        System.out.println(file.isFile()?"是一个文件":"不是一个文件");
        System.out.println(file.isDirectory()?"是一个目录":"不是一个目录");
        System.out.println(file.isAbsolute()?"是绝对路径":"不是绝对路径");
        //修改文件的最后时间
        System.out.println(file.lastModified());
        //文件的大小
        System.out.println(file.length()+"bytes");
        //删除文件，成功的化返回true
        System.out.println(file.delete());
    }
}

遍历目录下的文件

  • list()方法，该方法用于遍历某个指定目录下的所有文件的名称
  • listFiles()方法，返回一个包含File对象所有子文件和子目录的File数组
package top.dty.io;

import java.io.File;
import java.util.Arrays;

public class TestFile02 {
    public static void main(String[] args) {
        //创建File对象，并指定文件路径
        File file = new File("D:\生活学习");
        //判断是否是目录
        if(file.isDirectory()){
            String[] fileNames = file.list();
            //对指定路径下的文件或目录进行遍历
            Arrays.stream(fileNames).forEach(f -> System.out.println(f));
        }
        System.out.println("============");

        //筛选遍历指定该目录下所有扩展名为".txt"
        File file1 = new File("D:\生活学习");
        if(file.isDirectory()){
            String[] fileNames1 = file.list((dir,name)->name.endsWith(".txt"));
            //对指定路径下的文件或目录进行遍历
            Arrays.stream(fileNames1).forEach(f -> System.out.println(f));
        }
        System.out.println("===========");

        File file2 = new File("D:\生活学习");
        //调用fileDir()方法，遍历目录
        fileDir(file2);
    }
    //遍历目录及其子目录
    public static void fileDir(File file){
        //获得目录下所有文件，并赋给数组
        File[] listFiles = file.listFiles();
        //循环遍历数组
        for (File files : listFiles) {
            //如果遍历的是目录，则递归调用fileDir()方法
            if(files.isDirectory()){
                fileDir(files);
            }
            //输出文件路径
            System.out.println(files);
        }
    }
}

删除文件及目录

  • delete()方法，删除对象对应的文件或目录，若成功删除则返回ture，反之false
  • 删除文件夹内所有文件后，在删除文件夹
  • 删除文件不走回收站，直接删除
package top.dty.io;


import java.io.File;

public class TestFile03 {
    public static void main(String[] args) {
        File file = new File("D:\生活学习\空");
        //调用删除方法
        deleteDir(file);

    }
    public static void deleteDir(File file){
        //获取File对象中所有文件，并将其放在数组中
        File[] listFiles = file.listFiles();
        //循环遍历数组
        for (File listFile : listFiles) {
            //如果是目录文件，则递归调用删除方法
            if(listFile.isDirectory()){
                deleteDir(listFile);
            }
            //如果是文件，则删除
            listFile.delete();
        }
        //删除文件夹内所有文件后，在删除文件夹
        file.delete();
    }
}
RandomAccessFile类
  • RandomAccessFile类，它不属于流类，但具有读写文件数据的功能，可以随机从文件的任何位置开始执行读写数据的 *** 作
  • RandomAccessFile可以将文件以指定的 *** 作权限（如只读，可读可写等）的方式打开
RandomAccessFile的构造器
方法声明功能说明
RandomAccessFile(File file,String mode)使用参数file指定被访问的文件，并使用mode来指定访问模式
RandomAccessFile(String name,String mode)使用参数name指定被访问文件的路径，并使用mode来指定访问模式

参数mode有4个值

mode描述
r以只读方式打开指定文件，如果试图对该RandomAccessFile执行写入方法，都将抛出IOException异常
rw以读、写方式打开指定文件，如果该文件尚不存在，则尝试创建该文件
rws以读、写方式打开指定文件，相对于"rw"模式，还要求对文件的内容或元数据的每个更新都同步写入到底层存储设备
rwd以读、写方式打开指定文件，相对于"rw"模式，还要求对文件内容的每个更新都同步写入到底层存储设备
RandomAccessFile中的常用方法
方法声明功能说明
getFilePointer()返回当前读写指针所在的位置
seek()设定读写指针的位置，与文件开头相隔pos个字节数
skipBytes()使读写指针从当前位置开始，跳过n个字节
write()将指定的字节数组写入到这个文件，并从当前文件指针开始
setLength()设置此文件的长度
readLine()从指定文件当前指针读取下一行内容
package top.dty.io;

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.charset.StandardCharsets;

public class TestRandomAccessFile {
    public static void main(String[] args) throws IOException {
        //创建RandomAccessFIle对象，并以读写模式打开文件
        RandomAccessFile randomAccessFile = new RandomAccessFile("out.txt", "rw");
        //读取还可以使用次数
        int times = Integer.parseInt(randomAccessFile.readLine())-1;
        //判断剩余次数
        if(times > 0){
            //每执行一次代表使用一次，次数就减少一次
            System.out.println("你还可以使用"+times+"次");
            //将记录指针重新指向文件开头
            randomAccessFile.seek(0);
            //将剩余次数再次写入文件
            randomAccessFile.write((times+"").getBytes(StandardCharsets.UTF_8));
        }else {
            System.out.println("使用次数已使用完");
        }
        //关闭这个随机读取文件流并释放任何系统
        randomAccessFile.close();
    }
}
NIO
  • NIO是为了替代传统标准的I/O而出现的。与标准的I/O相比，NIO提供了一种与I/O不同的工作方式。
  • NIO采用内存映射文件的方式来处理输入输出，他将文件或文件的一段区域映射到内存中，这样就可以像访问内存一样来访问文件
  • 在标准的I/O中，使用的是字节流和字符流；而在NIO中，使用的是buffer（缓冲器）和Channel（通道）
  • 数据总是从Channel（通道）读入Buffer（缓冲器），或从Buffer（缓冲器）区写入Channel（通道）

NIO主要有三大核心部分: Buffer、Channel和Selector

  • 其中Buffer 可以被看成是一个容器,其本质是一个数组缓冲区，读人或写出到Channel中的所有对象都会先放在Buffer中
  • Channel是对传统的输人输出的模拟，在NIO中，所有的数据都需要通过通道流的形式传输
  • Selector(选择器)用于监听多个通道的事件(例如:连接打开、数据到达等),主要用于多线程处理
Buffer（缓冲器）
  • 从结构上来说，Buffer类似一个数组，它可以保存多个类型相同的数据。
  • 从类型上来说，Buffer是一个抽象类，子类中最常用的是ByteBuffer和CharBuffer
  • Buffer类的在子类中并没有提供构造方法，因此不能通过构造方法来创建对象
  • 要想创建Buffer对象，通常会通过子类中的static XxxBuffer allocate（int capacity）方法来实现
Buffer中的三个重要概念
  • capacity(容量):缓冲区的容量表示该Bufler的最大数据容量，即最多可以存储多少数据。缓冲区的容量值不能为负数，也不能够改变。
  • limit(界限):表示Buffer容器中不可被读取的区域的第一 个索引,即位于Buffer容器中索引为0到limit之间的区域都可以进行读取 *** 作。缓冲区的limit 值从不为负，也从不大于其容量。
  • position(位置):用于指定下一个可以被读写的缓冲区位置索引。新创建的Buffer对象,position的默认值为0,每进行一次读取或写人 *** 作，position的值都会自动向后移动一步。如果向Buffer缓冲区中执行8次写人 *** 作，那么position的值为8,即指向Buffer中的第九个元素的索引位置
Buffer类的常用方法
方法声明功能设置
capacity()获取缓冲区的大小
limit()获取Buffer的limit的位置
position()获取Buffer中的position的值
flip()反转缓冲区，先将limit设置为当前position位置，然后再将position设置为0
put()将某位置放入元素
get()获取buffer中的某位置的元素
clear()清楚缓冲去，将position设置为0，limit设置为capacity
hasRemaining()判断当前位置（position)和界限(limit)之间是否有元素
remaining()获取当前位置和界限之间的元素个数
package top.dty.io;

import java.nio.CharBuffer;

public class NIOBuffer {
    public static void main(String[] args) {
        //创建CharBuffer对象，并指定缓冲区容量大小为6
        CharBuffer charBuffer = CharBuffer.allocate(6);
        System.out.println(charBuffer.capacity());//容量
        System.out.println(charBuffer.limit());//界限值
        System.out.println(charBuffer.position());//初始位置
        //向CharBuffer对象放入3个元素
        charBuffer.put('d');
        charBuffer.put('t');
        charBuffer.put('y');
        System.out.print(charBuffer.limit());
        System.out.println(charBuffer.position());
        //执行flip()方法
        //反转缓冲区，先将limit设置为当前position位置，然后再将position设置为0
        charBuffer.flip();
        System.out.print(charBuffer.limit());
        System.out.println(charBuffer.position());
        //取出第一个元素
        System.out.println(charBuffer.get());
        System.out.print(charBuffer.limit());
        System.out.println(charBuffer.position());
        //执行clear()方法
        //清楚缓冲去，将position设置为0，limit设置为capacity
        charBuffer.clear();
        System.out.print(charBuffer.limit());
        System.out.println(charBuffer.position());
        //取出第一个元素
        System.out.println(charBuffer.get(0));
        System.out.print(charBuffer.limit());
        System.out.println(charBuffer.position());
        //判断当前位置（position)和界限(limit)之间是否有元素
        System.out.println(charBuffer.hasRemaining());
        //获取当前位置和界限之间的元素个数
        System.out.println(charBuffer.remaining());
//        //标记？
//        System.out.println(charBuffer.mark());
//        System.out.println(charBuffer.reset());
//        System.out.println(charBuffer.rewind());
    }
}
Channel（通道）（简单）

Channel是一个接口对象，他类似与传统的流对象，但与传统的流对象有些不同

  • Channel可以异步地执行I/O读写 *** 作
  • Channel的读写 *** 作时双向的，既可以从Channel中读取数据，又可以写数据到Channel，而流的读写 *** 作通常都是单向的
  • Channel可以直接将文件的部分或者全部直接映射成Buffer
  • Channel只能与BUffer进行交互，程序不能直接读写Channel中的数据
  • FileChannel类可以实现常用的读写 *** 作

FileChannel类的常用方法

方法声明功能描述
position()返回该通道的文件位置
read()从该通道读取字节到给定的缓冲取
size()返回该通道文件的当前大小
transferTo()读取该通道文件中给定位置的字节数，并将它们写入目标通道
write()从给定的缓冲区写入这个通道的字节序列
package top.dty.io;

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;

public class NIOChannel {
    public static void main(String[] args) throws IOException {
        //创建 RandomAccessFile对象，指定源文件
        RandomAccessFile inFile = new RandomAccessFile("C:\Users\段通瑶\Desktop\Zombatar_1.jpg","rw");
        //获取读取资源文件FileChannel通道
        FileChannel inFileChannel = inFile.getChannel();
        ///创建 RandomAccessFile对象，指定目标文件
        RandomAccessFile outFile = new RandomAccessFile("C:\Users\段通瑶\Desktop\666.jpg", "rw");
        //获取复制目标文件FileChannel通道
        FileChannel outFileChannel = outFile.getChannel();
        //使用transferTo()方法进行整体复制
        long transferTo = inFileChannel.transferTo(0, inFileChannel.size(), outFileChannel);
        if(transferTo>0){
            System.out.println("复制成功");
        }
        inFile.close();
        inFileChannel.close();
        outFile.close();
        outFileChannel.close();
    }
}
NIO.2

改进后的NIO被称为NIO2

Path接口
  • Path接口是一个用在文件系统中定位文件的对象，通常表示一个依赖于系统的文件路径
  • Path类提供了两个返回Path的静态方法，通过这两个方法可以创建Path对象

Path接口的常用方法

方法声明功能描述
endWith()判断当前路径是否以指定的字符串结尾
getName()返回此路径的名称元素作为路径对象
getNameCount()返回路径中名称元素的数量
getParent()返回父路径，如果此路径没有父路径，则返回null
getRoot()返回该路径的根组件作为路径对象，如果此路径没有跟组件，则返回null
toAbsolutePath()返回表示此路径的绝对路径的路径对象
toUri()返回表示此路径的URI地址
package top.dty.io;

import java.nio.file.Path;
import java.nio.file.Paths;

public class TestPath {
    public static void main(String[] args) {
        //使用Path的get()方法创建Path对象
        Path path = Paths.get("D:\生活学习\txt.txt");
        //Path的根路径
        System.out.println(path.getRoot());
        //Path的父路径
        System.out.println(path.getParent());
        //Path中的路径名称个数
        System.out.println(path.getNameCount());
        //获取指定索引处的路径名称
        for (int i = 0; i < path.getNameCount(); i++) {
            Path name = path.getName(i);
            System.out.println(i+"  "+name);
        }
        //Path的URI的路径
        System.out.println(path.toUri());
        //Path的绝对路径
        System.out.println(path.toAbsolutePath());
    }
}
Files工具类

Files类中提供了大量的静态方法来 *** 作文件

Files工具类的常用方法

方法声明功能描述
createFile()创建一个新的空文件，如果文件已经存在，则创建失败
copy()该方法将一个文件复制到目标文件，并使用选项参数 指定如何执行复制
readAllLines()从文件中读取所有行
size()返回文件的大小（以字节为单位）
write()将文本写入文件，并传入指定的写入模式
package top.dty.io;

import java.io.*;
import java.nio.file.*;
import java.util.*;

public class TestFiles {
    public static void main(String[] args) throws IOException {
        //定义一个目录路径的Path对象
        Path path = Paths.get("D:\生活学习\空");
        //根据Path对象创建多级目录
        Files.createDirectories(path);
        System.out.println("目录创建成功");
        //定义一个文件路径的Path对象
        Path path1 = Paths.get("D:\生活学习\空\tt.txt");
        //根据Path对象创建一个文件
        Files.createFile(path1);
        //创建一个List集合，并向集合中添加内容
        ArrayList<String> list = new ArrayList<>();
        list.add("这是一个测试文件");
        //将集合中的内容追加写到指定的文件中
        Files.write(path1,list, StandardOpenOption.APPEND);
        List<String> list1 = Files.readAllLines(path1);
        System.out.println(Files.size(path1));
        System.out.println(list1);
    }
}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/877173.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-05-13
下一篇 2022-05-13

发表评论

登录后才能评论

评论列表（0条）

保存