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;