Java I/O

一.File类

java.io.File类：文件和目录路径名的抽象表示形式，与平台无关

File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。

File对象可以作为参数传递给流的构造函数。

凡是与输入、输出相关的类、接口都定义在java.io下

File是一个类，可以有构造器创建其对象。此对象对应着一个文件或一个文件目录

File类对象是与平台无关的

绝对路径：包括盘符在内的完整的文件路径

相对路径：在当前文件目录下的文件的路径

 

renameTo(File newName):重命名

file1.renameTo(file2):file1重命名为file2,要求：file1文件一定存在，file2文件一定不存在

mkDir():创建一个文件目录，只有在上层文件目录存在的情况下，才能返回true

mkDirs():创建一个文件目录。上层文件目录不存在时，一并创建

list():将文件以字符串的形式列出来

listFiles():将文件以文件的形式列出来

 

二.java IO流

IO流用来处理设备之间的数据传输。 

Java程序中，对于数据的输入/输出操作以”流(stream)” 的方式进行。

java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

 

按操作数据单位不同分为：字节流(8 bit)，字符流(16 bit)  

按数据流的流向不同分为：输入流，输出流

按流的角色的不同分为：节点流，处理流

四个抽象基类：InputStream,OutputStream,Reader,Writer

IO流体系：

下列程序将从file1文件中读取全部数据，然后写到file2文件中:

public class TestFile {
    public static void main(String[] args) {
      try{
       File file1=new File("F:\\io1\\hello1.txt");
       File file2=new File("F:\\io2\\hello2.txt");
       
       FileInputStream fis=new FileInputStream(file1);
       FileOutputStream fos=new FileOutputStream(file2);
       
       int c;
       while((c=fis.read())!=-1){
           fos.write(c);
       }
       fis.close();
       fos.close();
      }catch(FileNotFoundException e){
          System.out.println("FileStreamsTest"+e);
      }catch(IOException e){
          System.out.println("FileStreamTest"+e);
      }
    }

改进后如下：

public class TestFileInputOutputStream { 
       public static void copyFile(String src,String dest){
             //提供读入、写出的文件
             File file1=new File(src);
             File file2=new File(dest);
             //提供相应的流
             FileInputStream fis=null;
             FileOutputStream fos=null;
             try{
                 fis=new FileInputStream(file1);
                 fos=new FileOutputStream(file2);
                //实现文件的复制
                 byte[] b=new byte[20];
                 int len;
                 while((len=fis.read(b))!=-1){
                    fos.write(b,0,len);
                 }
             }catch(Exception e){
                 e.printStackTrace();
             }finally{
                 if(fos!=null){
                         try {
                            fos.close();
                        } catch (Exception e){
                            e.printStackTrace();
                        }
                     }
                 if(fis!=null){
                     try {
                        fis.close();
                    } catch (Exception e){
                        e.printStackTrace();
                    }
                 }
            }
      }
} 

此外，使用FileReader,FileWriter可以实现文本文件的复制。对于非文本文件(视频文件，音频文件，图片文件)，只能使用字节流FileInputStream,FileOutputStream。两种流用法相同。

 

缓冲流：

   根据数据操作单位可以把缓冲流分为：BufferedInputStream 和 BufferedOutputStream、BufferedReader 和 BufferedWriter

   缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法，其中readLine()一次读取字符文本文件的一行字符

   对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush()将会使内存中的数据立刻写出

   

转换流：

   转换流提供了在字节流和字符流之间的转换

   Java API提供了两个转换流：InputStreamReader和OutputStreamWriter

   字节流中的数据都是字符时，转成字符流操作更高效。

   解码：字节数组-->字符串

   编码：字符串-->字节数组

示例：

public void testMyInput() throws Exception{
    //定义读入、写出字节流
    FileInputStream fis = new FileInputStream("dbcp.txt");
    FileOutputStream fos = new FileOutputStream("dbcp5.txt");
    //解码、编码转换流
    InputStreamReader isr = new InputStreamReader(fis,"GBK");
    OutputStreamWriter osw = new OutputStreamWriter(fos,"GBK");
    //缓冲流
    BufferedReader br = new BufferedReader(isr);
    BufferedWriter bw = new BufferedWriter(osw);
    //复制
    String str = null;
    while((str = br.readLine()) != null){
        bw.write(str);
        bw.newLine();
        bw.flush();
}    bw.close();  br.close();}

标准输入输出流：

System.in和System.out分别代表了系统标准的输入和输出设备

 

对象流：

ObjectInputStream和ObjectOutputSteam

用于存储和读取对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。

 

序列化(Serialize)：用ObjectOutputStream类将一个Java对象写入IO流中

反序列化(Deserialize)：用ObjectInputStream类从IO流中恢复该Java对象

ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

 

对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其它程序获取了这种二进制流，就可以恢复成原来的Java对象

序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原

 

要实现序列化的类，必须要：

    1.要求此类是可序列化的，实现Serializable接口;

    2.要求此类的属性同样的实现Serializable接口;

    3.凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：private static final long serialVersionUID;serialVersionUID用来表明类的不同版本间的兼容性

    4.使用static或transient修饰的成员变量，不可实现序列化。

 

序列化对象步骤：

    1.创建一个 ObjectOutputStream

       2.调用 ObjectOutputStream 对象的 writeObject(对象) 方法输出可序列化对象。注意写出一次，操作flush()

反序列化步骤：

       1.创建一个 ObjectInputStream

       2.调用 readObject() 方法读取流中的对象

强调：如果某个类的字段不是基本数据类型或 String  类型，而是另一个引用类型，那么这个引用类型必须是可序列化的，否则拥有该类型的 Field 的类也不能序列化

序列化:将对象写入到磁盘或者进行网络传输。

要求对象必须实现序列化

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("test3.txt"));
Person p = new Person("韩梅梅",18,"中华大街",new Pet());
oos.writeObject(p);
oos.flush();
oos.close();
//反序列化：将磁盘中的对象数据源读出。
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test3.txt"));
Person p1 = (Person)ois.readObject();
System.out.println(p1.toString());
ois.close();

RandomAccessFile 类：

      1.支持 “随机访问” 的方式

      2.既可以充当一个输入流，也可以充当一个输出流

      3.支持从任意位置的读取、写入

      构造器

             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("xyz".getBytes());
raf.write(temp.getBytes());
 
raf.close();