java IO(一)：File、RandomAccessFile、字节流与字符流、字节字符转换流
所有的io操作都保存在java.io包中。
File类
在整个java io包中，唯一与文件本身有关的类就是File类了。使用FIle类可以进行创建、删除文件等常用操作。
File的构造函数如下：
public File(String pathName) //实例化File类的时候必须设置好路径
File类具体提供的操作接口请参考相关的API 文档。
常量：public static final String pathSeparator //这里的常量使用的是小写，是因为java历史遗留问题
在各个操作系统中，实际上路径的分隔符是不一样的，例如：
- 在windows中使用反斜杠："\"
- 在linux中使用正斜杠："/"
1. 创建、删除文件范例：
import java.io.File ;
import java.io.IOException ;
public class FileDemo06{
public static void main(String args[]){
File f = new File("d:"+File.separator+"test.txt") ; // 实例化File类的对象
if(f.exists()){ // 如果文件存在则删除
f.delete() ; // 删除文件
}else{
try{
f.createNewFile() ; // 创建文件，根据给定的路径创建
}catch(IOException e){
e.printStackTrace() ; // 输出异常信息
}
}
}
};
2. 列出指定目录的全部文件
如果现在给出了目录，则可以直接列出目录中的内容。但是列出的方法在FIle中存在两个：
- 以字符串数组的形式返回：String[] list()
- 以File数组的形式返回：FIle[] listFiles()
import java.io.File ;
import java.io.IOException ;
public class FileDemo08{
public static void main(String args[]){
File f = new File("d:"+File.separator) ; // 实例化File类的对象
String str[] = f.list() ; // 列出给定目录中的内容
for(int i=0;i<str.length;i++){
System.out.println(str[i]) ;
}
File files[] = f.listFiles() ; // 列出全部内容
for(int i=0;i<files.length;i++){
System.out.println(files[i]) ;
}
}
};
RandomAccessFile
RandomAccessFile主要完成随机读取的功能，可以读取指定位置的内容。
之前的File类是针对文件本身进行操作的，而如果想要对文件本身进行操作，可以使用RandomAccessFile类，此类属于随机读取类，可以随机读取一个文件中指定位置的数据。
构造：
public RandomAccessFile(File file,String mode) throws FileNotFoundException
实例化此类的时候需要传入一个File对象，告诉程序要操作的是哪个文件，此后需要传入一个文件的打开模式，常用三种模式：
- r：读模式
- w：写模式
- rw：读写模式，使用此模式，如果文件不存在，则会自动创建
RandomAccessFile类具体提供的操作接口请参考相关的API 文档。
范例：
现在假设文件中保存了以下的三个数据：
使用RandomAccessFile写入数据：
import java.io.File ;
import java.io.RandomAccessFile ;
public class RandomAccessFileDemo01{
// 所有的异常直接抛出，程序中不再进行处理
public static void main(String args[]) throws Exception{
File f = new File("d:" + File.separator + "test.txt") ; // 指定要操作的文件
RandomAccessFile rdf = null ; // 声明RandomAccessFile类的对象
rdf = new RandomAccessFile(f,"rw") ;// 读写模式，如果文件不存在，会自动创建
String name = null ;
int age = 0 ;
name = "zhangsan" ; // 字符串长度为8
age = 30 ; // 数字的长度为4
rdf.writeBytes(name) ; // 将姓名写入文件之中
rdf.writeInt(age) ; // 将年龄写入文件之中
name = "lisi " ; // 字符串长度为8
age = 31 ; // 数字的长度为4
rdf.writeBytes(name) ; // 将姓名写入文件之中
rdf.writeInt(age) ; // 将年龄写入文件之中
name = "wangwu " ; // 字符串长度为8
age = 32 ; // 数字的长度为4
rdf.writeBytes(name) ; // 将姓名写入文件之中
rdf.writeInt(age) ; // 将年龄写入文件之中
rdf.close() ; // 关闭
}
};
使用RandomAccessFile读出数据：
import java.io.File ;
import java.io.RandomAccessFile ;
public class RandomAccessFileDemo02{
// 所有的异常直接抛出，程序中不再进行处理
public static void main(String args[]) throws Exception{
File f = new File("d:" + File.separator + "test.txt") ; // 指定要操作的文件
RandomAccessFile rdf = null ; // 声明RandomAccessFile类的对象
rdf = new RandomAccessFile(f,"r") ;// 以只读的方式打开文件
String name = null ;
int age = 0 ;
byte b[] = new byte[8] ; // 开辟byte数组
// 读取第二个人的信息，意味着要空出第一个人的信息
rdf.skipBytes(12) ; // 跳过第一个人的信息
for(int i=0;i<b.length;i++){
b[i] = rdf.readByte() ; // 读取一个字节
}
name = new String(b) ; // 将读取出来的byte数组变为字符串
age = rdf.readInt() ; // 读取数字
System.out.println("第二个人的信息 --> 姓名：" + name + "；年龄：" + age) ;
// 读取第一个人的信息
rdf.seek(0) ; // 指针回到文件的开头
for(int i=0;i<b.length;i++){
b[i] = rdf.readByte() ; // 读取一个字节
}
name = new String(b) ; // 将读取出来的byte数组变为字符串
age = rdf.readInt() ; // 读取数字
System.out.println("第一个人的信息 --> 姓名：" + name + "；年龄：" + age) ;
rdf.skipBytes(12) ; // 空出第二个人的信息
for(int i=0;i<b.length;i++){
b[i] = rdf.readByte() ; // 读取一个字节
}
name = new String(b) ; // 将读取出来的byte数组变为字符串
age = rdf.readInt() ; // 读取数字
System.out.println("第三个人的信息 --> 姓名：" + name + "；年龄：" + age) ;
rdf.close() ; // 关闭
}
};
字节流与字符流
1. 流
在程序中所有的数据都是以流的形式进行保存或者传输的，程序需要数据的时候，就从输入流中读取数据，当需要将数据保存起来时，就要输出流完成。
文件中保存的其实全是字节。
2. 字节流与字符流
在java.io包中操作文件内容分为两大类：字节流、字符流，两类都分为输入和输出操作。在字节流中输出操作使用的是OutputStream完成，输入使用的是InputStream，在字符流中输出主要使用Writer，输入主要使用Reader完成。实际上四个操作类都是抽象类。
在Java中IO操作也是有相应步骤的，以文件操作为例，主要的操作步骤如下：
A) 使用File类打开一个文件
B) 通过字节流或字符流的子类，指定输出的位置
C) 进行读/写操作
D) 关闭输入/输出操作
使用Java IO操作的时候一定要注意路径分隔符的问题。
IO操作属于资源操作，对于资源操作，在操作最后必须要关闭，否则就可能出现未知的错误。
3. 字节流
字节流主要操作byte类型数据，字节输出流：OutputStream，字符输入流：InputStream。
所有的数据都可以直接使用Byte数组表示出来。
（1） OutputStream类
OutputStream是整个io包中字节输出流的最大父类，此类的定义如下：
public abstract class OutputStream extends Object implements Closeable，Flushable从定义可以看到，此类是一个抽象类，如果要想使用此类的话，则必须通过其子类实例化此对象，如果现在操作的是一个文件，则可以使用：FileOutputStream类。通过向上转型后，可以为OutputStream实例化。
Closeable：表示可以执行关闭的操作，因为资源到最后一定会关闭。
Flushable：表示刷新，清空内存中的数据。
FIleOutputStream构造函数：
public FileOutputStream(File file) throws FileNotFoundException;
范例：
import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo02{
public static void main(String args[]) throws Exception{ // 异常抛出，不处理
// 第1步、使用File类找到一个文件
File f= new File("d:" + File.separator + "test.txt") ; // 声明File对象
// 第2步、通过子类实例化父类对象
OutputStream out = null ; // 准备好一个输出的对象
out = new FileOutputStream(f) ; // 通过对象多态性，进行实例化
// 第3步、进行写操作
String str = "Hello World!!!" ; // 准备一个字符串
byte b[] = str.getBytes() ; // 只能输出byte数组，所以将字符串变为byte数组
for(int i=0;i<b.length;i++){ // 采用循环方式写入
out.write(b[i]) ; // 每次只写入一个内容
}
// 第4步、关闭输出流
out.close() ; // 关闭输出流
}
};
追加新内容：
之前的操作，如果重新执行程序，则肯定会覆盖文件中的已有内容，如果想要追加在文件的末尾，则要使用FileOutputStream的另外一个构造方法：
public FileOutputStream(File file,boolean append) throws FileNotFoundException;在构造方法中，如果将append的值设置为true，则表示在文件的末尾追加内容。
在windows下，如果在文件操作中想要换行的话，使用"\r\r"完成。
范例：
import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo04{
public static void main(String args[]) throws Exception{ // 异常抛出，不处理
// 第1步、使用File类找到一个文件
File f= new File("d:" + File.separator + "test.txt") ; // 声明File对象
// 第2步、通过子类实例化父类对象
OutputStream out = null ; // 准备好一个输出的对象
out = new FileOutputStream(f,true) ; // 此处表示在文件末尾追加内容
// 第3步、进行写操作
String str = "\r\nHello World!!!" ; // 准备一个字符串
byte b[] = str.getBytes() ; // 只能输出byte数组，所以将字符串变为byte数组
for(int i=0;i<b.length;i++){ // 采用循环方式写入
out.write(b[i]) ; // 每次只写入一个内容
}
// 第4步、关闭输出流
out.close() ; // 关闭输出流
}
};
(2) InputStream
既然程序可以向文件中写入内容，则可以通过InputStream从文件中把内容读取出来，首先来看InputStream类的定义：
public abstract class InputStream extends Object implements CloseableInputStream是一个抽象类，如果要从文件中进行读取，则可以使用FileInputStream将其实例化。
public FileInputStream(File file) throws FileNotFoundException;
具体提供的操作接口，请查看API 文档。
使用范例：
import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo02{
public static void main(String args[]) throws Exception{ // 异常抛出，不处理
// 第1步、使用File类找到一个文件
File f= new File("d:" + File.separator + "test.txt") ; // 声明File对象
// 第2步、通过子类实例化父类对象
InputStream input = null ; // 准备好一个输入的对象
input = new FileInputStream(f) ; // 通过对象多态性，进行实例化
// 第3步、进行读操作
byte b[] = new byte[1024] ; // 所有的内容都读到此数组之中
int len = input.read(b) ; // 读取内容
// 第4步、关闭输出流
input.close() ; // 关闭输出流\
System.out.println("读入数据的长度：" + len) ;
System.out.println("内容为：" + new String(b,0,len)) ; // 把byte数组变为字符串输出
}
}; 可以使用File.length（）提前获取文件的大小，然后开辟相应大小的byte数组进行读取。
现在假如在不知道文件大小的前提下，使用public abstract int read() throws IOException读取内容
import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo05{
public static void main(String args[]) throws Exception{ // 异常抛出，不处理
// 第1步、使用File类找到一个文件
File f= new File("d:" + File.separator + "test.txt") ; // 声明File对象
// 第2步、通过子类实例化父类对象
InputStream input = null ; // 准备好一个输入的对象
input = new FileInputStream(f) ; // 通过对象多态性，进行实例化
// 第3步、进行读操作
byte b[] = new byte[1024] ; // 数组大小由文件决定
int len = 0 ;
int temp = 0 ; // 接收每一个读取进来的数据
while((temp=input.read())!=-1){
// 表示还有内容，文件没有读完
b[len] = (byte)temp ;
len++ ;
}
// 第4步、关闭输出流
input.close() ; // 关闭输出流\
System.out.println("内容为：" + new String(b,0,len)) ; // 把byte数组变为字符串输出
}
}; 当不知道要读取多大的内容时，只能以返回值是否为-1为读完的标志。
4. 字符流
在程序中一个字符等于两个字节，那么JAVA提供了Reader、Writer两个专门操作字符流的类。
(1) Writer
Writer本身是一个字符流的输出类，此类的定义如下：
public abstract class Writer extends Obejct implements Appendable,Closeable,Flushable;
此类本身也是一个抽象类，如果要想使用此类，则肯定要使用其子类，此时如果是向文件中写入内容，则应该使用FileWriter子类。
FileWriter类的构造方法如下：
public FileWriter(File file) throws IOException
范例：
import java.io.File ;
import java.io.Writer ;
import java.io.FileWriter ;
public class WriterDemo02{
public static void main(String args[]) throws Exception{ // 异常抛出，不处理
// 第1步、使用File类找到一个文件
File f= new File("d:" + File.separator + "test.txt") ; // 声明File对象
// 第2步、通过子类实例化父类对象
Writer out = null ; // 准备好一个输出的对象
out = new FileWriter(f,true) ; // 通过对象多态性，进行实例化 追加操作
// 第3步、进行写操作
String str = "\r\nLIXINGHUA\r\nHello World!!!" ; // 准备一个字符串
out.write(str) ; // 将内容输出，保存文件
// 第4步、关闭输出流
out.close() ; // 关闭输出流
}
};
(2) Reader
Reader是使用字符的方式从文件中读取数据，Reader类的定义如下：
public abstract class Reader extends Object implements Readable,Closeable
Reader本身也是抽象类，如果要从文件中读取内容，则可以直接使用FileReader子类。
FileReader构造函数如下：
public FileReader(File file) throws FileNotFoundException
范例，使用循环的方式读取：
import java.io.File ;
import java.io.Reader ;
import java.io.FileReader ;
public class ReaderDemo02{
public static void main(String args[]) throws Exception{ // 异常抛出，不处理
// 第1步、使用File类找到一个文件
File f= new File("d:" + File.separator + "test.txt") ; // 声明File对象
// 第2步、通过子类实例化父类对象
Reader input = null ; // 准备好一个输入的对象
input = new FileReader(f) ; // 通过对象多态性，进行实例化
// 第3步、进行读操作
char c[] = new char[1024] ; // 所有的内容都读到此数组之中
int temp = 0 ; // 接收每一个内容
int len = 0 ; // 读取内容
while((temp=input.read())!=-1){
// 如果不是-1就表示还有内容，可以继续读取
c[len] = (char)temp ;
len++ ;
}
// 第4步、关闭输出流
input.close() ; // 关闭输出流
System.out.println("内容为：" + new String(c,0,len)) ; // 把字符数组变为字符串输出
}
};
5. 字节流和字符流的区别
字节流在操作的时候本身是不会用到缓冲区的(内存) 的，是与文件本身直接操作的，而字符流在操作的时候是使用到缓冲区的。
在使用字节流进行输出时，即使文件没有关闭，最终也是可以输出的。
使用字符流进行输出的话，如果文件没有关闭，就不会输出到文件之中，除非缓冲区满或者强制调用flush函数。
说明：在开发中使用字节流多还是字符流多？
在硬盘上保存文件或者是进行传输的时候都是以字节的形式进行的。包括图片也是按字节完成，而字符只有在内存中才会形成的。如果处理跟字符无关的操作，就别用字符流了。
OutputStreamWriter 和 InputStreamReader
在整个IO包中，实际上就是分为字节流和字符流，但是除了这两个流之外，还存在一组字节流-字符流的转换类。
OutputStreamWriter：是Writer的子类，将输出的字符流变为字节流，即：将一个字符流的输出对象变为字节流的输出对象。
InputStreamReader：是Reader的子类，将输出的字节流变为字符流，即：将一个字节流的输出对象变为字符流的输入对象。
范例：
import java.io.* ;
public class InputStreamReaderDemo01{
public static void main(String args[]) throws Exception{
File f = new File("d:" + File.separator + "test.txt") ;
Reader reader = null ;
reader = new InputStreamReader(new FileInputStream(f)) ; // 将字节流变为字符流
char c[] = new char[1024] ;
int len = reader.read(c) ; // 读取
reader.close() ; // 关闭
System.out.println(new String(c,0,len)) ;
}
};
import java.io.* ;
public class OutputStreamWriterDemo01{
public static void main(String args[]) throws Exception { // 所有异常抛出
File f = new File("d:" + File.separator + "test.txt") ;
Writer out = null ; // 字符输出流
out = new OutputStreamWriter(new FileOutputStream(f)) ; // 字节流变为字符流
out.write("hello world!!") ; // 使用字符流输出
out.close() ;
}
};
FileReader 和 FileWriter的说明
