java IO(一)：File、RandomAccessFile、字节流与字符流、字节字符转换流
所有的io操作都保存在java.io包中。
File类
在整个java io包中，唯一与文件本身有关的类就是File类了。使用FIle类可以进行创建、删除文件等常用操作。
File的一个构造函数如下：
public File(String pathName) //实例化File类的时候必须设置好路径
常量：public static final String separator //这里的常量使用的是小写，是因为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() ; // 输出异常信息
}
}
}
};可以直接指定目录中的内容。列出的方法在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() ; // 列出给定目录中的内容,只有name
for(int i=0;iRandomAccessFile
RandomAccessFile主要完成文件内容随机读写的功能
构造：
public RandomAccessFile(File file,String mode) throws FileNotFoundException
实例化此类的时候需要传入一个File对象，告诉程序要操作的是哪个文件，此后需要传入一个文件的打开模式，常用三种模式：
- r：读模式
- w：写模式
- rw：读写模式，使用此模式，如果文件不存在，则会自动创建
范例：
现在假设文件中保存了以下的三个数据：
使用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() ; // 关闭
}
};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 姓名：" + name + "；年龄：" + age) ;
// 读取第一个人的信息
rdf.seek(0) ; // 指针回到文件的开头
for(int i=0;i 姓名：" + name + "；年龄：" + age) ;
rdf.skipBytes(12) ; // 空出第二个人的信息
for(int i=0;i 姓名：" + 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 implements Closeable，FlushableCloseable：表示可以执行关闭的操作，因为资源到最后一定要关闭。
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追加新内容：
之前的操作，如果重新执行程序，则肯定会覆盖文件中的已有内容，如果想要追加在文件的末尾，则要使用FileOutputStream的另外一个构造方法：
public FileOutputStream(File file,boolean append) throws FileNotFoundException;在windows下，如果在文件操作中想要换行的话，使用"\r\n"完成。
范例：
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(2) InputStream
既然程序可以向文件中写入内容，则可以通过InputStream从文件中把内容读取出来，首先来看InputStream类的定义：
public abstract class InputStream implements Closeablepublic FileInputStream(File file) throws FileNotFoundException;使用范例：
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数组变为字符串输出
}
};4. 字符流
在程序中一个字符等于两个字节(UTF-16编码)，那么JAVA提供了Reader、Writer两个专门操作字符流的类。
(1) Writer
Writer本身是一个字符流的输出类，此类的定义如下：
public abstract class Writer 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是使用字符的方式从IO中读取数据，Reader类的定义如下：
public abstract class Reader implements Readable,CloseableReader本身也是抽象类，如果要从文件中读取内容，则可以直接使用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的说明
