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中使用正斜杠："/"

如果想让java程序的移植性得到继续保持，则最好使用pathSeparator ，让其根据当前所使用的操作系统来自动选择路径分隔符。

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" ;// 字符串长度为8age = 30 ;// 数字的长度为4rdf.writeBytes(name) ;// 将姓名写入文件之中rdf.writeInt(age) ;// 将年龄写入文件之中name = "lisi    " ;// 字符串长度为8age = 31 ;// 数字的长度为4rdf.writeBytes(name) ;// 将姓名写入文件之中rdf.writeInt(age) ;// 将年龄写入文件之中name = "wangwu  " ;// 字符串长度为8age = 32 ;// 数字的长度为4rdf.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 Closeable

   InputStream是一个抽象类，如果要从文件中进行读取，则可以使用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的说明