IO流（1）

Java IO操作_1

 

知识点

1、讲解Java IO包中的各个字节操作类
2、File类的使用及注意
3、字节操作流：OutputStream、InputStream
4、字符操作流：Reader、Writer
5、对象序列化：Serializable

 

File类

 

基本概念

java.io.File类的定义如下：
public class File
extends Object
implements Serializable, Comparable<File>

 

操作方法和常量：

 

No.
方法或常量名称
类型
描述
1
public static final String separator
常量
表示路径分隔符“\”
2
public static final String pathSeparator
常量
表示路径分隔，表示“;”
3
public File(String pathname)
构造
构造File类实例，要传入路径
4
public boolean createNewFile() throws IOException
普通
创建新文件
5
public boolean delete()
普通
删除文件

6
public String getParent()
普通
得到文件的上一级路径
7
public boolean isDirectory()
普通
判断给定的路径是否是文件夹
8
public boolean isFile()
普通
判断给定的路径是否是文件
9
public String[] list()
普通
列出文件夹中的文件
10
public File[] listFiles()
普通
列出文件夹中的所有文件
11
public boolean mkdir()
普通
创建新的文件夹
12
public boolean renameTo(File dest)
普通
为文件重命名
13
public long length()
普通
返回文件大小

 

创建文件

使用createNewFile()方法完成

package org.iodemo.filedemo;
import java.io.File;
import java.io.IOException;
public class FileDemo01 {
public static void main(String[] args) {
File file = new File("d:\\test.txt");
try {
file.createNewFile(); // 创建文件
} catch (IOException e) {
e.printStackTrace();
}
}
}

 

删除文件

使用delete()方法进行文件的删除操作。

package org.iodemo.filedemo;
import java.io.File;
public class FileDemo03 {
public static void main(String[] args) {
File file = new File("d:" + File.separator + "test.txt");
file.delete();// 删除文件
}
}

 

判断类型

 

package org.iodemo.filedemo;
import java.io.File;
public class FileDemo06 {
public static void main(String[] args) {
File file1 = new File("d:" + File.separator + "test.txt"); // 文件路径
File file2 = new File("d:"); // 文件夹路径
System.out.println(file1.isFile());
System.out.println(file2.isDirectory());
System.out.println("文件大小：" + file1.length());
System.out.println("文件路径：" + file1.getPath());
System.out.println("文件路径：" + file1);
}
}

 

列出目录的内容

使用list()方法

package org.iodemo.filedemo;
import java.io.File;
public class FileDemo07 {
public static void main(String[] args) {
File file = new File("d:" + File.separator); // 文件夹路径
String str[] = file.list(); // 列出目录内容
for (int x = 0; x < str.length; x++) {
System.out.println(str[x]);
}
}
}

 

使用listFiles()方法

public class FileDemo08 {
public static void main(String[] args) {
File file = new File("d:" + File.separator); // 文件夹路径
File files[] = file.listFiles(); // 列出
for (int x = 0; x < files.length; x++) {
System.out.println(files[x]);
}
}
}

 

输入和输出流

输入和输出分为两种类型，一种称为字节流，另外一种称为字符流

· 字节流：主要是操作字节数据（byte），分为OutputStream，字节输出流、InputStream，字节输入流
· 字符流：主要是操作字符数据（char），分为Writer，字符输出流，Reader，字符输入流
但是，不管使用那种操作，字节流和字符流的操作都是采用如下的步骤完成：
1、找到一个要操作的资源，可能是文件，可能是其他的位置
2、根据字节流或字符流的子类，决定输入及输出的位置
3、进行读或写的操作
4、关闭

 

字节输出流：OutputStream

此类是一个抽象类实现了Closeable和Fluashable接口。此类的常用方法如下所示：
No.
方法名称
类型
描述
1
public void close() throws IOException
普通
关闭
2
public void flush() throws IOException
普通
刷新操作
3
public void write(byte[] b) throws IOException
普通
将一组字节写入到输出流之中
4
public void write(byte[] b,int off,int len) throws IOException
普通
将指定范围的字节数组进行输出
5
public abstract void write(int b) throws IOException
普通
每次写入一个字节，byte  int

 

此类的构造方法如下：
No.
方法名称
类型
描述
1
public FileOutputStream(File file) throws FileNotFoundException
构造
接收File类的实例，表示要操作的文件位置。
2
public FileOutputStream(File file,boolean append) throws FileNotFoundException
构造
接收File类实例，并指定是否可以追加

 

范例：向文件中输出“Hello World!!!”

 

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class OutputStreamDemo01 {
public static void main(String[] args) {
File file = new File("D:" + File.separator + "test.txt"); // 指定要操作的文件
OutputStream out = null; // 定义字节输出流对象
try {
out = new FileOutputStream(file); // 实例化操作的父类对象
} catch (FileNotFoundException e) {
e.printStackTrace();
}
String info = "Hello World";// 要打印的信息
byte b[] = info.getBytes(); // 将字符串变为字节数组
try {
out.write(b);// 输出内容
} catch (IOException e) {
e.printStackTrace();
}
try {
out.close(); // 关闭
} catch (IOException e) {
e.printStackTrace();
}
}
}

 

字节输入流：InputStream

本类也是一个抽象类，本类中的常用操作方法如下：
No.
方法名称
类型
描述
1
public void close() throws IOException
普通
关闭
2
public abstract int read() throws IOException
普通
读取每一个字节
3
public int read(byte[] b) throws IOException
普通
向字节数组中读取，同时返回读取的个数
4
public int read(byte[] b,int off,int len) throws IOException
普通
指定读取的范围

 

InputStream类本身属于抽象类，肯定需要子类支持，子类从文件中读取肯定是FileInputStream。
No.
方法名称
类型
描述
1
public FileInputStream(File file) throws FileNotFoundException
构造
通过File类实例，创建文件输入流

 

范例：从文件之中读取出内容

package org.iodemo.fileinputstreamdemo;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
public class InputStreamDemo01 {
public static void main(String[] args) {
File file = new File("D:" + File.separator + "test.txt");// 要读取的文件路径
InputStream input = null; // 字节输入流

第（10）页 共（23）页
try {
input = new FileInputStream(file);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
byte[] b = new byte[1024];// 开辟byte数组空间，读取内容
int len = 0;
try {
len = input.read(b); // 读取
} catch (IOException e) {
e.printStackTrace();
}
try {
input.close();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println(new String(b, 0, len));
}
}

 

字符输出流：Writer

此类也是个抽象类，此类的常用方法如下：
No.
方法名称
类型
描述
1
public void write(String str) throws IOException
普通
直接将字符串写入输出
2
public void write(char[] cbuf) throws IOException
普通
输出字符数组
3
public abstract void close() throws IOException
普通
关闭
4
public abstract void flush() throws IOException
普通
刷新

 

与OutputStream一样，使用FileWriter类完成操作，此类的构造方法如下：
No.
方法名称
类型
描述
1
public FileWriter(File file) throws IOException
构造
根据File类构造FileWriter实例
2
public FileWriter(File file,boolean append) throws IOException
构造
根据File类构造FileWriter实例，可以追加内容

 

范例：使用Writer完成文件内容的输出

package org.iodemo.filewriterdemo;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class WriterDemo01 {
public static void main(String[] args) throws Exception { // 所有异常抛出
File file = new File("D:" + File.separator + "test.txt"); // 指定要操作的文件
Writer out = null; // 定义字节输出流对象
out = new FileWriter(file); // 实例化操作的父类对象
String info = "Hello World!!!";// 要打印的信息
out.write(info);// 输出内容
out.close(); // 关闭
}
}

 

字符输入流：Reader

 

此类还是抽象类，此类的方法如下：
No.
方法名称
类型
描述
1
public int read() throws IOException
普通
读取一个内容
2
public int read(char[] cbuf) throws IOException
普通
读取一组内容，返回读入的大小

3
public abstract void close() throws IOException
普通
关闭

 

此类，依然需要使用FileReader类进行实例化操作，FileReader类中的构造方法定义如下：
No.
方法名称
类型
描述
1
public FileReader(File file) throws FileNotFoundException
构造
接收File类的实例

 

范例：使用Reader进行文件的读取操作

package org.iodemo.filereaderdemo;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class ReaderDemo01 {
public static void main(String[] args) throws Exception {
File file = new File("D:" + File.separator + "test.txt");// 要读取的文件路径
Reader input = null; // 字节输入流
input = new FileReader(file);
char b[] = new char[1024];// 开辟char数组空间，读取内容
int len = input.read(b); // 读取
input.close();
System.out.println(new String(b, 0, len));
}
}

 

字节流和字符流的区别

 

区别：字节流没有使用到缓冲区，而是直接操作输出的，而字符流使用到了缓冲区，是通过缓冲区操作输出的。

字节流以字节作为操作单位，字符流以字符作为操作单位。

· 明显使用字节流操作会方便一些，例如：图片、电影都是字节保存的。

 

字节-字符转换流

· OutputStreamWriter：可以将输出的字符流变为字节流的输出形式
· InputStreamReader：将输入的字节流变为字符流输入形式

 

使用OutputStreamWriter完成一个字符-字节的转换操作：

package org.iodemo.outputinputdemo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
public class OutputStreamWriterDemo {
public static void main(String[] args) throws Exception {
File file = new File("D:" + File.separator + "temp.txt");

// 通过转换类，将字符输出流变为字节输出流
Writer out = new OutputStreamWriter(new FileOutputStream(file));
out.write("Hello World!!!");
out.close();
}
}

 

InputStreamReader是Reader的子类，可以将字节的输入流变为字符输入流。

package org.iodemo.outputinputdemo;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.io.Reader;
public class InputStreamReaderDemo {
public static void main(String[] args) throws Exception {
File file = new File("D:" + File.separator + "temp.txt");
Reader input = new InputStreamReader(new FileInputStream(file));
char c[] = new char[100];
int len = input.read(c);// 读取数据
System.out.println(new String(c, 0, len));
input.close();
}
}

 

打印流：PrintStream

· 字节打印流：PrintStream
· 字符打印流：PrintWriter

 

PrintStream本身也属于OutputStream的子类。但是继续观察PrintStream类中的一些方法。
No.
方法名称
类型
描述
1
public PrintStream(OutputStream out)
构造
接收OutputStream类的实例。
2
public PrintStream(File file) throws FileNotFoundException
构造
接收File类实例，向文件中输出
3
public PrintStream format(String format, Object... args)
普通
表示格式化输出
4
public void print(数据类型f)
普通
打印输出，不换行
5
public PrintStream printf(String format,Object... args)
普通
格式化输出
6
public void println(数据类型f)
普通
打印输出，换行

 

使用PrintStream完成输出

 

package org.iodemo.printstreamdemo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.PrintStream;
public class PrintStreamDemo01 {
public static void main(String[] args) throws Exception {
File file = new File("D:" + File.separator + "temp.txt");
OutputStream output = new FileOutputStream(file);
PrintStream out = new PrintStream(output);
out.print("hello");
out.print(" world ");
out.println("!!!");
out.print("1 X 1 = " + (1 * 1));
out.println("\n输出完毕");
out.close();
}
}

 

如果要想进行格式化的操作，则必须指定格式化的操作模板，模板的指定如下：
No.
模板标记
描述
1
%s
表示字符串
2
%d
表示整数
3
%n.mf
表示小数，一共的数字长度是n，其中小数是m位
4
%c
表示字符

 

进行格式化输出：

package org.iodemo.printstreamdemo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.PrintStream;
public class PrintStreamDemo02 {
public static void main(String[] args) throws Exception {
String name = "张三";
float salary = 800.897f;
int age = 10;
PrintStream out = new PrintStream(new FileOutputStream(new File("d:"
+ File.separator + "temp.txt")));
out.printf("姓名：%s，年龄：%d，工资：%7.2f。", name, age, salary);

out.close();
}
}

以上的操作基本上全部的模板都可以使用“%s”代替。
out.printf("姓名：%s，年龄：%s，工资：%s。", name, age, salary);

 

对象序列化

 

基本概念

对象序列化就是指将一个对象转化成二进制的byte流。以将对象保存在文件上为例。
· 将对象保存在文件上的操作称为对象的序列化操作
· 将对象从文件之中恢复称为反序列化的操作

 

Serializable接口

范例：定义Person类，此类可以被序列化

package org.iodemo.serdemo;
import java.io.Serializable;
public class Person implements Serializable {
/**
* 此常量表示的是一个序列化的版本编号，为的是可以在不同的JDK 版本间进行移植
*/
private static final long serialVersionUID = 1L;
private String name;
private int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}

public String getName() {
return name;

}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "姓名：" + this.name + "；年龄：" + this.age;
}
}

 

进行序列化操作：ObjectOutputStream

 

ObjectOutputStream专门用于对象的输出操作，此类的常用方法如下：
No.
方法名称
类型
描述
1
public ObjectOutputStream(OutputStream out) throws IOException
构造
接收OutputStream实例，进行实例化操作
2
public final void writeObject(Object obj) throws IOException
普通
输出一个对象
3
public void close() throws IOException
普通
关闭

 

范例：将Person的对象保存在文件之中

package org.iodemo.serdemo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
public class ObjectOutputStreamDemo {
public static void main(String[] args) throws Exception { // 所有异常抛出
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
new File("D:" + File.separator + "person.ser")));
Person per = new Person("张三", 30);
oos.writeObject(per);// 输出
oos.close();// 关闭
}
}

 

进行反序列化操作：ObjectInputStream

使用ObjectInputStream可以完成对象的反序列化操作。此类的常用方法如下：
No.
方法名称
类型
描述
1
public ObjectInputStream(InputStream in) throws IOException
构造
根据输入流的不同，实例哈ObjectInputStream类的对象
2
public final Object readObject() throws IOException,ClassNotFoundException
普通
读取对象

 

范例：进行对象的反序列化操作

package org.iodemo.serdemo;
import java.io.File;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class ObjectInputStreamDemo {
public static void main(String[] args) throws Exception { // 所有异常抛出
ObjectInputStream oos = new ObjectInputStream(new FileInputStream(
new File("D:" + File.separator + "person.ser")));
Person p = (Person)oos.readObject() ;
System.out.println(p);
}
}

 

序列化一组对象

采用对象数组的形式，因为对象数组可以向Object进行转型操作。

package org.iodemo.serdemo;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class SerArrayObjectDemo {
public static void main(String[] args) throws Exception {
Person per[] = { new Person("张三", 30), new Person("李四", 35),
new Person("王五", 50) };
ser(per); // 序列化一组对象
Person p[] = (Person[]) dser(); // 反序列化
for (int x = 0; x < p.length; x++) {
System.out.println(p[x]) ;
}
}
public static void ser(Object obj) throws Exception { // 所有异常抛出
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
new File("D:" + File.separator + "person.ser")));
oos.writeObject(obj);// 输出
oos.close();// 关闭
}
public static Object dser() throws Exception { // 所有异常抛出
ObjectInputStream oos = new ObjectInputStream(new FileInputStream(
new File("D:" + File.separator + "person.ser")));
Object obj = oos.readObject();
return obj;
}
}

transient关键字

 

对象中的某个属性不希望被序列化，则此时就可以使用transient关键字进行声明。
private transient String name;
private transient int age;