JAVA IO学习总结

一、java文件模型

　　在硬盘上的文件是以byte byte byte ...格式存储的，是数据的集合。

二、java.io.File类用于表示文件（目录）

　　File类只用于表示文件（目录）的信息（名称、大小等），不能用于文件内容的访问。以下是用File类的进本用法。

package com.imooc.io;

import java.io.File;
import java.io.IOException;

public class FileDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // 了解构造函数的情况  查帮助
        File file = new File("E:\\javaio\\imooc");
        //System.out.println(file.exists());
        if(!file.exists())
            file.mkdir(); //file.mkdirs()
        else
            file.delete();
        //是否是一个目录  如果是目录返回true,如果不是目录or目录不存在返回的是false
        System.out.println(file.isDirectory());
        //是否是一个文件
        System.out.println(file.isFile());
        
        //File file2 = new File("e:\\javaio\\日记1.txt");
        File file2 = new File("e:\\javaio","日记1.txt");
        if(!file2.exists())
            try {
                file2.createNewFile();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        else 
            file2.delete();
         //常用的File对象的API
        System.out.println(file);//file.toString()的内容
        System.out.println(file.getAbsolutePath());
        System.out.println(file.getName());
        System.out.println(file2.getName());
        System.out.println(file.getParent());
        System.out.println(file2.getParent());
        System.out.println(file.getParentFile().getAbsolutePath());
    }

}

三、java字节流

　　以字节为单位读取或写入文件

3.1 InputStream、OutputStream

InputStream抽象了应用程序以字节流的方式从文件中读取数据的内存中的方法。

OutputStream抽象了应用程序以字节流的方式从内存中将数据写入到文件中的方法。

 

1）InputStream抽象了应用程序读取数据的方式，此抽象类是表示字节输入流的所有类的超类。 

输入流基本方法：
int b = in.read();读取一个字节无符号填充到int低八位.-1是 EOF
in.read(byte[] buf) ；将读取到的字节写入到buf字节数组中。
in.read(byte[] buf,int start,int size)；将读取到的字节写入到buf字节数组中，start表示写入到buf的开始位置（一般从0开始），size表示最大能写入的字节数（一般为buf的长度）。

2）OutputStream抽象了应用程序写出数据的方式，此抽象类是表示字节输出流的所有类的超类。

输出流的基本方法：

out.write(int b) ；写出一个byte到流，b的低8位
out.write(byte[] buf)；将buf字节数组都写入到流
out.write(byte[] buf,int start,int size)；

3)FileInputStream--->具体实现了在文件上读取数据
4)FileOutputStream 实现了向文件中写出数据的方法

以下是实例代码：

package com.imooc.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class IOUtil {
    /**
     * 读取指定文件内容，按照16进制输出到控制台
     * 并且每输出10个byte换行
     * @param fileName
     * 单字节读取不适合大文件，大文件效率很低
     */
    public static void printHex(String fileName)throws IOException{
        //把文件作为字节流进行读操作
        FileInputStream in = new FileInputStream(fileName);
        int b ;
        int i = 1;
        while((b = in.read())!=-1){
            if(b <= 0xf){
                //单位数前面补0
                System.out.print("0");
            }
            System.out.print(Integer.toHexString(b)+"  ");
            if(i++%10==0){
                System.out.println();
            }
        }
        in.close();
    }
    /**
     * 批量读取，对大文件而言效率高，也是我们最常用的读文件的方式
     * @param fileName
     * @throws IOException
     */
    public static void printHexByByteArray(String fileName)throws IOException{
        FileInputStream in = new FileInputStream(fileName);
        byte[] buf = new byte[8 * 1024];
        /*从in中批量读取字节，放入到buf这个字节数组中，
         * 从第0个位置开始放，最多放buf.length个 
         * 返回的是读到的字节的个数
        */
        /*int bytes = in.read(buf,0,buf.length);//一次性读完，说明字节数组足够大
        int j = 1; 
        for(int i = 0; i < bytes;i++){
            System.out.print(Integer.toHexString(buf[i] & 0xff)+"  ");
            if(j++%10==0){
                System.out.println();
            }
        }*/
      int bytes = 0;
      int j = 1;
      while((bytes = in.read(buf,0,buf.length))!=-1){
          for(int i = 0 ; i < bytes;i++){
              System.out.print(Integer.toHexString(buf[i] & 0xff)+"  ");
              if(j++%10==0){
                  System.out.println();
              }
          }
      }
      in.close();
    }
    /**
     * 文件拷贝，字节批量读取
     * @param srcFile
     * @param destFile
     * @throws IOException
     */
    public static void copyFile(File srcFile,File destFile)throws IOException{
        if(!srcFile.exists()){
            throw new IllegalArgumentException("文件:"+srcFile+"不存在");
        }
        if(!srcFile.isFile()){
            throw new IllegalArgumentException(srcFile+"不是文件");
        }
        FileInputStream in = new FileInputStream(srcFile);
        FileOutputStream out = new FileOutputStream(destFile);
        byte[] buf = new byte[8*1024];
        int b ;
        while((b = in.read(buf,0,buf.length))!=-1){
            out.write(buf,0,b);
            out.flush();//最好加上
        }
        in.close();
        out.close();
        
    }
    /**
     * 进行文件的拷贝，利用带缓冲的字节流
     * @param srcFile
     * @param destFile
     * @throws IOException
     */
    public static void copyFileByBuffer(File srcFile,File destFile)throws IOException{
        if(!srcFile.exists()){
            throw new IllegalArgumentException("文件:"+srcFile+"不存在");
        }
        if(!srcFile.isFile()){
            throw new IllegalArgumentException(srcFile+"不是文件");
        }
        BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(destFile));
        int c ;
        while((c = bis.read())!=-1){
            bos.write(c);
            bos.flush();//刷新缓冲区
        }
        bis.close();
        bos.close();
    }
    /**
     * 单字节，不带缓冲进行文件拷贝
     * @param srcFile
     * @param destFile
     * @throws IOException
     */
    public static void copyFileByByte(File srcFile,File destFile)throws IOException{
        if(!srcFile.exists()){
            throw new IllegalArgumentException("文件:"+srcFile+"不存在");
        }
        if(!srcFile.isFile()){
            throw new IllegalArgumentException(srcFile+"不是文件");
        }
        FileInputStream in = new FileInputStream(srcFile);
        FileOutputStream out = new FileOutputStream(destFile);
        int c ;
        while((c = in.read())!=-1){
            out.write(c);
            out.flush();
        }
        in.close();
        out.close();
    }
    
}

四、java字符流

1.字符流以字符为单位读取或写入数据，字符流只能处理文本和文本文件。

2.文本和文本文件

java的文本(char)是16位无符号整数，是字符的unicode编码（双字节编码)
文件是byte byte byte ...的数据序列
文本文件是文本(char)序列按照某种编码方案(utf-8,utf-16be,gbk)序列化为byte的存储结果

字符的处理，一次处理一个字符
字符的底层任然是基本的字节序列
字符流的基本实现
InputStreamReader 完成byte流解析为char流,按照编码解析
OutputStreamWriter 提供char流到byte流，按照编码处理

package com.imooc.io;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class IsrAndOswDemo {
    public static void main(String[] args)throws IOException {
        FileInputStream in = new FileInputStream("e:\\javaio\\imoocutf8.txt");
        InputStreamReader isr = new InputStreamReader(in,"utf-8");//默认项目的编码,操作的时候，要写文件本身的编码格式
    
        FileOutputStream out = new FileOutputStream("e:\\javaio\\imoocutf81.txt");
        OutputStreamWriter osw = new OutputStreamWriter(out,"utf-8");
        /*int c ;
        while((c = isr.read())!=-1){
            System.out.print((char)c);
        }*/
        char[] buffer = new char[8*1024];
        int c;
        /*批量读取，放入buffer这个字符数组，从第0个位置开始放置，最多放buffer.length个
          返回的是读到的字符的个数
        */
        while(( c = isr.read(buffer,0,buffer.length))!=-1){
            String s = new String(buffer,0,c);
            System.out.print(s);
            osw.write(buffer,0,c);
            osw.flush();
        }
        isr.close();
        osw.close();
        
    }

}

五、序列化

序列化接口(Serializable)
对象必须实现序列化接口 ，才能进行序列化，否则将出现异常
这个接口，没有任何方法，只是一个标准

package com.imooc.io;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class ObjectSeriaDemo1 {
    public static void main(String[] args) throws Exception{
        String file = "demo/obj.dat";
        //1.对象的序列化
        /*ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream(file));
        Student stu = new Student("10001", "张三", 20);
        oos.writeObject(stu);
        oos.flush();
        oos.close();*/
        ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream(file));
        Student stu = (Student)ois.readObject();
        System.out.println(stu);
        ois.close();
        
    }
    

}