Java IO知识点总结

最新推荐文章于 2022-08-08 14:04:29 发布
最新推荐文章于 2022-08-08 14:04:29 发布
阅读量712 收藏
点赞数
分类专栏： java 文章标签： java io
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43860783/article/details/121027515
版权

<------------------------------廖雪峰学Java---------------------------------->

目录

1. File对象

  • Java的标准库java.io提供了File对象来操作文件和目录
  • File对象有3种形式表示的路径，一种是getPath()，返回构造方法传入的路径，一种是getAbsolutePath()，返回绝对路径，一种是getCanonicalPath，它和绝对路径类似，但是返回的是规范路径
  • File对象有一个静态变量用于表示当前平台的系统分隔符：
System.out.println(File.separator); // 根据当前平台打印"\"或"/"
  • 构造一个File对象，即使传入的文件或目录不存在，代码也不会出错，因为构造一个File对象，并不会导致任何磁盘操作。只有当我们调用File对象的某些方法的时候，才真正进行磁盘操作
  • 调用isFile()，判断该File对象是否是一个已存在的文件，调用isDirectory()，判断该File对象是否是一个已存在的目录
  • 判断文件的权限和大小：
boolean canRead()：是否可读；
boolean canWrite()：是否可写；
boolean canExecute()：是否可执行；
long length()：文件字节大小。

对目录而言，是否可执行表示是否能够列出其子文件夹及子文件

  • 当File对象表示一个文件时，可以通过createNewFile()创建一个新文件，用delete()删除该文件：
File file = new File("/path/to/file");
if (file.createNewFile()) {
    // 文件创建成功:
    // TODO:
    if (file.delete()) {
        // 删除文件成功:
    }
}
  • File对象提供了createTempFile()来创建一个临时文件，以及deleteOnExit() 在JVM退出时自动删除该文件
  • 当File对象表示一个目录时，可以使用list() 和listFiles() 列出目录下的文件和子目录名。listFiles()提供了一系列重载方法，可以过滤不想要的文件和目录：
public class Main {
    public static void main(String[] args) throws IOException {
        File f = new File("C:\\Windows");
        File[] fs1 = f.listFiles(); // 列出所有文件和子目录
        printFiles(fs1);
        File[] fs2 = f.listFiles(new FilenameFilter() { // 仅列出.exe文件
            public boolean accept(File dir, String name) {
                return name.endsWith(".exe"); // 返回true表示接受该文件
            }
        });
        printFiles(fs2);
    }

    static void printFiles(File[] files) {
        System.out.println("==========");
        if (files != null) {
            for (File f : files) {
                System.out.println(f);
            }
        }
        System.out.println("==========");
    }
}
  • File对象如果表示一个目录，可以通过以下方法创建和删除目录：
boolean mkdir()：创建当前File对象表示的目录；
boolean mkdirs()：创建当前File对象表示的目录，并在必要时将不存在的父目录也创建出来；
boolean delete()：删除当前File对象表示的目录，当前目录必须为空才能删除成功。
  • Java标准库还提供了一个Path对象，它位于java.nio.file包。Path对象和File对象类似，但操作更加简单：
public class Main {
    public static void main(String[] args) throws IOException {
        Path p1 = Paths.get(".", "project", "study"); // 构造一个Path对象
        System.out.println(p1);
        Path p2 = p1.toAbsolutePath(); // 转换为绝对路径
        System.out.println(p2);
        Path p3 = p2.normalize(); // 转换为规范路径
        System.out.println(p3);
        File f = p3.toFile(); // 转换为File对象
        System.out.println(f);
        for (Path p : Paths.get("..").toAbsolutePath()) { // 可以直接遍历Path
            System.out.println("  " + p);
        }
    }
}

2. InputStream

  • InputStream是Java标准库提供的最基本的输入流。它位于java.io这个包里。java.io包提供了所有同步IO的功能
  • InputStream是一个抽象类，它是所有输入流的超类。这个抽象类定义的一个最重要的方法就是int read()，签名如下：
public abstract int read() throws IOException;
// 这个方法会读取输入流的下一个字节，并返回字节表示的int值（0~255）。如果已读到末尾，返回-1表示不能继续读取了
  • FileInputStream是InputStream的一个子类。顾名思义，FileInputStream就是从文件流中读取数据
  • InputStream和OutputStream都是通过close()方法来关闭流。关闭流就会释放对应的底层资源
  • 在读取或写入IO流的过程中，可能会发生错误，例如，文件不存在导致无法读取，没有写权限导致写入失败，等等，这些底层错误由Java虚拟机自动封装成IOException异常并抛出。因此，所有与IO操作相关的代码都必须正确处理IOException
  • 利用Java 7引入的新的try(resource) 的语法，只需要编写try语句，让编译器自动为我们关闭资源:
public void readFile() throws IOException {
    try (InputStream input = new FileInputStream("src/readme.txt")) {
        int n;
        while ((n = input.read()) != -1) {
            System.out.println(n);
        }
    } // 编译器在此自动为我们写入finally并调用close()
}

编译器只看try(resource = …)中的对象是否实现了java.lang.AutoCloseable接口，如果实现了，就自动加上finally语句并调用close()方法。InputStream和OutputStream都实现了这个接口，因此，都可以用在try(resource)中

  • 很多流支持一次性读取多个字节到缓冲区，对于文件和网络流来说，利用缓冲区一次性读取多个字节效率往往要高很多。InputStream提供了两个重载方法来支持读取多个字节：
int read(byte[] b)：读取若干字节并填充到byte[]数组，返回读取的字节数
int read(byte[] b, int off, int len)：指定byte[]数组的偏移量和最大填充数
//利用上述方法一次读取多个字节时，需要先定义一个byte[]数组作为缓冲区，
//read()方法会尽可能多地读取字节到缓冲区， 但不会超过缓冲区的大小。
//read()方法的返回值不再是字节的int值，而是返回实际读取了多少个字节。
//如果返回-1，表示没有更多的数据

public void readFile() throws IOException {
    try (InputStream input = new FileInputStream("src/readme.txt")) {
        // 定义1000个字节大小的缓冲区:
        byte[] buffer = new byte[1000];
        int n;
        while ((n = input.read(buffer)) != -1) { // 读取到缓冲区
            System.out.println("read " + n + " bytes.");
        }
    }
}
  • 在调用InputStream的read()方法读取数据时，read()方法是阻塞（Blocking）的，即必须等待read()方法返回才能执行下一行代码
  • ByteArrayInputStream可以在内存中模拟一个InputStream：
public class Main {
    public static void main(String[] args) throws IOException {
        byte[] data = { 72, 101, 108, 108, 111, 33 };
        try (InputStream input = new ByteArrayInputStream(data)) {
            int n;
            while ((n = input.read()) != -1) {
                System.out.println((char)n);
            }
        }
    }
}
  • ByteArrayInputStream实际上是把一个byte[]数组在内存中变成一个InputStream，虽然实际应用不多，但测试的时候，可以用它来构造一个InputStream:
public class Main {
    public static void main(String[] args) throws IOException {
        byte[] data = { 72, 101, 108, 108, 111, 33 };
        try (InputStream input = new ByteArrayInputStream(data)) {
        // 不需要真的提供一个FileInputStream，用ByteArrayInputStream来模拟即可
            String s = readAsString(input);
            System.out.println(s);
        }
    }

    public static String readAsString(InputStream input) throws IOException {
        int n;
        StringBuilder sb = new StringBuilder();
        while ((n = input.read()) != -1) {
            sb.append((char) n);
        }
        return sb.toString();
    }
}

3. OutputStream

  • OutputStream是Java标准库提供的最基本的输出流，是所有输出流的超类。这个抽象类定义的一个最重要的方法就是void write(int b)，这个方法会写入一个字节到输出流。要注意的是，虽然传入的是int参数，但只会写入一个字节，即只写入int最低8位表示字节的部分
  • OutputStream也提供了close()方法关闭输出流，以便释放系统资源。要特别注意：OutputStream还提供了一个flush()方法，它的目的是将缓冲区的内容真正输出到目的地。

一般来说，系统会等到缓冲区写满时再一次 性输出，flush()方法的作用是强制输出缓冲区的内容

  • 通常情况下，我们不需要调用这个flush()方法，因为缓冲区写满了OutputStream会自动调用它，并且，在调用close()方法关闭OutputStream之前，也会自动调用flush()方法，但是在要求快速响应的场景（如聊天服务）下就需要手动调用flush方法
  • FileOutputStream为例，演示如何将若干个字节写入文件流：
public void writeFile() throws IOException {
    OutputStream output = new FileOutputStream("out/readme.txt");
    output.write(72); // H
    output.write(101); // e
    output.write(108); // l
    output.write(108); // l
    output.write(111); // o
    output.close();
}

public void writeFile() throws IOException {
    try (OutputStream output = new FileOutputStream("out/readme.txt")) {
        output.write("Hello".getBytes("UTF-8")); // Hello
    } // 编译器在此自动为我们写入finally并调用close()
}
  • OutputStream的write()方法是阻塞的
  • FileOutputStream可以从文件获取输出流，这是OutputStream常用的一个实现类。此外，ByteArrayOutputStream可以在内存中模拟一个OutputStream
  • 同时操作多个AutoCloseable资源时，在try(resource) { … }语句中可以同时写出多个资源，用;隔开。例如，同时读写两个文件:
// 读取input.txt，写入output.txt:
try (InputStream input = new FileInputStream("input.txt");
     OutputStream output = new FileOutputStream("output.txt"))
{
    input.transferTo(output); // transferTo的作用是?
}

4. Filter模式（装饰者模式）

InputStream/OutputStream的功能并不是一成不变的，例如我们想要给流添加上“缓存”，“签名”，“加密”等功能时，如果通过直接创建各类型子类的话会出现“子类爆炸”的问题（即：子类数目过多，可想而知，各功能的Stream成一个子类，不同功能之间的组合同样也是子类，而这样的组合数量过多）。因此，Java主张使用Filter模式（“装饰者模式”，decorator）来对Stream对象进行包装。

  • 为了解决依赖继承会导致子类数量失控的问题，JDK首先将InputStream分为两大类：
一类是直接提供数据的基础InputStream，例如：
    FileInputStream
    ByteArrayInputStream
    ServletInputStream

一类是提供额外附加功能的InputStream，例如：
	BufferedInputStream
	DigestInputStream
	CipherInputStream
  • 当我们需要给一个“基础”InputStream附加各种功能时，我们先确定这个能提供数据源的InputStream，如FileInputStream等：
InputStream file = new FileInputStream("test.gz");
  • 紧接着，我们希望FileInputStream能提供缓冲的功能来提高读取的效率，因此我们用BufferedInputStream包装这个InputStream，得到的包装类型是BufferedInputStream，但它仍然被视为一个InputStream：
InputStream buffered = new BufferedInputStream(file);
  • 最后，假设该文件已经用gzip压缩了，我们希望直接读取解压缩的内容，就可以再包装一个GZIPInputStream：
InputStream gzip = new GZIPInputStream(buffered);
  • 无论包装多少次，得到的对象始终是InputStream，我们直接用InputStream来引用它:
    包装
  • InputStream
  • 编写FilterInputStream：
public class Main {
    public static void main(String[] args) throws IOException {
        byte[] data = "hello, world!".getBytes("UTF-8");
        try (CountInputStream input = new CountInputStream(new ByteArrayInputStream(data))) {
            int n;
            while ((n = input.read()) != -1) {
                System.out.println((char)n);
            }
            System.out.println("Total read " + input.getBytesRead() + " bytes");
        }
    }
}

class CountInputStream extends FilterInputStream {
    private int count = 0;

    CountInputStream(InputStream in) {
        super(in);
    }

    public int getBytesRead() {
        return this.count;
    }

    public int read() throws IOException {
        int n = in.read();
        if (n != -1) {
            this.count ++;
        }
        return n;
    }

    public int read(byte[] b, int off, int len) throws IOException {
        int n = in.read(b, off, len);
        if (n != -1) {
            this.count += n;
        }
        return n;
    }
}

注意到在叠加多个FilterInputStream，我们只需要持有最外层的InputStream，并且，当最外层的InputStream关闭时（在try(resource)块的结束处自动关闭），内层的InputStream的close()方法也会被自动调用，并最终调用到最核心的“基础”InputStream，因此不存在资源泄露

5. 直接读取Zip压缩文件的内容

  • ZipInputStream是一种FilterInputStream，它可以直接读取zip包的内容：
    在这里插入图片描述
    另一个JarInputStream是从ZipInputStream派生，它增加的主要功能是直接读取jar文件里面的MANIFEST.MF文件。因为本质上jar包就是zip包，只是额外附加了一些固定的描述文件。

  • 读取Zip文件：创建一个ZipInputStream，通常是传入一个FileInputStream作为数据源，然后，循环调用getNextEntry()，直到返回null，表示zip流结束；一个ZipEntry表示一个压缩文件或目录，如果是压缩文件，我们就用read()方法不断读取，直到返回-1：

try (ZipInputStream zip = new ZipInputStream(new FileInputStream(...))) {
    ZipEntry entry = null;
    while ((entry = zip.getNextEntry()) != null) {
        String name = entry.getName();
        if (!entry.isDirectory()) {
            int n;
            while ((n = zip.read()) != -1) {
                ...
            }
        }
    }
}
  • 创建Zip文件：ZipOutputStream是一种FilterOutputStream，它可以直接写入内容到zip包。我们要先创建一个ZipOutputStream，通常是包装一个FileOutputStream，然后，每写入一个文件前，先调用putNextEntry()，然后用write()写入byte[]数据，写入完毕后调用closeEntry()结束这个文件的打包：
try (ZipOutputStream zip = new ZipOutputStream(new FileOutputStream(...))) {
    File[] files = ...
    for (File file : files) {
        zip.putNextEntry(new ZipEntry(file.getName()));
        zip.write(getFileDataAsBytes(file));
        zip.closeEntry();
    }
}

上面的代码没有考虑文件的目录结构。如果要实现目录层次结构，new ZipEntry(name)传入的name要用相对路径

6. 读取classpath资源

  • 从classpath读取文件可以避免不同环境下文件路径不一致的问题：如果我们把properties文件放到classpath中，就不用关心它的实际存放路径
  • 在classpath中的资源文件，路径总是以／开头，我们**先获取当前的Class对象，然后调用getResourceAsStream()**就可以直接从classpath读取任意的资源文件：
try (InputStream input = getClass().getResourceAsStream("/default.properties")) {
    // TODO:
}
  • 调用getResourceAsStream()需要特别注意的一点是，如果资源文件不存在，它将返回null
  • 把默认的配置放到jar包中，再从外部文件系统读取一个可选的配置文件，就可以做到既有默认的配置文件，又可以让用户自己修改配置：
Properties props = new Properties();
props.load(inputStreamFromClassPath("/default.properties"));
props.load(inputStreamFromFile("./conf.properties"));

7. 序列化

  • 序列化是指把一个Java对象变成二进制内容，本质上就是一个byte[]数组
  • 一个Java对象要能序列化，必须实现一个特殊的java.io.Serializable接口，Serializable接口没有定义任何方法，它是一个空接口。我们把这样的空接口称为 “标记接口”（Marker Interface） ，实现了标记接口的类仅仅是给自身贴了个“标记”，并没有增加任何方法
  • 把一个Java对象变为byte[]数组，需要使用ObjectOutputStream。它负责把一个Java对象写入一个字节流：
ublic class Main {
    public static void main(String[] args) throws IOException {
        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
        try (ObjectOutputStream output = new ObjectOutputStream(buffer)) {
            // 写入int:
            output.writeInt(12345);
            // 写入String:
            output.writeUTF("Hello");
            // 写入Object:
            output.writeObject(Double.valueOf(123.456));
        }
        System.out.println(Arrays.toString(buffer.toByteArray()));
    }
}
  • 和ObjectOutputStream相反，ObjectInputStream负责从一个字节流读取Java对象：
try (ObjectInputStream input = new ObjectInputStream(...)) {
    int n = input.readInt();
    String s = input.readUTF();
    Double d = (Double) input.readObject();
}
  • readObject()可能抛出的异常有：
ClassNotFoundException：没有找到对应的Class；
InvalidClassException：Class不匹配。

对于ClassNotFoundException，这种情况常见于一台电脑上的Java程序把一个Java对象，
例如，Person对象序列化以后，通过网络传给另一台电脑上的另一个Java程序，
但是这台电脑的Java程序并没有定义Person类，所以无法反序列化。

对于InvalidClassException，这种情况常见于序列化的Person对象定义了一个int类型的age字段，
但是反序列化时，Person类定义的age字段被改成了long类型，所以导致class不兼容。
  • 反序列化时，由JVM直接构造出Java对象，不调用构造方法，构造方法内部的代码，在反序列化时根本不可能执行
  • Java本身提供的基于对象的序列化和反序列化机制既存在安全性问题，也存在兼容性问题。更好的序列化方法是通过JSON这样的通用数据结构来实现，只输出基本类型（包括String）的内容，而不存储任何与代码相关的信息

8. Reader

  • Reader是Java的IO库提供的另一个输入流接口。和InputStream的区别是，InputStream是一个字节流，即以byte为单位读取，而Reader是一个字符流，即以char为单位读取
  • java.io.Reader是所有字符输入流的超类，read()方法读取字符流的下一个字符，并返回字符表示的int，范围是0~65535。如果已读到末尾，返回-1
  • FileReader是Reader的一个子类，它可以打开文件并获取Reader，FileReader默认的编码与系统相关（例如如果Windows的默认编码时GBK，那么读取UTF-8编码的文件就会出现乱码），要避免乱码问题，我们需要在创建FileReader时指定编码：
Reader reader = new FileReader("src/readme.txt", StandardCharsets.UTF_8);
  • 用**try (resource)**来保证Reader在无论有没有IO错误的时候都能够正确地关闭
  • CharArrayReader可以在内存中模拟一个Reader，它的作用实际上是把一个char[]数组变成一个Reader：
try (Reader reader = new CharArrayReader("Hello".toCharArray())) {
}
  • StringReader可以直接把String作为数据源，它和CharArrayReader几乎一样:
try (Reader reader = new StringReader("Hello")) {
}
  • Reader和InputStream有什么关系？

除了特殊的CharArrayReader和StringReader，普通的Reader实际上是基于InputStream构造的，因为Reader需要从InputStream中读入字节流（byte），然后，根据编码设置，再转换为char就可以实现字符流。如果我们查看FileReader的源码，它在内部实际上持有一个FileInputStream

  • InputStreamReader可以把任何InputStream转换为Reader（转换器）。示例代码如下：
// 持有InputStream:
InputStream input = new FileInputStream("src/readme.txt");
// 变换为Reader:
Reader reader = new InputStreamReader(input, "UTF-8");

9. Writer

  • Writer就是带编码转换器的OutputStream，它把char转换为byte并输出
  • Writer
  • Writer是所有字符输出流的超类，它提供的方法主要有：
写入一个字符（0~65535）：void write(int c)；
写入字符数组的所有字符：void write(char[] c)；
写入String表示的所有字符：void write(String s)。
  • FileWriter就是向文件中写入字符流的Writer。它的使用方法和FileReader类似：
try (Writer writer = new FileWriter("readme.txt", StandardCharsets.UTF_8)) {
    writer.write('H'); // 写入单个字符
    writer.write("Hello".toCharArray()); // 写入char[]
    writer.write("Hello"); // 写入String
}
  • CharArrayWriter可以在内存中创建一个Writer，它的作用实际上是构造一个缓冲区，可以写入char，最后得到写入的char[]数组，这和ByteArrayOutputStream非常类似：
try (CharArrayWriter writer = new CharArrayWriter()) {
    writer.write(65);
    writer.write(66);
    writer.write(67);
    char[] data = writer.toCharArray(); // { 'A', 'B', 'C' }
}
  • StringWriter也是一个基于内存的Writer，它和CharArrayWriter类似。实际上，StringWriter在内部维护了一个StringBuffer，并对外提供了Writer接口
  • 除了CharArrayWriter和StringWriter外，普通的Writer实际上是基于OutputStream构造的，它接收char，然后在内部自动转换成一个或多个byte，并写入OutputStream。因此，OutputStreamWriter就是一个将任意的OutputStream转换为Writer的转换器：
try (Writer writer = new OutputStreamWriter(new FileOutputStream("readme.txt"), "UTF-8")) {
    // TODO:
}

10. PrintStream以及PrintWriter

  • PrintStream是一种FilterOutputStream，它在OutputStream的接口上，额外提供了一些写入各种数据类型的方法：
写入int：print(int)
写入boolean：print(boolean)
写入String：print(String)
写入Object：print(Object)，实际上相当于print(object.toString())
...
  • 我们经常使用的System.out.println()实际上就是使用PrintStream打印各种数据。其中，System.out是系统默认提供的PrintStream，表示标准输出
  • System.err是系统默认提供的标准错误输出
  • PrintStream和OutputStream相比，除了添加了一组print()/println()方法，可以打印各种数据类型，比较方便外，它还有一个额外的优点，就是不会抛出IOException，这样我们在编写代码的时候，就不必捕获IOException
  • PrintStream最终输出的总是byte数据，而PrintWriter则是扩展了Writer接口，它的print()/println()方法最终输出的是char数据。两者的使用方法几乎是一模一样的：
public class Main {
    public static void main(String[] args)     {
        StringWriter buffer = new StringWriter();
        try (PrintWriter pw = new PrintWriter(buffer)) {
            pw.println("Hello");
            pw.println(12345);
            pw.println(true);
        }
        System.out.println(buffer.toString());
    }
}

11. 使用Files工具类

  • 从Java 7开始，提供了Files和Paths这两个工具类，能极大地方便我们读写文件，Files和Paths是java.nio包里面的类，他俩封装了很多读写文件的简单方法
  • 要把一个文件的全部内容读取为一个byte[]，可以这么写：
byte[] data = Files.readAllBytes(Paths.get("/path/to/file.txt"));
  • 如果是文本文件，可以把一个文件的全部内容读取为String：
// 默认使用UTF-8编码读取:
String content1 = Files.readString(Paths.get("/path/to/file.txt"));
// 可指定编码:
String content2 = Files.readString(Paths.get("/path/to/file.txt"), StandardCharsets.ISO_8859_1);
// 按行读取并返回每行内容:
List<String> lines = Files.readAllLines(Paths.get("/path/to/file.txt"));
  • 写入文件：
// 写入二进制文件:
byte[] data = ...
Files.write(Paths.get("/path/to/file.txt"), data);
// 写入文本并指定编码:
Files.writeString(Paths.get("/path/to/file.txt"), "文本内容...", StandardCharsets.ISO_8859_1);
// 按行写入文本:
List<String> lines = ...
Files.write(Paths.get("/path/to/file.txt"), lines);
  • Files工具类还有copy()、delete()、exists()、move()等快捷方法操作文件和目录
  • Files提供的读写方法，受内存限制，只能读写小文件，例如配置文件等，不可一次读入几个G的大文件。读写大型文件仍然要使用文件流，每次只读写一部分文件内容
PinkGranite
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java zip压缩
後雪寒的专栏
11-09 525
Java中有与zip相关的api，位于java.util.zip.*包下。 在一些应用场景中，可能需要对程序生成的文件如导出比较大的excel文件，然后需要对其压缩上传。 在《Java 核心技术 卷二 高级特性》这本书中就有关于zip的介绍，下面将其摘录如下： 1.读取zip文件 zip文档通常以压缩格式存储了一个或多个文件，每个zip文档都有一个包含诸如文件名字和所使用的压缩方法等信...
import java.io后报错_【JAVA小白】 问关于做IO流作业的时候出错了，错误FileOutputStream.writeBytes...
weixin_39888268的博客
02-16 764
代码如下：package file;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;public class FileSplit {public stat...
一次使用FileOutputStream碰到的坑
chiczero的博客
09-28 2769
背景： 在一次使用字节流保存视频文件时，发现播放时画面出现乱码（卡碟）的现象 一开始的代码写法： InputStream inputStream = null; FileOutputStream fileOutputStream = null; inputStream = response.body().byteStream(); File file = new File(*******); if(!file.exists()){ file.
文件上传案例阻塞问题
qq_20564455的博客
08-05 267
如题所示，read进入阻塞状态怎么办 以及为什么会进入阻塞状态，文件为什么读取到末尾不返回-1结束标记。 客户端 import javafx.print.Printer; import java.io.*; import java.net.Socket; import java.util.HashMap; public class FuXi2 { public static void main(String[] args) throws IOException { ..
卧槽，这也真的太上头了吧
gp16674213804的博客
11-10 1265
“老吴，Java IO 也太上头了吧？”新兵蛋子小三向头顶很凉快的老吴抱怨道，“你瞧，我就按照传输方式对 IO 进行了一个简单的分类，就能搞出来这么多的玩意！” 好久没搞过 IO 了，老吴看到这幅思维导图也是吃了一惊。 想想也是，他当初学习 Java IO 的时候头也大，乌央乌央的一片，全是类，估计是所有 Java 包里面类最多的，一会是 Input 一会是 Output，一会是 Reader 一会是 Writer，真不知道 Java 的设计者是怎么想的。 看着肺都快要气炸的小三，老吴深深地吸了一口
Java中IO流知识点总结
12-22
一、流的分类 　1、按功能分 　读取流：InputStream Reader 　写出流：OutPutStream Writer 　2、按流的类型分类 　字节流：InputStream OutputStream 　字符流：Reader Writer 　二、流功能分析 ...
JAVA核心知识点总结.pdf
10-02
《JAVA核心知识点总结》 Java作为一款广泛应用的编程语言，其核心知识点对于开发者来说至关重要。本资料旨在为准备面试或者系统学习Java的人员提供一个全面的复习框架。以下是对其中部分关键知识点的详细阐述： **...
Java基础知识点总结.docx
04-03
Java学习更是如此，知识点总结目录如下： 目录 一、 Java概述 3 二、 Java语法基础 5 数据类型 5 运算符号 14 语句 15 函数 15 方法重载（Overloadjing）与重写（Overriding） 16 数组 17 总结 18 三、 常见关键字 ...
java 基础知识之IO总结
08-31
Java 基础知识之IO总结 Java中的I/O（Input/Output）是指计算机与外部世界交互的方式，包括输入和输出。Java中的I/O有两种类型，一...这些知识点对于Java开发者来说非常重要，因为I/O操作是编程语言的一个基础特性。
Java面试高频知识点总结
12-21
Java基础 – NIO的实现原理 NIO主要有三大核心部分：Channel(通道)，Buffer(缓冲区), ...JavaIO面向流意味着每次从流中读取一个或多个字节直到读取完所有字节，数据没有被缓存到任何地方，不能前后移动流中的数据，只有
【重铸Java根基】Java中的IO基础知识
最新发布
playadota的博客
08-08 259
java io基础知识
Java IO流知识点总结
热门推荐
wenzhi的博客
09-18 1万+
本主要对java的IO流知识点做比较全面的总结，但是没有很深入阐述。
Java中IO流知识总结
IT晓可程序员之路
05-23 998
流：可以理解数据的流动，就是一个数据流。IO流最终要以对象来体现，对象都存在IO包中。 流也进行分类： 1：输入流（读）和输出流（写）。 2：因为处理的数据不同，分为字节流和字符流。 字节流：处理字节数据的流对象。设备上的数据无论是图片或者dvd，文字，它们都以二进制存储的。二进制的最终都是以一个8位为数据单元进行体现，所以计算机中的最小数据单元就是字节。意味着，字节流可以处理设备上的所有数据
java IO知识点
oYeYuanXinZhiZhu1的专栏
05-04 706
1.对于字节流InputStream和OutPutStream，当read（）和writer（）时，他们只接受byte[]型数组。对于字符流Reader和Writer，read（）接受char[]类型，writer（）可以接受字符串、char[]数组，int值等参数。为什么已经存在字节流还要引入字符流熟悉java的应该知道，字节流比字符流产生的更早，可以说jdk一面世，已经有字节流了。那么为什么后...
Java中IO流详细总结
ThegreatHaige的博客
09-05 761
IO流 定义:Java针对文件的输入输出操作 各种流的总结一览 static关键字作用：不用通过新建对象就能直接去调用该方法， 类名.方法名即可。若是在本类中直接用方法名即可。 方法 作用 File(String Path) 完全路径法创建（包括文件名） File(文件路径 ,文件名) 文件路径+文件名创建 package haige.jichu.IO; import java.io.File; public class Demo01 { public stati
java知识点总结------IO(输入输出)
sunshine的博客
08-30 384
在Java中，将通过不同输入输出设备之间的数据传输抽象表示为流，Java中的流位于Java.io包中，称为IO流。 根据操作数据的不同，可以分为字节流和字符流，根据数据传输方向的不同，可以分为输入流和输出流，程序从输入流中读取数据，向输出流中写入数据。在IO包中，字节流的输入输出流用java.io.inputStream和java.io.outputStream表示，字符流的输入输出流分别用java.io.Reader和java.io.Writer表示。 IO中的输入输出都是对于程序而言的 flush
Java IO（一、概览）
weixin_55120597的博客
12-08 335
java IO 知识梳理
【学习日记】有关java的IO的知识点总结
z6528328的博客
09-09 1004
最近在看毕向东老师的java基础视频的IO部分知识的讲解。由于IO这块知识很重要，而且小的知识点很多，方法也多，今晚做个简单的总结以便日后复习。 IO概述 字符流的方法 字节流的方法 装饰设计模式 缓冲区的介绍 IO概述IO在java中是很重要的概念和知识点，按流向分为输入流和输出流，按操作数据分为**字节流**和**字符流**，顾名思义，字节流以字节为单位，字符流以字符为单位。java.io包中包
【转载】Java IO基础总结
weixin_30493321的博客
12-14 488
Java中使用IO(输入输出）来读取和写入，读写设备上的数据、硬盘文件、内存、键盘......，根据数据的走向可分为输入流和输出流，这个走向是以内存为基准的，即往内存中读数据是输入流，从内存中往外写是输出流。 根据处理的数据类型可分为字节流和字符流 1.字节流可以处理所有数据类型的数据，在java中以Stream结尾 2.字符流处理文本...
Java知识点.docx
12-10
"Java面试知识点概览" 在Java编程语言中，掌握基础知识对于成为一名优秀的开发者至关重要。以下是一些关键的Java知识点： 1. **String、StringBuffer、StringBuilder的区别** - String对象是不可变的，每次对其...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值