java.io.File类的使用
IO原理及流的分类
文件流
FileInputStream / FileOutputStream / FileReader / FileWriter
缓冲流
BufferedInputStream / BufferedOutputStream /
BufferedReader / BufferedWriter
转换流
InputStreamReader / OutputStreamWriter
标准输入/输出流
打印流（了解） System.out.println
PrintStream / PrintWriter
数据流（了解）
DataInputStream / DataOutputStream
对象流 ----涉及序列化、反序列化
ObjectInputStream / ObjectOutputStream
随机存取文件流
RandomAccessFile
File 类
java.io.File类：文件和目录路径名的抽象表示形式，与平台无关
File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。
File对象可以作为参数传递给流的构造函数
File类的常见构造方法：
public File(String pathname)
以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
public File(String parent,String child)
以parent为父路径，child为子路径创建File对象。
File的静态属性String separator存储了当前系统的路径分隔符。
在UNIX中，此字段为‘/’，在Windows中，为‘\’
File 类代表与平台无关的文件和目录。
File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。
Java IO原理
iO流用来处理设备之间的数据传输。
Java程序中，对于数据的输入/输出操作以”流(stream)” 的方式进行。
java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。
输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中
文件字符输入流
读取文件操作步骤:
1.建立一个流对象，将已存在的一个文件加载进流。
FileReader fr = new FileReader(“Test.txt”);
2.创建一个临时存放数据的数组。
char[] ch = new char[1024];
3.调用流对象的读取方法将流中的数据读入到数组中。
fr.read(ch);
文件字符输出流
1.创建流对象，建立数据存放文件
FileWriter fw = new FileWriter(“Test.txt”);
2.调用流对象的写入方法，将数据写入流
fw.write(“text”);
2.1 输出流关闭之前需要清空缓存
fw.flush();
3.关闭流资源，并将流中的数据清空到文件中。
fw.close();
注意
定义文件路径时，注意：可以用“/”或者“\\”。
在写入一个文件时，如果目录下有同名文件将被覆盖。
在读取文件时，必须保证该文件已存在，否则出异常
缓冲流
为了提高数据读写的速度，Java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组
根据数据操作单位可以把缓冲流分为：
BufferedInputStream 和 BufferedOutputStream
BufferedReader 和 BufferedWriter
缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法
对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush()将会使内存中的数据立刻写出
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
/**
* 缓冲字节流
* @author lby
*
*/
public class Test {
public static void main(String[] args) {
try {
// Test.testBufferedInputStream();
// Test.testBufferedOutputStream();
Test.copyFile();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 缓冲字节输入流
* BufferedInputStream
* @throws Exception
*/
public static void testBufferedInputStream() throws Exception{
//文件字节输入流对象
FileInputStream in = new FileInputStream("D:\\testdemo\\demo\\src\\day13\\tt.txt");
//把文件字节输入流放到缓冲字节输入流对象
BufferedInputStream br = new BufferedInputStream(in);
byte[] b = new byte[10];
int len = 0;
while((len = br.read(b)) != -1){
System.out.println(new String(b,0,len));
}
//关闭流的时候，本着一个最晚开的最早关，依次关
br.close();
in.close();
}
/**
* 缓冲字节输出流
* BufferedOutputStream
*/
public static void testBufferedOutputStream() throws Exception{
//创建字节输出流对象
FileOutputStream out = new FileOutputStream("D:\\testdemo\\demo\\src\\day13\\tt1.txt");
//把字节输出流对象放到缓冲字节输出流中
BufferedOutputStream bo = new BufferedOutputStream(out);
String s = "hello world";
bo.write(s.getBytes());//写到内存中
bo.flush();//刷到硬盘上
//关闭流的时候，本着一个最晚开的最早关，依次关
bo.close();
out.close();
}
/**
* 缓冲流实现文件的复制
*/
public static void copyFile() throws Exception{
//缓冲输入流
BufferedInputStream br = new BufferedInputStream(new FileInputStream("D:\\testdemo\\demo\\src\\day13\\tt1.txt"));
//缓冲输出流
BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream("D:\\testdemo\\demo\\src\\day13\\tt2.txt"));
byte[] b = new byte[1024];
int len = 0;//设置一个没出读取到的数据的长度，直到br.read方法执行到最后（比如说文件中只有hello world，执行到最后一个就读取d的后面，这个时候返回值就是-1）
while((len = br.read(b)) != -1){
bo.write(b, 0, len);//写到内存
}
bo.flush();//刷到硬盘
bo.close();
br.close();
}
}
转换流
转换流提供了在字节流和字符流之间的转换
Java API提供了两个转换流：
InputStreamReader和OutputStreamWriter
字节流中的数据都是字符时，转成字符流操作更高效。
InputStreamReader
用于将字节流中读取到的字节按指定字符集解码成字符。需要和 InputStream“套接”。
构造方法
InputStreamReader(InputStream in)
public InputSreamReader(InputStream in,String charsetName)
如： Reader isr = new InputStreamReader(System.in,”ISO5334_1”);
OutputStreamWriter
用于将要写入到字节流中的字符按指定字符集编码成字节。 需要和OutputStream“套接”。
构造方法
public OutputStreamWriter(OutputStream out)
public OutputSreamWriter(OutputStream out,String charsetName)
标准输入输出流
System.in和System.out分别代表了系统标准的输入和输出设备
默认输入设备是键盘，输出设备是显示器
System.in的类型是InputStream
System.out的类型是PrintStream，其是OutputStream的子类FilterOutputStream 的子类
通过System类的setIn，setOut方法对默认设备进行改变。
public static void setIn(InputStream in)
public static void setOut(PrintStream out)
打印流
在整个IO包中，打印流是输出信息最方便的类。
PrintStream(字节打印流)和PrintWriter(字符打印流)提供了一系列重载的print和println方法，用于多种数据类型的输出
PrintStream和PrintWriter的输出不会抛出异常
PrintStream和PrintWriter有自动flush功能
System.out返回的是PrintStream的实例
数据流（了解）
为了方便地操作Java语言的基本数据类型的数据，可以使用数据流。
数据流有两个类：(用于读取和写出基本数据类型的数据）
DataInputStream 和 DataOutputStream
分别“套接”在 InputStream 和 OutputStream 节点流上
DataInputStream中的方法
boolean readBoolean() byte readByte()
char readChar() float readFloat()
double readDouble() short readShort()
long readLong() int readInt()
String readUTF() void readFully(byte[] b)
DataOutputStream中的方法
将上述的方法的read改为相应的write即可。
对象流
ObjectInputStream和OjbectOutputSteam
用于存储和读取对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
序列化(Serialize)：用ObjectOutputStream类将一个Java对象写入IO流中
反序列化(Deserialize)：用ObjectInputStream类从IO流中恢复该Java对象
ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
对象的序列化
若某个类实现了 Serializable 接口，该类的对象就是可序列化的：
创建一个 ObjectOutputStream
调用 ObjectOutputStream 对象的 writeObject(对象) 方法输出可序列化对象。注意写出一次，操作flush()
反序列化
创建一个 ObjectInputStream
调用 readObject() 方法读取流中的对象
强调：如果某个类的字段不是基本数据类型或 String 类型，而是另一个引用类型，那么这个引用类型必须是可序列化的，否则拥有该类型的 Field 的类也不能序列化
public class Test5 {
public static void main(String[] args) {
try {
// Test5.testSerialize();
Test5.testDeserialize();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 对象的序列化
*/
public static void testSerialize() throws Exception{
//定义对象的输出流，把对象的序列化之后的流放到指定的文件中
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("D:/testdemo/demo/src/day13/tt9.txt"));
Person p = new Person();
p.name = "zhangsan";
p.age = 11;
out.writeObject(p);
out.flush();//刷写数据到硬盘
out.close();
}
/**
* 对象的反序列化
*/
public static void testDeserialize() throws Exception{
//创建对象输入流对象，从指定的文件中把对象序列化后的流读取出来
ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:/testdemo/demo/src/day13/tt9.txt"));
Object obj = in.readObject();
Person p = (Person)obj;
//这个时候序列化与反序列化使用的类不是一个类分别是day13.Person和day13.test.Person
//这个时候反序列化就有异常day13.Person cannot be cast to day13.test.Person
// day13.test.Person p = (day13.test.Person)obj;
System.out.println(p.name);
System.out.println(p.age);
in.close();
}
}
RandomAccessFile 类
RandomAccessFile 类支持 “随机访问” 的方式，程序可以直接跳到文件的任意 地方来读、写文件
支持只访问文件的部分内容
可以向已存在的文件后追加内容
RandomAccessFile 对象包含一个记录指针，用以标示当前读写处的位置。 RandomAccessFile 类对象可以自由移动记录指针：
long getFilePointer()：获取文件记录指针的当前位置
void seek(long pos)：将文件记录指针定位到 pos 位置
构造器
public RandomAccessFile(File file, String mode)
public RandomAccessFile(String name, String mode)
创建 RandomAccessFile 类实例需要指定一个 mode 参数，该参数指定 RandomAccessFile 的访问模式：
r: 以只读方式打开
rw：打开以便读取和写入
rwd:打开以便读取和写入；同步文件内容的更新
rws:打开以便读取和写入；同步文件内容和元数据的更新
读取文件内容
RandomAccessFile raf = new RandomAccessFile(“test.txt”, “rw”）;
raf.seek(5);
byte [] b = new byte[1024];
int off = 0;
int len = 5;
raf.read(b, off, len);
String str = new String(b, 0, len);
System.out.println(str);
raf.close();
写入文件内容
RandomAccessFile raf = new RandomAccessFile("test.txt", "rw");
raf.seek(5);
//先读出来
String temp = raf.readLine();
raf.seek(5);
raf.write("xykj".getBytes());
raf.write(temp.getBytes());
raf.close();
示例代码
import java.io.RandomAccessFile;
public class Test6 {
public static void main(String[] args) {
try {
// Test6.testRandomAccessFileRead();
Test6.testRandomAccessFileWrite();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 随机读文件
*/
public static void testRandomAccessFileRead() throws Exception{
//RandomAccessFile的构造有两个参数，参数1是读写的文件的路径
//参数2是指定 RandomAccessFile 的访问模式
//r: 以只读方式打开
//rw：打开以便读取和写入
//rwd:打开以便读取和写入；同步文件内容的更新
//rws:打开以便读取和写入；同步文件内容和元数据的更新
//最常用是r和rw
RandomAccessFile ra = new RandomAccessFile("D:/testdemo/demo/src/day13/tt10.txt", "r");
// ra.seek(0);//设置读取文件内容的起始点
ra.seek(8);//通过设置读取文件内容的起始点，来达到从文件的任意位置读取
byte[] b = new byte[1024];
int len = 0;
while((len = ra.read(b)) != -1){
System.out.println(new String(b, 0, len));
}
ra.close();
}
/**
* 随机写
*/
public static void testRandomAccessFileWrite() throws Exception{
RandomAccessFile ra = new RandomAccessFile("D:/testdemo/demo/src/day13/tt10.txt", "rw");
// ra.seek(0);//设置写的起始点，0代表从开头写
//注意：如果是在文件开头或者中间的某个位置开始写的话，就会用写的内容覆盖掉等长度的原内容
ra.seek(ra.length());//设置写的起始点,ra.length()代表从文件的最后结尾写，也就是文件的追加
ra.write("你好".getBytes());
ra.close();
}
}
来源：CSDN
作者：Sharpen__
链接：https://blog.csdn.net/Sharpen__/article/details/104301679