首页 / JAVA / 08 - JavaSE之IO流

08 - JavaSE之IO流

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了08 - JavaSE之IO流，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11008字，纯文字阅读大概需要16分钟。

内容图文

IO流

JAVA流式输入输出原理：可以想象成一根管道怼到文件上，另一端是我们程序，然后流的输入输出都是按照程序本身作为第一人称说明的。比如 input，对于我们程序来说就是有数据输入我们程序，output就是我们程序输出数据到文件等。对象不能搞错了，否则就南辕北辙了。

通过不同的角度对流的输入输出功能进行分类：

按数据流的方向分为：输入流和输出流
按处理数据单位不同分为：字节流和字符流（2个字节）
按功能不同分为：节点流和处理流

输入流和输出流

JAVA JDK 所提供的所有流类型位于包 java.io 内部，分别继承自下面四个抽象流类型：
```
                    字节流             字符流   
                
```
输入流 InputStream Reader
输出流 OutputStream Writer

节点流和处理流

节点流为可以从一个特定的数据源（节点）读写数据（如：文件，内存）。

节点流可以简单的理解为：一根管道直接怼到文件上，进行数据的读写。

处理流是连接在已存在的节点流或处理流上的，通过读数据进行处理（过滤等）为程序提供更加强大的读写功能。

处理流可以简单的理解为：套在节点流管道的管子，可以对流过节点流的数据进行处理，过滤等操作。

InputStream 抽象类

继承自 InputStream的流都是用于向程序中输入数据，且数据的单位为字节。
继承自 InputStream的类有如下等：（加粗为节点流，未加粗为处理流）

FileInputStream

PipedInputStream

FilterInputStream

ByteArrayInputStream

SequenceInputStream

StringBufferInputStream

ObjectInputStream

InputStream的基本方法

int read() throws IOException
int read(byte[] buffer) throws IOException
int read(byte[] buffer, int offset, int length) throws IOException
void close() throws IOException

OutputStream 抽象类

继承自 OutputStream的流都是用于从程序中输出数据，且数据的单位为字节。
继承自 OutputStream的类有如下等：（加粗为节点流，未加粗为处理流）

FileOutputStream

PipedOutputStream

FilterOutputStream

ByteArrayOutputStream

ObjectOutputStream

OutputStream 基本方法

void write(int b) throws IOException
void write(byte[] b) throws IOException
void write(byte[] b, int off, int len) throws IOException
void close() throws IOException
void flush() throws IOException // 在关闭输出流之前使用，将输出缓冲区的数据写到目的地

Reader

继承自 Reader 的流都是用于程序从外部读入数据，且数据的单位是字符（2个字节）。
如下为继承自Reader的流。（加粗为节点流，未加粗为处理流）

BufferedReader

CharArrayReader

InputStreamReader

FilterReader

PipedReader

StringReader

Reader的基本方法 - 略

Writer

继承自 Writer的流都是用于程序向外部写入数据，且数据的单位是字符（2个字节）。
如下为继承自Writer的流。（加粗为节点流，未加粗为处理流）

BufferedWriter

CharArrayWriter

OutputStreamWriter

FilterWriter

PipedWriter

StringWriter

Writer的基本方法 - 略

节点流类型

类型字节流字符流
File（文件） FileInputStream / FileOutputStream FileReader / FileWriter
Memory Array ByteArrayInputStream / ByteArrayOutputStream CharArrayReader / CharArrayWriter
Memory String -- StringReader / StringWriter
Pipe（管道） PipedInputStream / PipedOutputStream PipedReader / PipedWriter

举例1：FileInputStream

            import java.io.*;
public class Test {
    public static void main(String[] args) {
        int b = 0;
        long num = 0;
        FileInputStream ln = null;

        try {
             ln = new FileInputStream("I:/Java/Demo/test.txt");
        } catch (FileNotFoundException e) {
            System.out.println("文件不存在！");
            System.exit(-1);
        }

        try {
            while ((b=ln.read()) != -1) {
                System.out.print((char)b);
                num++;
            }
            ln.close();
            System.out.println();
            System.out.println("共读出：" + num + "个字节。");
        } catch (IOException e) {
            System.out.println("文件读取失败！");
            System.exit(-1);
        }
    }
}

举例2：FileOutputStream

            import java.io.*;
public class Test {
    public static void main(String[] args) {
        int b = 0;
        FileInputStream in = null;
        FileOutputStream out = null;

        try {
            in = new FileInputStream("I:/Java/Demo/test.txt");
            out = new FileOutputStream("I:/Java/Demo/newtest.txt");

            while((b=in.read()) != -1) {
                out.write(b);
            }
        } catch (FileNotFoundException e) {
            System.out.println("文件不存在！");
            System.exit(-1);

        } catch (IOException e) {
            System.out.println("文件复制失败！");
            System.exit(-2);
        }
        System.out.println("文件复制成功！");
    }
}

处理流类型

处理类型字节流字符流
Buffering BufferedInputStream/BufferedOutputStream BufferedReader/BufferedWriter
Filtering FilterInputStream/FilterOutputStream FilterReader/FilterWriter
Converting between bytes and character -- InputStreamReader/OutputStreamWriter
Object Serialization ObjectInputStream/ObjectOutputStream --
Data conversion DataInputStream/DataOutputStream --
Counting LineNumberInputStream LineNumberReader
Peeking ahead PushbackInputStream PushbackReader
Printing PrintStream PrintWriter

缓冲流（以Buffered开头）

缓冲流套接在相应的节点流上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法。

BufferedReader / BufferedWriter / BufferedInputStream / BufferedOutputStream
缓冲流支持其父类的 mark 和 reset 方法。
BufferedReader 提供了 readLine 方法用于读取一行字符串（以\r或者\n分割）
BufferedWriter 提供了 newLine 用于写入一个行分隔符。
对于输出的缓冲流，写出的数据会先在内存中缓存，使用 flush 方法将会使内存中的数据立刻写出。

举例1：

            import java.io.*;
public class Test {
    public static void main(String[] args) {
        int b = 0;
        FileInputStream in = null;
        BufferedInputStream bin = null;

        try {
            in = new FileInputStream("I:/Java/Demo/test.txt");
            bin = new BufferedInputStream(in);

            bin.mark(100);

            for(int i=0; (i<=10)&&(b=bin.read()) != -1; i++) {
                System.out.print((char)b);
            }

            bin.reset();
            System.out.println();

            for(int i=0; (i<=10)&&(b=bin.read()) != -1; i++) {
                System.out.print((char)b);
            }

        } catch (FileNotFoundException e) {
            System.out.println("文件不存在！");
            System.exit(-1);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

举例2：

            import java.io.*;
public class Test {
    public static void main(String[] args) {
        String s = null;
        try {
            BufferedWriter bw = new BufferedWriter(new FileWriter("I:/Java/Demo/test.txt"));
            BufferedReader br = new BufferedReader(new FileReader("I:/Java/Demo/test.txt"));

            for(int i=0; i<100; i++) {
                s = Double.toString(Math.random());
                bw.write(s);
                bw.newLine();
            }

            bw.flush();

            while((s=br.readLine()) != null) {
                System.out.println(s);
            }

            bw.close();
            br.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
//0.7365309652822098
//0.577186775602007
//0.11736466966949166
//0.2998096440959087
//0.23859539950503672
//...

转换流

InputStreamReader 和 OutputStreamWriter 用于字节数据到字符数据之间的转换。
InputStreamReader 需要和 InputStream 套接。
OutputStreamWriter 需要和 OutputStream 套接。
转换流在构造时可以指定其编码结合，例如： InputStream is = new InputStreamReader(System.in, "ISO8859_1")

举例1：

            import java.io.*;
public class Test {
    public static void main(String[] args) {
        try {
            OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("I:/Java/Demo/test.txt"));
            osw.write("1234567890");
            System.out.println(osw.getEncoding());
            osw.flush();
            osw.close();

            osw = new OutputStreamWriter(new FileOutputStream("I:/Java/Demo/test.txt", true), "ISO8859_1");
            osw.write("abcdefghijklmn");
            System.out.println(osw.getEncoding());
            osw.flush();
            osw.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

举例2：

            import java.io.*;
public class Test {
    public static void main(String[] args) {
        try {
            String s = null;
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);

            while((s = br.readLine()) != null) {
                if(s.equalsIgnoreCase("exit")) {
                    break;
                }
                System.out.println(s);
            }
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

数据流

DataInputStream 和 DataOutputStream 分别继承自 InputStream 和 OutputStream，它属于处理流，需要分别套接在 InputStream 和 OutputStream 类型的节点流上。
DataInputStream 和 DataOutputStream 提供了可以存取与机器无关的 Java 原始类型数据（如：int，double 等）的方法。
DataInputStream 和 DataOutputStream 的构造方法为：
DataInputStream (InputStream in)
DataOutputStream (OutputStream out)

数据流的作用？

比如，我们如何存储一个很大的数到文件？我们之前的方法是将其转换成字符串存储，可不可以直接存储呢？数据流可以。它提供了很多方法用于存储基础数据类型的数据，参看 API 文档。

举例1：

            import java.io.*;
public class Test {
    public static void main(String[] args) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream(); // 在内存自动生成一个 Byte[] 数组
        DataOutputStream dos = new DataOutputStream(baos);

        try {
            dos.writeDouble(Math.random());
            dos.writeBoolean(true);

            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            System.out.println(bais.available());

            DataInputStream dis = new DataInputStream(bais);

            System.out.println(dis.readDouble());
            System.out.println(dis.readBoolean());

            dos.close();
            dis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

问题：我们写一个 double，写一个boolean写到哪里了呢？

其实，在我们 ByteArrayOutputStream baos = new ByteArrayOutputStream(); 的时候，就在内存中开辟了一块空间，用来将程序要写入的数据写到这片内存中。

还有，在读数据的时候，由于这片内存的分配是按照队列的方式分配的，所以先写进去的数据要先读出来，如果如上面程序那样，先读boolean的话，就会读取到double 8个字节的第一个字节上，切记！

Print 流（打印流）

PrintWriter 和 PrintStream 都属于输出流，分别针对与字符和字节。
PrintWriter 和 PrintStream 提供了重载的 print println 方法用于多种数据类型的输出。
PrintWriter 和 PrintStream 的输出操作不会抛出异常，用户通过检测错误状态获取错误信息。
PrintWriter 和 PrintStream 有自动 flush 功能。

PrintWriter(PrintWriter out)
PrintWriter(Writer out, boolean autoFlush)
PrintWriter(OutputStream out)
PrintWriter(OutputStream out, boolean autoFlush)
PrintStream(OutputStream out)
PrintStream(OutputStream out, boolean autoFlush)

举例1：

            import java.io.*;
public class Test {
    public static void main(String[] args) {
        PrintStream ps = null;

        try {
            FileOutputStream fos = new FileOutputStream("I:\\Java\\Demo\\test.txt");

            ps = new PrintStream(fos);

            if(null != ps) {
                System.setOut(ps);
            }

            for(int i=0; i<60000; i++) {
                System.out.print((char)i + " ");

                if(i%50 == 0) {
                    System.out.println();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

将输出打印语句重定向到 test.txt 文件中。

举例2：

            import java.io.*;

public class Test {
    public static void main(String[] args) {
        String filename = args[0];

        if (filename != null) {
            list(filename, System.out);
        }
    }

    public static void list(String f, PrintStream fs) {
        try {
            String s = null;
            BufferedReader br = new BufferedReader(new FileReader(f));

            while ((s = br.readLine()) != null) {
                fs.println(s);
            }
            br.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

将 args[0] 所写的文件名对应的文件打印到终端。

举例3：

            import java.io.*;
import java.util.*;

public class Test {
    public static void main(String[] args) {
        String s = null;

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        try {
            FileWriter fw = new FileWriter("I:/Java/Demo/log.txt", true);
            PrintWriter log = new PrintWriter(fw);

            while((s=br.readLine()) != null) {
                if(s.equalsIgnoreCase("exit")) {
                    break;
                }
                System.out.println(s);
                log.println("------");
                log.println(s);
                log.flush(); // 可以省略

            }
            log.println("--- " + new Date() + " ---");
            log.flush(); // 可以省略
            log.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

将从终端输入的内容作为 log 写到 log.txt 文件里面。

Object 流

Object 流的作用：当我们存储一个元素的时候，（比如在画图软件上画了一个圆）我们的圆有很多属性，原点位置，半径大小，颜色，粗细等，既然每一个属性都需要存储，而且这些属性都在一个 Object 对象里面，那么我们为什么不直接写整个 Object呢？（这叫序列化。）

注意：当你 new 一个 Object 的时候，不单单只有你的属性，还有一些比如 Object的版本号，this，super 等。

举例：

            import java.io.*;
public class Test {
    public static void main(String[] args) {
        TmpClass tm = new TmpClass();
        tm.a  =10;
        tm.d = false;

        try {
            FileOutputStream fos = new FileOutputStream("I:/Java/Demo/text.txt");
            ObjectOutputStream oos = new ObjectOutputStream(fos);

            oos.writeObject(tm);
            oos.flush();
            oos.close();

            FileInputStream fis = new FileInputStream("I:/Java/Demo/text.txt");
            ObjectInputStream ois = new ObjectInputStream(fis);
            TmpClass t = (TmpClass) ois.readObject();
            System.out.println(t.a + " " + t.b + " " + t.c + " " + t.d);
        } catch (ClassNotFoundException c) {
            System.out.println("读取文件失败");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class TmpClass implements Serializable {
    int a = 1;
    int b = 2;
    double c = 3.0;
    boolean d = true;
}

Serializable 接口

可以被序列化的，如果想把一个类的对象，写到硬盘或者网络，想把这个对象序列化成一个字节流的话，必须要实现这个接口。
这个接口没有任何方法，是一个空接口，是一个标记性接口，它只是给编译器看的，编译器看到后就知道这个类的对象时可以被序列化的，是可以整个写入文件的。

tansient关键字

使用方法，修饰成员变量。

class TmpClass implements Serializable {
int a = 1;
int b = 2;
tansient double c = 3.0;
boolean d = true;
}
transient 表示透明的意思，就是说在一个类的对象序列化的时候不予考虑，就是将这个类的对象写入文件的时候，不写这个被transient 修饰的成员变量，那么我们再读出来的时候就是默认值（如上，c 读出来的时候是 0.0）

externalizable 接口

可以理解为个性化的 Serializable 接口，externalizable 接口是继承 Serializable 接口得到的，相当于自己控制序列化的过程。（了解就好）

总结

本章复习方法：把所有的名字，关键字写到一张纸上，每天看看想想自己，给朕看半个时辰。—— 康熙

原文：https://www.cnblogs.com/lvonve/p/8323649.html

内容总结

以上是互联网集市为您收集整理的08 - JavaSE之IO流全部内容，希望文章能够帮你解决08 - JavaSE之IO流所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1284343.html

来源：【匿名】

【上一篇】JAVA 设计模式职责链模式【下一篇】JAVA/JSP学习系列之五

更多 ►

【08 - JavaSE之IO流】教程文章相关的互联网学习教程文章

08 - JavaSE之IO流【代码】

IO流JAVA流式输入输出原理：可以想象成一根管道怼到文件上，另一端是我们程序，然后流的输入输出都是按照程序本身作为第一人称说明的。比如 input，对于我们程序来说就是有数据输入我们程序，output就是我们程序输出数据到文件等。对象不能搞错了，否则就南辕北辙了。通过不同的角度对流的输入输出功能进行分类：按数据流的方向分为：输入流和输出流按处理数据单位不同分为：字节流和字符流（2个字节）按功能不同分为：节点流和处理...

java IO流学习笔记

import java.io.*;class hello{ public static void main(String[] args) { System.out.println(File.separator); System.out.println(File.pathSeparator); }}【运行结果】：\;String fileName="D:"+File.separator+"hello.txt"; File f=new File(fileName); if(f.exists()){ f.delete();File f=new File("D:\\hello.txt");创建新文件f.createNewFile();创建新文件夹 f.mkdir();删除...

java IO流：转换流【代码】【图】

转换流目录转换流字符编码和字符集1. 字符编码2. 字符集ASCII字符集ISO-8859-1字符集：GBxxx字符集：Unicode字符集：编码引出的问题OutputStreamWriter 类构造方法InputStreamReader类构造方法字符编码和字符集1. 字符编码计算机中储存的信息都是用二进制数表示的。按照某种规则，将字符存储到计算机中，称为编码。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码。编码:字符(能看懂的)--字节(看不懂的)解码...

Java IO流【代码】【图】

IO流是用来处理设备之间的数据传输的，Java对数据的操作都是使用流的方式处理的，而且Java将处理流的操作封装成IO流对象了。一、IO流的分类流按照操作的数据分为：字节流、字符流流按照流的方向分为：输入流、输出流二、字节流：inputString------此抽象类是表示字节输入流的所有类的超类。inputStream提供的方法inputStream是输入流，是应用程序读取数据的方式，而read（）方法就是InputStream读取数据的方式从API中可以看到，rea...

Java IO流之 InputStreamReader 字节流转字符流【代码】

http://www.verejava.com/?id=16994667084611package com.io;import java.io.*;public class TestInputStreamReader {public static void main(String[] args){InputStream is=null;try{is=new FileInputStream("res/chinese.txt");//将inputStream 转换成 ReaderReader reader=new InputStreamReader(is);int l;while((l=reader.read())!=-1){System.out.println((char)l);}}catch (Exception e){e.printStackTrace();}finally{tr...

Java基础知识强化之IO流笔记60：打印流之改进复制文本文件的案例【代码】

1. 使用打印流改进复制文本文件的案例2. 代码示例： 1package cn.itcast_03;2 3import java.io.BufferedReader;4import java.io.BufferedWriter;5import java.io.FileReader;6import java.io.FileWriter;7import java.io.IOException;8import java.io.PrintWriter;910/*11 * 需求：DataStreamDemo.java复制到Copy.java中 12 * 数据源： 13 * DataStreamDemo.java -- 读取数据 -- FileReader -- BufferedReader 14 * 目的地...

Java第09次实验(IO流)-实验报告【代码】【图】

0. 字节流与二进制文件使用DataOutputStream与FileOutputStream将Student对象写入二进制文件student.data 二进制文件与文本文件的区别try...catch...finally注意事项使用try..with...resouces关闭资源使用DataInputStream与FileInputStream从student.data中读取学生信息并组装成对象我的代码 1class Student {2privateint id;3private String name;4privateint age;5privatedouble grade; 6public Student(){7 8 }9public ...

java IO流的API【图】

常用的IO流API有：【InputStream、OutputStream】【FileInputStream、FileOutputStream】【BufferedInputStream、BufferedOutputStream】【BufferedReader、BufferedWriter】流分为两种：字节流、字符流。InputStream(字节输入流)和Reader(字符输入流)通俗的理解都是读（read）的。OutputStream(字节输出流)和Writer(字符输出流)通俗的理解都是写(writer)的。 1、字节输入流InputStream及以下子类层次结构图如下 2、java中的字符是...

java基础46 IO流技术（输入字符流/缓冲输入字符流）

一、输入字符流原创作者：DSHORE作者主页：http://www.cnblogs.com/dshore123/原文出自：https://www.cnblogs.com/dshore123/p/9272904.html欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的推荐，或评论，谢谢！）原文：https://www.cnblogs.com/dshore123/p/9272904.html

Java基础系列——IO流【代码】

---恢复内容开始--- Java对数据的操作都是通过流的方式，数据的输入和输出是相对内存来说的，将外设的数据读到内存：输入流；将内存的数据写到外设：输出流。流按操作数据分为两种：字节流，字符流。输入输出的数据全都是以字节为单位的二进制，字符流后期才出现，字符流出现的目的是让机器识别日常生活文字，编码表(美国ascii，中国GBK)记录了文字和数字的对应关系，从而字节流+编码表=字节流，从硬盘读取字节流之后，先查表，转...

JAVA面试题一之 io流的操作【代码】

/*定义一个文件输入流，调用read(byte[] b)方法。将a.txt文件中的内容打印出来（byte数组大小限制为5）。*/拿到题以后要先整理出思路：分析可知： 1.read(byte[] b)该方法属于字节输入流 2.byte数组大小限制为5，当碰到中文的时候极易出现乱码解决的方案：使用内存流publicstaticvoid main(String[] args) throws IOException {FileInputStream fis = new FileInputStream("f.txt");ByteArrayOutputStream baos = ...

【JAVA的 IO流之FileInputStream和FileOutputStream】

java的 IO流即输入输出流，流是一组有顺序的，有起点和终点的字节结合，是对数据传输的总称。即数据在两设备间的传输称为流，流的本质是数据传输。 IO流可以分为字节流和字符流。给出相应的IO结构图：在接下来的一段时间里，将会慢慢介绍各种流的使用，本篇博客先介绍字节流的FileOutputStream和相对应的FileInputStream。一.FileOutputStream(文件输出流） OutputStream是一个抽象类，抽象类必须通过子类实现。现在要向文件...

黑马程序员_java基础笔记(07)...IO流

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- <DIV style=‘font: 16px/28px "Hiragino Sans GB W3", "Hiragino Sans GB", Arial, Helvetica, simsun, 宋体; text-align: left; color: rgb(0, 0, 0); text-transform: none; text-indent: 0px; letter-spacing: normal; word-spacing: 0px; white-space: normal; orphans: 2; widows: 2; font-size-adjust: none; font-st...

Java基础知识强化之IO流笔记66：Properties的概述和使用（作为Map集合使用）【代码】【图】

1. Properties的概述 Properties：属性集合类。是一个可以和IO流相结合使用的集合类。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。Properties是Hashtable的子类，说明是一个Map集合。 2. Properties作为Map集合使用 1package cn.itcast_08;2 3import java.util.Properties;4import java.util.Set;5 6/* 7 * Properties:属性集合类。是一个可以和IO流相结合使用的集合类。8 * Properties 可保...

Java的IO流

1.概述 Java的IO通过java.io包下面的接口和类来实现的，在java.io包下包括输入，输出两种IO流，每种输入和输出流又可以分为字节流和字符流两大类。其中字节流以字节为单位来处理输入输出操作，其中字符流以字符为单位来处理输入输出操作。Java的IO流分为底层节点流和上层处理流，其中节点流用于和底层的物理节存储点直接关联——不同的物理节点获取节点流的方式可能存在差异，但程序可以把不同的物理节点包装成统一的处理流，从而允...

JAVA - 技术教程分类

Java 教程 Java 简介 Java 开发环境配置 Java 基础语法 Java 对象和类 Java 基本数据类型 Java 变量类型 Java 修饰符 Java 运算符 Java 循环结构 Java 条件语句 Java switch case Java Number & Math 类 Java Character 类 Java String 类 Java StringBuffer Java 数组 Java 日期时间 Java 方法 Java Stream、File、IO Java Scanner 类 Java 异常处理 Java 继承 Java Override/Overload Java 多态 Java 抽象类 Java 封装 Java 接口 Java 枚举 Java 包(package) Java 数据结构 Java 集合框架 Java ArrayList Java LinkedList Java HashSet Java HashMap Java Iterator Java Object Java 泛型 Java 序列化 Java 网络编程 Java 多线程编程 Java Applet 基础 Java 文档注释 Java 实例 Java 8 新特性 Java MySQL 连接 Java 9 新特性 Java 测验 java 全部

JAVA - 最热教程

Java在运行项目时候，点击右键的弹框，...nacos配置中心超时问题：java.net.Conn...Java的设计模式（7）— 生产者-消费者模...基于DOM4j和POI实现的XML文件转换为XLS...如何在Java中创建一些变量类型别名使用java8的Stream统计字符串数组中每一...idea插件篇之java内存分析工具(JProfil...cannot cast 'java.lang.Integer' to '...java – Bootstrap.properties中Spring...Java8利用stream流实现数字排序和中文排...

首页 / JAVA / 08 - JavaSE之IO流

08 - JavaSE之IO流

内容导读

内容图文

内容总结

内容备注

内容手机端

【08 - JavaSE之IO流】教程文章相关的互联网学习教程文章

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程