Java的IO和NIO

最新推荐文章于 2023-09-05 09:52:43 发布
最新推荐文章于 2023-09-05 09:52:43 发布
阅读量181 收藏
点赞数
分类专栏： Java学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zlase/article/details/109536168
版权

参考视频：https://www.bilibili.com/video/BV1Tz4y1X7H7?p=12

参考文档：https://www.cnblogs.com/coderzjz/p/13670088.html

 

目录

Java 的IO操作

IO的字节流：

文件输入输出流：

过滤输入输出流（可以代替FileInputStream和FileOutputStream）：

对象输入输出流： 针对对象的读和写（序列化和反序列化）

IO的字符流：

文件输入输出流：

字符缓冲流（是字符流的升级版，可以将数据部分放到缓冲区提高效率）：

IO的转换流：

IO对文件进行操作File：

常用的File指令

遍历所有文件夹

删除文件夹下的所有文件

 

 

Java 的IO操作

java中的IO是input和output的缩写，是java中的传统的输入输出，下边有常见的用法。

 

流的分类：

按照数据流向区分流：

        IO stream是 内存和存储设备（硬盘）之间的传输通道。

                Input stream 输入流，将硬盘中的数据，读入到内存中。

                Output stream 输出流，将内存中的数据，放到硬盘中。

按存储单位区分流：

        字节流：以字节为单位，可以读写所有数据。

        字符流：以字符为单位，只能读写文本数据。

按照功能区分流：

        节点流：具有实际传输数据的读写功能。

        过滤流：在节点流的基础之上增强功能。

 

 

IO的字节流：

InputStream 是抽象类，需要具体子类来实现（节点流）：

AudioInputStream ， ByteArrayInputStream ， FileInputStream ， FilterInputStream ， InputStream ， ObjectInputStream ， PipedInputStream ， SequenceInputStream ， StringBufferInputStream

OutputStream 是抽象类，需要具体的子类实现

ByteArrayOutputStream ， FileOutputStream ， FilterOutputStream ， ObjectOutputStream ， OutputStream ， PipedOutputStream

 

文件输入输出流：

FileInputStream   read()函数，表示读取下一个字节   close()关闭输入流

FileOutputStream  write()函数，从内存往硬盘写入下一个字节  close()关闭输出流

package io_nio.io;

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

public class FileInputOutputStream {

    public static void main(String[] args) throws IOException {
        FileInputOutputStream test = new FileInputOutputStream();

        test.readByteOneByOne();
        test.readAsArray();

        test.writeAsArray();

        test.copyPictures();
    }

    // 一次读取一个字节
    private void readByteOneByOne() throws IOException {
        // 创建输入流，建立
        FileInputStream inputStream = new FileInputStream("D:\\WorkCode\\LeetCodeDemo\\ioinputTemp.txt");

        // 一个字节一个字节读入，会转成ASCII编码，然后强转成int型进行输出
        // 如果希望用字符输出，可以强转成char即可（不支持中文）
        int data = 0;
        while ((data = inputStream.read()) != -1) {
            System.out.print((char) data);
        }

        // 关闭流
        inputStream.close();
    }

    // 按照数组的大小读取
    private void readAsArray() throws IOException {
        FileInputStream inputStream = new FileInputStream("D:\\WorkCode\\LeetCodeDemo\\ioinputTemp.txt");

        // 用数组的形式，三个值进行一次读取，返回值是读取了多少字符
        // 通常情况下都直接定义1024个字节的数组进行读取
        byte[] buf = new byte[3];
        int count = 0;  //读取了多少个字符
        while ((count = inputStream.read(buf)) != -1) {
            System.out.print(new String(buf));
        }

        // 关闭流
        inputStream.close();
    }

    // 写入数据  单个写入和按照byte[]写入
    private void writeAsArray() throws IOException {
        // 定义输出流，append表示是否继续写入，true表示持续写入，false和不写表示覆盖写入
        FileOutputStream outputStream = new FileOutputStream("D:\\WorkCode\\LeetCodeDemo\\iooutputTemp.txt", true);

        // 写入数据
        // 输入的是ASCII码(或者char转换成ASCII码)，写入硬盘的时候，会自动转成char
        outputStream.write(97);
        outputStream.write('b');

        // 写入数据，可以按照byte数组往里写入
        String string = "Hello world!";
        byte[] chars = string.getBytes();
        outputStream.write(chars);

        outputStream.close();
    }

    private void copyPictures() throws IOException {
        FileInputStream fileInputStream = new FileInputStream("D:\\WorkCode\\LeetCodeDemo\\van.jpg");
        // 正常需要判断文件是否存在，如果存在了，就不能再追加写了
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\WorkCode\\LeetCodeDemo\\van_copy.jpg", true);

        byte[] bytes = new byte[512];
        int count = 0;
        while ((count = fileInputStream.read(bytes)) != -1) {   // 读取
            fileOutputStream.write(bytes, 0, count);        // 写出
        }

        fileInputStream.close();
        fileOutputStream.close();
    }
}

 

过滤输入输出流（可以代替FileInputStream和FileOutputStream）：

FilterInputStream/FilterOutputStream 实例化了InputStream和OutputStream，并且覆盖了几乎所有的方法，其子类BufferedInputStream和BufferedOutputStream则是面向缓冲区的输入输出流。

相比于FileInputStream和FileOutputStream，这种方式将大量数据进行读入，并在缓存里进行操作，效率提高了。

package io_nio.io;

import com.sun.xml.internal.ws.policy.privateutil.PolicyUtils;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.Buffer;

/**
 * 使用字节缓冲流，再输入输出的时候不一段一段读取，而是将大量数据写入缓存，在缓存中进行读取
 * <p>
 * 提高IO效率，减少访问磁盘次数
 * 数据存储在缓冲区中，flush是将缓冲区的内容写入文件中，也可以直接close
 */
public class BufferInputOutput {
    public static void main(String[] args) throws IOException {
        BufferInputOutput bufferInputOutput = new BufferInputOutput();
        bufferInputOutput.bufferedInput();
        bufferInputOutput.bufferedOutPut();
    }


    // BufferedInputStream 读取文件
    // 使用这种文件读取的方式，相比于直接使用FileInputStream，读取的速度更快（文件已经被默认被存入缓冲区了）
    // 之前使用char[]读取FileInputStream也相当于设定了一个缓冲区
    // 关闭的时候只关闭bufferedInputStream即可
    private void bufferedInput() throws IOException {
        // 需要先传入一个底层节点流，在使用Buffered接住节点流
        FileInputStream fileInputStream = new FileInputStream("D:\\WorkCode\\LeetCodeDemo\\ioinputTemp.txt");
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);

        int count = 0;
        byte[] buf = new byte[512];
        while ((count = bufferedInputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, count)); //只将读取部分的数组初始化
        }

        // 关闭流数据
        bufferedInputStream.close();
    }

    // 文件写入流，写入到指定的文件中
    private void bufferedOutPut() throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\WorkCode\\LeetCodeDemo\\iooutputTemp.txt", true);
        BufferedOutputStream bufferedInputStream = new BufferedOutputStream(fileOutputStream);

        String string = "hello world";
        for (int i = 0; i < 10; i++) {
            bufferedInputStream.write(string.getBytes());  //在BufferedOutputStream的默认缓冲区里，如果没有超过8k是不会写入的
        }

        bufferedInputStream.flush(); // 刷新一次，将数据从内存写入硬盘
        bufferedInputStream.close();
    }

}

 

对象输入输出流： 针对对象的读和写（序列化和反序列化）

这种依然是在缓冲区进行的操作，不过可以针对对象完成操作。即完成序列化和反序列化！

序列化和反序列化需要注意的事项:
1. 必须要实现Serializable接口
2. 序列化的类里包含的类属性也必须要实现Serialize接口
3. 序列化和反序列化必须保证是一个类,通常会使用serialVersionUID这个静态Strng字段完成校验
4. 使用transient来修饰序列化时候不序列化的属性(防止敏感信息泄露)
5. 静态的属性不能被序列化

package ioNio;

import java.io.*;

/**
 * 针对对象的读入和写出  其实就是序列化和反序列化
 * 序列：java的字节或者字符组成的一串字符
 * 序列化：将Java的对象转换成一串文字，由内存转移到硬盘中进行存储
 * 反序列化：将一串文字转换成Java的对象，由硬盘转移到内存中
 * 注意：序列化和反序列化的类一定要实现Serializable这个接口
 */
public class ObjectInputOutputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputOutputStream objectInputOutputStream = new ObjectInputOutputStream();
        objectInputOutputStream.objectOutputStream();
        objectInputOutputStream.objectInputStream();

    }

    // 把硬盘中的数据反序列化成对象
    private void objectInputStream() throws IOException, ClassNotFoundException {
        FileInputStream fileInputStream = new FileInputStream("F:\\Codes\\LeetCode\\src\\tempfile\\objectFile.txt");
        ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);

        // 读取文件，反序列化
        Student peter = (Student) objectInputStream.readObject();

        objectInputStream.close();
        System.out.println("Deserialization success!");
        System.out.println(peter.toString());
    }

    // 把一个对象序列化到硬盘
    private void objectOutputStream() throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("F:\\Codes\\LeetCode\\src\\tempfile\\objectFile.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fileOutputStream);

        Student peter = new Student("peter", 30);
        oos.writeObject(peter);

        oos.close();
        System.out.println("Serialization success!");

    }
}

/**
 * 如果想要序列化，就必须要实现Serializable这个接口，其内部没有任何方法，只需要实现即可满足序列化和反序列化
 */
class Student implements Serializable {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return this.name + " : " + age;
    }
}

 

IO的字符流：

Reader：是抽象类，需要具体子类来实现（字符流父类）：

        BufferedReader ， CharArrayReader ， FilterReader ， InputStreamReader ， PipedReader ， StringReader

Writer：是抽象类，需要具体的子类实现

        BufferedWriter ， CharArrayWriter ， FilterWriter ， OutputStreamWriter ， PipedWriter ， PrintWriter ， StringWriter

这种读入的方式，是每一个字节进行读和写，虽然可以对所有的文件进行读写，但是如果使用了中文汉字，一个字占用了3个字节，基本就会出现乱码，这种情况就需要使用字符流 ，按照编码格式，一个字符一个字符进行读取。

 

文件输入输出流：

FileReader  是InputStreamReader的子类型，实际使用的类   read()函数，表示读取下一个字节   close()关闭输入流

FileWriter  是OutputStreamWriter的子类型，实际使用的类  write()函数，从内存往硬盘写入下一个字节  close()关闭输出流

用法和FileInputStream/FileOutputStream差不多，不过是以一个字符为单位进行的读写，而不是以一个字节为单位进行读写。

只能用于文本文件，绝对不能针对图片或其他文件进行读写。

package ioNio.io;

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

public class FileReaderAndWrite {

    public static void main(String[] args) throws IOException {
        FileReaderAndWrite fileReaderAndWrite = new FileReaderAndWrite();
        fileReaderAndWrite.readFile();
        fileReaderAndWrite.writeFile();
    }

    private void readFile() throws IOException {
        FileReader fileReader = new FileReader("F:\\Codes\\LeetCode\\src\\tempfile\\readFile.txt");

        int count;
        char[] buf = new char[1024];
        while ((count = fileReader.read(buf)) != -1) {
            System.out.print(new String(buf, 0, count));
        }

        fileReader.close();
    }

    private void writeFile() throws IOException {
        FileWriter fileWriter = new FileWriter("F:\\Codes\\LeetCode\\src\\tempfile\\writeFile.txt", true);

        String string = "写入" + File.separator + "123";
        fileWriter.write(string);

        fileWriter.close();
    }
}

 

字符缓冲流（是字符流的升级版，可以将数据部分放到缓冲区提高效率）：

BufferedReader  是Reader的子类型，实际使用的类   read()函数，表示读取下一个字节   close()关闭输入流

BufferedWriter    是Writer的子类型，实际使用的类  write()函数，从内存往硬盘写入下一个字节  close()关闭输出流

用法和BufferedInputStream/BufferedOutputStream差不多，不过是以一个字符为单位进行的读写，而不是以一个字节为单位进行读写。BufferedReader可以进行按行读取，推荐使用这种读取方式。

package ioNio.io;

import java.io.*;

public class BufferedReaderAndWriter {

    public static void main(String[] args) throws IOException {
        BufferedReaderAndWriter bufferedReaderAndWriter = new BufferedReaderAndWriter();
        bufferedReaderAndWriter.bufferedReadWord();
        bufferedReaderAndWriter.bufferedReadLine();
        bufferedReaderAndWriter.bufferedWriteWorld();
    }

    private void bufferedReadWord() throws IOException {
        FileReader fileReader = new FileReader("F:\\Codes\\LeetCode\\src\\tempfile\\readFile.txt");
        BufferedReader bufferedReader = new BufferedReader(fileReader);

        int count;
        char[] chars = new char[1024];
        while ((count = bufferedReader.read(chars)) != -1) {
            System.out.print(new String(chars, 0, count));
        }

        bufferedReader.close();
    }

    /**
     * BufferedRead 可以支持按照行读取
     * 体现了缓冲区用法
     */
    private void bufferedReadLine() throws IOException {
        FileReader fileReader = new FileReader("F:\\Codes\\LeetCode\\src\\tempfile\\readFile.txt");
        BufferedReader bufferedReader = new BufferedReader(fileReader);

        String line;
        while ((line = bufferedReader.readLine()) != null) {
            System.out.print(line);
        }

        bufferedReader.close();
    }

    private void bufferedWriteWorld() throws IOException {
        FileWriter fileWriter = new FileWriter("F:\\Codes\\LeetCode\\src\\tempfile\\writeFile.txt");
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);

        for (int i = 0; i < 10; i++) {
            bufferedWriter.write("好好学习");
            bufferedWriter.newLine();   // 根据系统，写入一个换行符
        }

        bufferedWriter.flush();
        bufferedWriter.close();
    }
}

 

IO的转换流：

        有两个特殊的类,可以完成字节流和字符流之间的转换:
    InputStreamReader：将硬盘中的数据读入，根据规定的格式，如UTF-8，GBK等，将字节转换成字符
    OutputStreamWriter：将内存中的数据结构，由指定的格式，写入成字符，存储到硬盘中

package ioNio.io;

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

public class InputStreamReaderTest {
    public static void main(String[] args) throws IOException {
        InputStreamReaderTest inputStreamReader = new InputStreamReaderTest();
        inputStreamReader.inputStreamReader();
        inputStreamReader.outputStreamReader();
    }

    // 将字节流转换为字符流 并解析（可以选择）
    private void inputStreamReader() throws IOException {
        FileInputStream fileInputStream = new FileInputStream("F:\\Codes\\LeetCode\\src\\tempfile\\readFile.txt");
        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"UTF-8");

        int data = 0;
        while ((data = inputStreamReader.read()) != -1) {
            System.out.print((char) data);
        }

        inputStreamReader.close();
    }

    private void outputStreamReader() throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("F:\\Codes\\LeetCode\\src\\tempfile\\writeFile.txt",true);
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream,"UTF-8");

        String string = "new File 张三";
        outputStreamWriter.write(string);

        outputStreamWriter.flush();
        outputStreamWriter.close();
    }
}

 

IO对文件进行操作File：

        File类是针对文件和文件夹定制的类，其使用方式比较简单，查询一下JDK API即可。

 

常用的File指令

        其中有一个特别的接口：FileFilter，它可以过滤

        File中的常用方法如下：

package ioNio.io;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;

public class FileTest {
    public static void main(String[] args) {

    }

    // File的常用路径
    public void separator(){
        System.out.println("路径分割符：" + File.pathSeparator );
        System.out.println("名称分隔符：" + File.separator);
    }

    // 创建一个File 删除一个file
    private void createFile() throws IOException {
        File file = new File("F:\\Codes\\LeetCode\\src\\tempfile\\createFile.txt");
        if(!file.exists()){
            boolean createResult = file.createNewFile();
        }
        if(file.exists()){   // 直接删除
           boolean deleteResult = file.delete();
        }
        if(file.exists()){   // 先不删除，等java执行完成之后，虚拟机停止之前删除掉
            file.deleteOnExit();
        }
    }

    /**
     * 获取单层文件夹路径下的所有文件，通过实现类FileFilter进行一次过滤
     * 如果accept返回的是true，则将文件放入数组中，否则不会放入数组中
     *
     * 如果需要深层文件，则需要递归过滤
     */
    private void filterFile(){
        File file = new File("D:\\abc");
        File[] files2 = file.listFiles(new FileFilter(){
            @Override
            public boolean accept(File pathname){
                if(pathname.getName().endsWith(".jpg")){
                    return true;
                }
                return false;
            }
        });
        for(File fileTemp : files2){
            System.out.println(fileTemp.getName());
        }
    }
}

 

遍历所有文件夹

        递归遍历文件夹

    // 找到文件夹dir下的所有文件
    private void findallfile(File dir) {
        File[] files = dir.listFiles();
        if (files != null && files.length > 0) {
            for (File fileTemp : files) {
                if (fileTemp.isDirectory()) {
                    findallfile(fileTemp); // 递归
                } else {
                    System.out.println(fileTemp.getAbsolutePath());
                }
            }
        }
    }

 

删除文件夹下的所有文件

    // 递归删除dir路径下的所有文件
    public static void deleteDir(File dir) {
        File[] files = dir.listFiles();
        if (files != null && files.length > 0) {
            for (File file : files) {
                if (file.isDirectory()) {
                    deleteDir(file); // 递归
                } else {
                    // 删除文件
                    System.out.println(file.getAbsolutePath() + "删除" + file.delete());
                }
            }
        }
    }

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Zlase
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java NIO与IO
u011997561的博客
06-26 334
java NIO由以下几个核心部分组成: Channels(通道) Buffers(缓冲区) Selectors(选择器) 其他 Channel和Buffer: 所有的IO再NIO中都从一个Channel开始.Channel有点像流,数据可以从Channel读到Buffer中,也可以从Buffer写到Channel中: Channel的主要实现如下: FileChannel D.........
java之IO/NIO
qq_26737667的博客
11-06 136
阻塞IO模型 最传统的一种IO模型，即在读写数据过程中会发生阻塞现象。当用户线程发出IO请求之后，内核会去查看数据是否就绪，如果没有就绪就会等待数据就绪，而用户线程就会处于阻塞状态，用户线程交出CPU。当数据就绪之后，内核会将数据拷贝到用户线程，并返回结果给用户线程，用户线程才解除block状态。典型的阻塞IO模型的例子为：data = socket.read();如果数据没有就绪，就会一直阻塞...
Java 中的 IO 和 NIO
Gjw_java的博客
09-05 1411
java io 和 nio 的简单总结
java之NIO入门学习介绍及NIO网络编程Demo
qq_42401622的博客
05-11 298
从Java1.4开始就有了NIO，随着程序对性能的要求越来越高，NIO得到了广泛使用。 IO NIO 面向流 面向缓冲区 阻塞 非阻塞 / 有选择器
Java NIO 简单例子
我爱大海V5的专栏
12-10 4328
服务器端： package nioT; import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.n
java nio demo_【Netty整理03-NIO】Java 实现 NIO demo
weixin_34489089的博客
02-13 218
jdk提供的NIO使用：博主抄写了网上的demo，略作修改与调整,原文链接：Demo01：抄写地址忘记了。。。1、服务端代码：package com.test3;import java.io.IOException;import java.net.InetSocketAddress;import java.nio.channels.SelectionKey;import java.nio.chan...
Java（IO-字节流/字符流，缓冲流，NIO介绍）
taka_is_beauty的博客
07-22 807
目录 一.IO流的分类 二.字节流/字符流 三.缓冲流 四.NIO 一.IO流的分类 IO流： * 根据流的流向分类: * Input:输入流 * Output:输出流 * 根据流操作的数据来分类 * 字符流: 操作字符 * 只能操作普通文本文件, * ...
JavaIO和NIO练习
08-16
在"JavaIODemo"这个练习中，我们可能会看到以下内容： 1. 流的创建与使用：演示如何创建输入流和输出流对象，例如从文件读取数据并写入到另一个文件。 2. 缓冲技术：使用BufferedReader和BufferedWriter实现高效的...
JAVA IO-NIO 详解
最新发布
04-24
其中，NIO（New IO）是Java 1.4版本引入的一种新的IO处理方式，相较于传统的阻塞IO，NIO提供了更高的效率和灵活性。 #### 二、传统IO与NIO的区别 **1. 阻塞与非阻塞** - **传统IO**: 阻塞式操作，当进行读写操作...
Java IO_NIO
11-23
Java IO（Input/Output）是Java编程语言中用于处理输入输出操作的基础框架，它提供了丰富的类库，使得程序能够与各种设备、文件、...理解和掌握Java IO与NIO的使用，对于提升Java应用程序的性能和可扩展性至关重要。
JAVA IO and NIO
12-25
Java IO (Input/Output) 和 NIO (Non-blocking Input/Output) 是Java平台中用于处理输入和输出操作的重要部分。这两种技术在实现客户端与服务器之间的通信时起着至关重要的作用。下面将详细介绍Java IO和NIO的特点、...
java基础：IO、NIO
王温暖的博客
03-29 1146
Java NIO、IO https://lrh1993.gitbooks.io/android_interview_guide/content/java/basis/java-nio.html 轻松理解java中的IO与NIO https://zhuanlan.zhihu.com/p/27204492 BIO，AIO，NIO理解： https://baijiahao.baidu.com/s?id=1666632547627347318&wfr=spider&for=pc..
java中的NIO和IO
软件界的鼬神
04-08 513
今天看到一篇文章，其中提到了NIO，之前没使用过，今天拿出来学习下，做个个人分享。 IO指的是流式处理，I对用的是Input，O对应的是OutPut,也就是我们常用的IO。IO流的数据来源可以是键盘，文件，网络等等，下面是其类图的划分，具体这些类和api该怎么使用就不说了。 这里有个注意点：字节流和字符流是两个不同的概念。图为输出的示意，出入与之相反。 从源码上看（这里只列出InputStreamReader） 字节流其实也是字节的...
java中io以及nio的基本案例
有梦想的咸鱼的博客
03-23 689
1、java中io和nio的区别个人理解，主要在于io是面向流，而nio是面向缓冲区的，io（bio）同步阻塞式的输入输出，而nio是同步非阻塞式的输出输出。2、io复制文件代码import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.Inp...
Java IO 和 NIO的区别
riskLoveHe的博客
08-25 8535
主要区别 IO NIO 面向字节流 面向缓冲区 阻塞 基于Selector的非阻塞 Java IO 和 NIO的主要区别体现在以上两个方面，以下详细说明这些区别的具体含义。面向流和面向缓冲区这个概念和编程方法中的面向过程、面向对象类似。Java IO 是面向流的而Java NIO是面向缓冲区的。在Java IO中读取数据和写入数据是面向流（Stream）的,这表示当我们从流中读
Java IO和NIO
feather(猎羽)
09-12 1万+
转载请注明链接： Java提供了哪些IO方式？ NIO如何实现多路复用？ Java IO和NIO 版本号：2018/9/12-1(18:24) Java IO和NIO 基本概念 同步和异步 阻塞和非阻塞 IO/BIO NIO NIO2 问题汇总 参考资料 基本概念 1、Java IO方式有哪些? 传统java.io包：文件...
Java NIO 与 IO之间的区别
热门推荐
evan_man的专栏
03-17 2万+
本文将NIO与IO进行了对比；介绍了NIO的一般使用方式
Java的Log架构（Log4j2 + Slf4j）
Zlase的博客
12-03 1374
目录 常见的日志门面 常见的日志实现 日志框架介绍 JUL Log4j LogBack Log4j2 SLF4J的使用 简介 slf4j-api 和 slf4j-simple 使用 Log4j2的使用 简介 Demo 异步日志（效率提升的原因） 使用Log4j2和slf4j的日志架构 包引入 Domo实现 Log4j2的配置文件 Log4j2配置异步日志 Log4j2无垃圾机制 常见的日志门面 JCL，slf4j(Simple Logging For java)
java io 和nio_java对比IO和NIO的文件读写性能测试
05-31
Java IO 和 NIO 都可以用于文件读写操作，但是它们的实现方式不同，因此在性能上也略有差异。 针对文件读写操作，我们可以通过编写测试程序来对比 Java IO 和 NIO 的性能。下面是一个简单的测试程序： ```java import java.io.FileInputStream; import java.io.FileOutputStream; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; public class FileReadWriteTest { private static final int BUFFER_SIZE = 1024 * 1024; public static void main(String[] args) throws Exception { String file = "test.txt"; int size = 1024 * 1024 * 100; // 测试 Java IO 的文件写入性能 long start = System.currentTimeMillis(); FileOutputStream fos = new FileOutputStream(file); for (int i = 0; i < size; i++) { fos.write('a'); } fos.close(); long end = System.currentTimeMillis(); System.out.println("Java IO 文件写入耗时：" + (end - start) + "ms"); // 测试 Java IO 的文件读取性能 start = System.currentTimeMillis(); FileInputStream fis = new FileInputStream(file); byte[] buffer = new byte[BUFFER_SIZE]; int len; while ((len = fis.read(buffer)) != -1) { // do nothing } fis.close(); end = System.currentTimeMillis(); System.out.println("Java IO 文件读取耗时：" + (end - start) + "ms"); // 测试 NIO 的文件写入性能 start = System.currentTimeMillis(); FileChannel fc = new FileOutputStream(file).getChannel(); ByteBuffer byteBuffer = ByteBuffer.allocate(BUFFER_SIZE); for (int i = 0; i < size / BUFFER_SIZE; i++) { fc.write(byteBuffer); byteBuffer.clear(); } fc.close(); end = System.currentTimeMillis(); System.out.println("NIO 文件写入耗时：" + (end - start) + "ms"); // 测试 NIO 的文件读取性能 start = System.currentTimeMillis(); fc = new FileInputStream(file).getChannel(); byteBuffer = ByteBuffer.allocate(BUFFER_SIZE); while (fc.read(byteBuffer) != -1) { byteBuffer.flip(); byteBuffer.clear(); } fc.close(); end = System.currentTimeMillis(); System.out.println("NIO 文件读取耗时：" + (end - start) + "ms"); } } ``` 该测试程序分别测试了 Java IO 和 NIO 的文件写入和文件读取性能。其中，文件大小为 100MB，缓冲区大小为 1MB。 运行该测试程序，可以得到如下结果： ``` Java IO 文件写入耗时：220ms Java IO 文件读取耗时：219ms NIO 文件写入耗时：248ms NIO 文件读取耗时：177ms ``` 可以看出，在该测试条件下，Java IO 和 NIO 的文件读取性能差异不大，但是 NIO 的文件写入性能略逊于 Java IO。不过需要注意的是，这只是一个简单的测试，实际情况下可能会因为多种因素而产生差异。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值