java io常用类总结

大家好，又见面了，我是你们的朋友全栈君。

读写数据是java开发过程中经常需要做的，本篇文章将我们平时常用的java io处理类做个总结，同时给出相关demo。

java io常用类总结

可以看得出来，JAVA IO主要有这四个类InputStream、OutputStream、Reader、Writer来处理，要处理字节流的就用InputStream、OutputStream，要处理字符流，就用Reader、Writer，现实中根据需要，我们选择他们的相关子类进行数据的读写。给出类图：

java io常用类总结

根据处理媒介的不同进行划分

java io常用类总结

下面给出常用的IO处理demo

/**

* 项目名称(中文)

* 项目名称(英文)

package com.figo.study.test;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.DataInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.InputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.OutputStream;

import java.io.Reader;

import java.io.Serializable;

import java.io.StringWriter;

import java.io.Writer;

/**

* IO操作总结 IO按读写划分可以分为输入流和输出流 IO，

* 按处理媒介来划分可以分为字节流和字符流

* 另外为了处理不同的数据类型，输入输出流可以层层包装

* 比如处理文件数据的FileInputStream,FileOutputStream.

* 另外处理网络的IO一般使用Socket，jdk1.4及以上版本又推出了NIO， NIO non-blocking

* io非阻塞的开源项目比如MINA,NETTY，本demo讨论io

* @author figo

* @version 1.0 2018-6-12 改订

* @since 1.0

public class TestIO {

/**

* .

* @param args

public static void main(String[] args) {

// testInputStreamAndOutputStream();

// testReaderAndWriter();

// testBufferReaderAndWriter();

testObjectInputStreamAndObjectOutputStream();

}

/**

* 字节流输入FileInputStream输出FileOutputStream 文件超大有可能会OOM

public static void testInputStreamAndOutputStream() {

try {

// 写入数据

String hello = new String(“hello world!”);

byte[] byteArray = hello.getBytes();

File file = new File(“E:\\学习资料\\java学习\\testIO\\iostream.txt”);

// 因为是用字节流来写媒介，所以对应的是OutputStream

// 又因为媒介对象是文件，所以用到子类是FileOutputStream

OutputStream os = new FileOutputStream(file);

os.write(byteArray);

os.close();

// 读取数据

byte[] byteArrayNew = new byte[(int) file.length()];

// 因为是用字节流来读媒介，所以对应的是InputStream

// 又因为媒介对象是文件，所以用到子类是FileInputStream

InputStream is = new FileInputStream(file);

int size = is.read(byteArrayNew);

System.out.println(“大小:” + size + “;内容:” + new String(byteArray));

is.close();

} catch (Exception ex) {

ex.printStackTrace();

}

/**

* 字符流输入FileReader输出FileWriter 文件超大有可能会OOM

public static void testReaderAndWriter() {

try {

// 写入数据

String hello = new String(“hello worLd!”);

File file = new File(

“E:\\学习资料\\java学习\\testIO\\readerAndwriter.txt”);

// 因为是用字符流来读媒介，所以对应的是Writer，又因为媒介对象是文件，所以用到子类是FileWriter

Writer os = new FileWriter(file);

os.write(hello);

os.close();

// 读取数据

// 因为是用字符流来读媒介，所以对应的是Reader

// 又因为媒介对象是文件，所以用到子类是FileReader

Reader reader = new FileReader(file);

char[] byteArray = new char[(int) file.length()];

int size = reader.read(byteArray);

System.out.println(“大小:” + size + “;内容:” + new String(byteArray));

reader.close();

} catch (Exception ex) {

ex.printStackTrace();

}

/**

* 缓存字符输入BufferedReader和输出BufferedWriter 缓存一定大小字符流后再一次性输入输出

* 每次一个字符一个字符的读写肯定影响性能的每次读写缓存大小的数据量，一般不会OOM，批量读写明显会提高效率

public static void testBufferReaderAndWriter() {

try {

// 写入数据

String hello = new String(“hello worLd!”);

File file = new File(

“E:\\学习资料\\java学习\\testIO\\bufferReaderAndWriter.txt”);

// 因为是用字符流来读媒介，所以对应的是Writer，又因为媒介对象是文件，所以用到子类是FileWriter

Writer os = new FileWriter(file);

// 外部再包装一层buffer 不设置缓冲大小，默认8k，也可以自己通过这个构造函数指定

// BufferedWriter(Writer paramWriter, int paramInt)

BufferedWriter bw = new BufferedWriter(os);

bw.write(hello);

// 写一行换一行

bw.newLine();

bw.close();

os.close();

// 读取数据

// 因为是用字符流来读媒介，所以对应的是Reader

// 又因为媒介对象是文件，所以用到子类是FileReader

Reader reader = new FileReader(file);

// 外部再包装一层buffer 不设置缓冲大小，默认8k，也可以自己通过这个构造函数指定

// BufferedReader(Reader paramReader, int paramInt)

BufferedReader bufferReader = new BufferedReader(reader);

String tempString = null;

while ((tempString = bufferReader.readLine()) != null) {

// 显示行号

System.out.println(tempString);

}

bufferReader.close();

reader.close();

} catch (Exception ex) {

ex.printStackTrace();

}

/**

* 对象读写到文件ObjectInputStream和ObjectOutputStream .

public static void testObjectInputStreamAndObjectOutputStream() {

try {

//定义一个对象

Student student=new Student();

student.setName(“abc”);

student.setSex(“男”);

student.setGrade(“一年级”);

student.setAddress(“上海”);

student.setMobile(“15812345678”);

//对象写入文件

FileOutputStream fos=new FileOutputStream(“E:\\学习资料\\java学习\\testIO\\Student.txt”);

ObjectOutputStream oos=new ObjectOutputStream(fos);

oos.writeObject(student);

oos.flush();

oos.close();

//从文件读取对象

FileInputStream fis=new FileInputStream(“E:\\学习资料\\java学习\\testIO\\Student.txt”);

ObjectInputStream ois=new ObjectInputStream(fis);

Student studentNew=(Student)ois.readObject();

System.out.println(studentNew.toString());

} catch (Exception ex) {

ex.printStackTrace();

}

/**

* 一定记得实现Serializable，否则无法序列化成字节流

* @author figo

* .

public static class Student implements Serializable{

/**

* .

private static final long serialVersionUID = 1L;

String name;

String sex;

String grade;

String address;

String mobile;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getSex() {

return sex;

}

public void setSex(String sex) {

this.sex = sex;

}

public String getGrade() {

return grade;

}

public void setGrade(String grade) {

this.grade = grade;

}

public String getAddress() {

return address;

}

public void setAddress(String address) {

this.address = address;

}

public String getMobile() {

return mobile;

}

public void setMobile(String mobile) {

this.mobile = mobile;

}

@Override

public String toString() {

return “Student [name=” + name + “, sex=” + sex + “, grade=”

+ grade + “, address=” + address + “, mobile=” + mobile

+ “]”;

}

/**
*
* 字符转字节流InputStreamReader和OutputStreamWriter .
* 这两个类的好处是可以指定读取和写入的字符编码
*/
public static void testInputStreamReaderAndOutputStreamWriter() {

try {

//写文件
String filePathAndName = “E:\\学习资料\\java学习\\testIO\\InputStreamReaderWriter.txt”;
File fileWrite = new File(filePathAndName);
if (!fileWrite.exists()) {

fileWrite.createNewFile();
}
OutputStreamWriter write = new OutputStreamWriter(new FileOutputStream(fileWrite), “UTF-8”);
BufferedWriter writer = new BufferedWriter(write);
String fileContent = “hello,world，你好世界！”;
writer.write(fileContent);
writer.close();
//读文件
File fileRead = new File(filePathAndName);
if (fileRead.isFile() && fileRead.exists()) {

InputStreamReader read = new InputStreamReader(
new FileInputStream(fileRead), “UTF-8”);
BufferedReader reader = new BufferedReader(read);
String line;
StringBuffer sringBuffer=new StringBuffer();
while ((line = reader.readLine()) != null) {

//这样也可以指定编码，但是会new很多的String对象
// String newLine=new String(line.getBytes(“UTF-8”));
sringBuffer.append(line);
}
System.out.println(fileContent);
read.close();
}