Java I/O学习（附实例和详解）
来源：互联网 发布：新手淘宝客服简历表格 编辑：程序博客网 时间：2024/06/03 13:47
一、Java I/O类结构以及流的基本概念
在阅读Java I/O的实例之前我们必须清楚一些概念，我们先看看Java I/O的类结构图：
Java I/O主要以流的形式进行读写数据。
流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。
根据处理数据的数据类型的不同可以分为：字符流和字节流。
字符流和字节流的主要区别：
1.字节流读取的时候，读到一个字节就返回一个字节； 字符流使用了字节流读到一个或多个字节（中文对应的字节数是两个，在UTF-8码表中是3个字节）时。先去查指定的编码表，将查到的字符返回。
2.字节流可以处理所有类型数据，如：图片，MP3，AVI视频文件，而字符流只能处理字符数据。只要是处理纯文本数据，就要优先考虑使用字符流，除此之外都用字节流。
3.实际上字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流在操作时使用了缓冲区，通过缓冲区再操作文件。
下面我们以文件操作作为实例进一步了解。
二、字符流实例
之前提到过“只要是处理纯文本数据，就要优先考虑使用字符流，除此之外都用字节流”。因此本字符流操作实例是操作txt文件。对其进行读写操作。
2.1、一些概念
此前，我们需要了解一些概念。
Java采用16位的Unicode来表示字符串和字符的。在写入字符流时我们都可以指定写入的字符串的编码。
这里博主贴出字符流类图结构，方便猿友阅读：
在文件操作的时候我们主要使用到FileReader和FileWriter或BufferedReader和BufferedWriter。
从类结构图来看：
FileReader是InputStreamReader的子类，而InputStreamReader是Reader的子类；
FileWriter是OutputStreamWriter的子类，而OutputStreamWriter则是Writer的子类。
2.2、FileReader和BufferedReader的使用
FileReader的常用构造包括以下两种：
（1）FileReader(String fileName)：根据文件名创建FileReader对象。
（2）FileReader(File file)：根据File对象创建FileReader对象。
FileReader的常用方法包括以下几种：
（1）int read()：读取单个字符。返回字符的整数值，如果已经到达文件尾，则返回-1.
（2）int read(char[] cbuf)：将字符读入cbuf字符数组。返回读取到的字符数，如果已经到达文件尾，则返回-1.
（3）int read(char[] cbuf,int off,int len)：将读取到的字符存放到cbuf字符数组从off标识的偏移位置开始处，最多读取len个字符。
BufferedReader有以下两种构造方法：
（1）BufferedReader(Reader in):根据in代表的Reader对象创建BufferReader实例，缓冲区大小采用默认值。
（2）BufferedReader(Reader in,int sz):根据in代表的Reader对象创建BufferedReader实例，缓冲区大小采用指定sz值。
BufferedReader的常用方法包括以下几种：
（1）int read()：返回字符的整数值，如果已经到达文件尾，则返回-1.
（2）int read(char[], int, int)：将读取到的字符存放到cbuf字符数组从off标识的偏移位置开始处，最多读取len个字符。
（3）String readLine()：读取一文本行。该方法遇到以下字符或者字符串认为当前行结束：‘\n’(换行符),’\r’(回车符),’\r\n’(回车换行)。返回值为该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回null。
代码实例：
package java_io;import java.io.BufferedReader; import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TestReader { public static void main(String[] args) { TestReader testReader = new TestReader(); String path = "C:\\Users\\luoguohui\\Desktop\\readerTest.txt"; testReader.readFileByFileReader(path); testReader.readFileByBufferedReader(path); } public void readFileByFileReader(String path){ FileReader fileReader = null; try { fileReader = new FileReader(path); char[] buf = new char[1024]; //每次读取1024个字符 int temp = 0; System.out.println("readFileByFileReader执行结果："); while ((temp = fileReader.read(buf)) != -1) { System.out.print(new String(buf, 0, temp)); } System.out.println(); } catch (Exception e) { e.printStackTrace(); } finally { //像这种i/o操作尽量finally确保关闭 if (fileReader!=null) { try { fileReader.close(); } catch (IOException e) { e.printStackTrace(); } } } } public void readFileByBufferedReader(String path){ File file = new File(path); if (file.isFile()) { BufferedReader bufferedReader = null; FileReader fileReader = null; try { fileReader = new FileReader(file); bufferedReader = new BufferedReader(fileReader); String line = bufferedReader.readLine(); System.out.println("readFileByBufferReader执行结果："); while (line != null) { System.out.println(line); line = bufferedReader.readLine(); } } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { try { fileReader.close(); bufferedReader.close(); } catch (IOException e) { e.printStackTrace(); } } } } } - 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
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
上面代码用到finally，关于finally虽然与I/O无关，不过这里还是说一下：
1、不管有木有出现异常，finally块中代码都会执行；
2、当try和catch中有return时，finally仍然会执行；
3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；
4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。
readerTest.txt文本内容：
执行结果：
2.3、FileWriter和BufferWriter的使用
FileWriter的常用构造有以下四种：
（1）FileWriter(String fileName)：根据文件名创建FileWriter对象。
（2）FileWriter(String fileName,boolean append)：根据文件名创建FileWriter对象，append参数用来指定是否在原文件之后追加内容。
（3）FileWriter(File file)：根据File对象创建FileWriter对象。
（4）FileWriter(File file,boolean append)：根据File对象创建FileWriter对象，append参数用来指定是否在原文件之后追加内容。
FileWriter的常用方法包括以下几种：
（1）void writer(int c)：向文件中写入正整数c代表的单个字符。
（2）void writer(char[] cbuf)：向文件中写入字符数组cbuf。
（3）void writer(char[] cbuf,int off, in len)：向文件中写入字符数组cbuf从偏移位置off开始的len个字符。
（4）void writer(String str)：向文件中写入字符串str，注意此方法不会在写入完毕之后自动换行。
（5）void writer(String str,int off,int len)：向文件中写入字符串str的从位置off开始、长度为len的一部分子串。
（6）Writer append(char c)：向文件中追加单个字符c。
（7）Writer append(CharSequence csq)：向文件中追加csq代表的一个字符序列。CharSequence是从JDK1.4版本开始引入的一个接口，代表字符值的一个可读序列，此接口对许多不同种类的字符序列提供统一的只读访问。
（8）Writer append(CharSequence csq,int start,int end)：向文件中追加csq字符序列的从位置start开始、end结束的一部分字符。
（9）void flush()：刷新字符输出流缓冲区。
（10）void close()：关闭字符输出流。
BufferedWriter也拥有如下两种形式的构造方法：
（1）BufferedWriter(Writer out): 根据out代表的Writer对象创建BufferedWriter实例，缓冲区大小采用默认值。
（2）BufferedWriter(Writer out,int sz):根据out代表的Writer对象创建BufferedWriter实例，缓冲区大小采用指定的sz值。
BufferedWriter的常用方法包括以下几种：
（1）void close() ：关闭字符输出流。
（2）void flush() ：刷新字符输出流缓冲区。
（3）void newLine()： 写入文本行。
（4）void write(char[] cbuf, int offset, int count) ：向文件中写入字符数组cbuf从偏移位置off开始的len个字符。
（5）void write(int oneChar) ：写入单个字符。
（6）void write(String str, int offset, int count) ：向文件中写入字符串str的从位置off开始、长度为len的一部分子串。
（7）以上的方法都是重写了Writer的，还有继承自java.io.Writer 的方法：Writer append(char c)、Writer append(CharSequence csq)、Writer append(CharSequence csq, int start, int end)、void write(char[] cbuf)、write(String str)等方法。
代码实例：
package java_io;import java.io.BufferedWriter;import java.io.File;import java.io.FileNotFoundException;import java.io.FileWriter;import java.io.IOException;public class TestWriter { public static void main(String[] args) { TestWriter testWriter = new TestWriter(); String path = "C:\\Users\\luoguohui\\Desktop\\readerTest.txt"; testWriter.writeFileByFileWriter(path); testWriter.writeFileByBufferWriter(path); } public void writeFileByFileWriter(String path){ FileWriter fileWriter = null; try { fileWriter = new FileWriter(path,true); //将字符串写入到流中，\r\n表示换行 //因为fileWriter不会自动换行 fileWriter.write("本行是通过fileWriter加入的行\r\n"); //如果想马上看到写入效果，则需要调用w.flush()方法 fileWriter.flush(); } catch (IOException e) { e.printStackTrace(); } finally { if(fileWriter != null) { try { fileWriter.close(); } catch (IOException e) { e.printStackTrace(); } } } } public void writeFileByBufferWriter(String path){ File file = new File(path); if (file.isFile()) { BufferedWriter bufferedWriter = null; FileWriter fileWriter = null; try { fileWriter = new FileWriter(file,true); bufferedWriter = new BufferedWriter(fileWriter); bufferedWriter.write("本行是通过bufferedWriter加入的行\r\n"); bufferedWriter.flush(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { try { fileWriter.close(); bufferedWriter.close(); } catch (IOException e) { e.printStackTrace(); } } } } }- 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
- 59
- 60
- 61
- 62
- 63
- 64
我们先把readerTest.txt文件的内容清空，运行结果如下（不清空也行，只是运行结果博主的不一样）：
三、字节流实例
3.1、实例之前
再次声明之前提到过的“只要是处理纯文本数据，就要优先考虑使用字符流，除此之外都用字节流”。
这里博主贴出字节流类图结构，方便猿友阅读：
下面我们依旧以文件读写为例。
3.2、FileInputStream的使用
FileInputStream的构造方法：
（1）FileInputStream(File file) ：通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
（2）FileInputStream(FileDescriptor fdObj) ：通过使用文件描述符 fdObj 创建一个 FileInputStream，该文件描述符表示到文件系统中某个实际文件的现有连接。
（3）FileInputStream(String name) 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。
FileInputStream的常用方法：
（1）int available()：返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。
（2）void close()：关闭此文件输入流并释放与此流有关的所有系统资源。
（3）protected void finalize()：确保在不再引用文件输入流时调用其 close 方法。
（4）FileChannel getChannel()：返回与此文件输入流有关的唯一 FileChannel 对象。
（5）FileDescriptor getFD()：返回表示到文件系统中实际文件的连接的 FileDescriptor 对象，该文件系统正被此 FileInputStream 使用。
（6）int read()：从此输入流中读取一个数据字节。
（7）int read(byte[] b)：从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
（8）int read(byte[] b, int off, int len)：从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
（9）long skip(long n)：从输入流中跳过并丢弃 n 个字节的数据。
代码实例：
package java_io;import java.io.FileInputStream;import java.io.IOException;public class TestFileInputStream { public static void main(String[] args) { TestFileInputStream testFileInputStream = new TestFileInputStream(); String path = "C:\\Users\\luoguohui\\Desktop\\readerTest.txt"; testFileInputStream.readFileByFileInputStream(path); } public void readFileByFileInputStream(String path) { FileInputStream fileInputStream = null; try { // 创建文件输入流对象 fileInputStream = new FileInputStream(path); // 设定读取的字节数 int n = 1024; byte buffer[] = new byte[1024]; // 读取输入流 System.out.println("readFileByFileInputStream执行结果："); while ((fileInputStream.read(buffer, 0, n) != -1) && (n > 0)) { System.out.print(new String(buffer)); } System.out.println(); } catch (IOException ioe) { ioe.printStackTrace(); } catch (Exception e) { e.printStackTrace(); } finally { // 关闭输入流 if (fileInputStream != null) { try { fileInputStream.close(); } catch (IOException e) { e.printStackTrace(); } } } }}- 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
readerTest.txt内容：
运行结果：
3.3、FileOutputStream 的使用
FileOutputStream的构造方法：
（1）FileOutputStream(File file) ：创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
（2）FileOutputStream(File file, boolean append) ：创建一个向指定 File 对象表示的文件中写入数据的文件输出流。append参数用来指定是否在原文件之后追加内容。
（3）FileOutputStream(FileDescriptor fdObj) ：创建一个向指定文件描述符处写入数据的输出文件流，该文件描述符表示一个到文件系统中的某个实际文件的现有连接。
（4）FileOutputStream(String name) ：创建一个向具有指定名称的文件中写入数据的输出文件流。
（5）FileOutputStream(String name, boolean append) ： 创建一个向具有指定 name 的文件中写入数据的输出文件流。append参数用来指定是否在原文件之后追加内容。
FileOutputStream的常用方法：
（1）void close() ：关闭此输出流并释放与此流有关的所有系统资源。
（2）void flush() ：刷新此输出流并强制写出所有缓冲的输出字节。
（3）void write(byte[] b) ：将 b.length 个字节从指定的字节数组写入此输出流。
（4）void write(byte[] b, int off, int len) ：将指定字节数组中从偏移量 off 开始的 len 个字节写入此输出流。
（6）abstract void write(int b) ：将指定的字节写入此输出流。
代码实例：
package java_io;import java.io.FileOutputStream;public class TestFileOutputStream { public static void main(String[] args) { TestFileOutputStream testFileOutputStream = new TestFileOutputStream(); String path = "C:\\Users\\luoguohui\\Desktop\\readerTest.txt"; testFileOutputStream.readFileByFileOutputStream(path); } public void readFileByFileOutputStream(String path) { FileOutputStream fos = null; try { fos = new FileOutputStream(path,true); String str = "这是使用FileOutputStream添加的内容\r\n"; byte[] b = str.getBytes(); fos.write(b); fos.flush(); } catch (Exception e) { e.printStackTrace(); } finally { try { fos.close(); } catch (Exception e2) { e2.printStackTrace(); } } }}- 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
运行结果：
- Java I/O学习（附实例和详解）
- Java I/O学习（附实例和详解）
- Java I/O学习（附实例和详解）
- Java I/O学习（附实例和详解）
- Java I/O学习（附实例和详解）
- 【Java学习笔记】I/O实例
- I/O实例 java
- Java I/O 详解
- java i/o 详解
- Java I/O详解
- Java I/O 详解
- Java I/O 详解
- Java I/O 详解
- Java I/O详解
- java I/O详解
- Java I/O 详解
- Java I/O 学习
- java I/O学习
- C语言再学习之：指针详解（2）
- python高效编程技巧1 (如何在列表，字典，集合中根据条件筛选数据)
- Javascript中JSON操作总结
- 实验四 栈和队列的定义与实现（未完成）
- Mark几个网址
- Java I/O学习（附实例和详解）
- qmake用户手册
- Codeforces Round #433 (Div. 2)
- JZOJ 5404. 【NOIP2017提高A组模拟10.10】Graph
- 文章标题
- 九度OJ——1012畅通工程
- tensorflow学习笔记（一）
- greenplum创建表，修改表语句
- oracle中sqldeveloper的使用和unable to find a java virtual machine
