Java I/O输入输出流

一、编码问题

文本文件其实就是字节序列，可以是任意编码的字节序列，如果我们在中文机器上直接创建文本文件，那么该文本文件只能解析默认的ansi编码

转换成字节序列用的是项目默认的编码GBK，GBK编码中文占用2个字节，英文占用1个字节

UTF-8编码中中文占用3个字节，英文占用1个字节

Java是双字节编码，UTF-16BE编码，中文占用2个字节，英文占用2个字节

字符串转化为字节时可以指定编码方式：

        String s ="中国";
        byte[] byte1= s.getBytes("gbk");

当你的字节序列是某种编码时，这时候想把字节序列变成字符串，也需要用这种编码方式，否则会出现乱码。如下说明编码方式

String str1 = new String(bytes1,"utf-16be");

如果没有指明编码方式，则用项目默认的编码GBK

每个project可以设置自己默认的编码方式，且只认识自己的编码方式

二、File类的使用

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

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

文件的创建

        File file = new File("d:\javaIo");//要使用双斜杠\
        if(!file.exists())//判断文件存不存在
            file.mkdirs();//创建多级文件目录，file.mkdir()只创建一级目录
        else
            file.delete();//删除文件、文件夹

File file2 = new File("d:"+File.separator+"javaIo"+File.separator+"file2.txt");//File.separator设置分隔符，各个系统都能够识别
File file3 = new File("d:\javaIo","日记.txt");//两种方式都可以
if(!file2.exists())
            try {
                file2.createNewFile();//创建文件
            } catch (IOException e) {
                e.printStackTrace();
            }

常用的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());//父目录的路径

File类的常用操作

/**
     * 列出指定目录下（包括其子目录）的所有文件
     */
    public static void listDirectory(File dir) throws IOException{
        if(!dir.exists())
            throw new IllegalArgumentException("目录："+dir+"不存在");
        if(!dir.isDirectory())
            throw new IllegalArgumentException(dir+"不是目录");
      
        File[] files = dir.listFiles();
        if(files!=null&&files.length>0){
            for (File file : files) {
                if(file.isDirectory())
                    FileUtils.listDirectory(file);//递归方式遍历目录下所有文件
                else
                    System.out.println(file);
            }
        }
    }

注意：file.listFiles()方法获取到的是File，所以打印输出是完整的目录

而file.list()方法获取到的是String，打印输出的只是文件的名称，要打印完整目录需要加上父目录

三、RandomAccessFile的使用

RandomAccessFile是Java提供的对文件内容的访问类，既可以读文件，也可以写文件。支持随机访问文件，可以访问文件的任意位置

(1)Java的文件模型

在硬盘上的文件是byte  byte byte存储的，是数据的集合

(2)打开文件

有两种模式“rw”）(读写)“r”(只读)

RandomAccessFile = new RandomAccessFile(file,"rw");

文件指针，打开文件时指针在开头，pointer = 0;

(3)写方法

raf.write(int)---->只写一个字节（后8位），同时指针指向下一个位置，准备再次写入

raf.write(byte数组) 可以写入整个数组

(4)读方法

int b = raf.read()--->读一个字节

如果用raf.read(byte数组) 可以读取全部

(5)文件读写完成一定要关闭

四、字节流的使用

(1)InputStreamOutputStream

 InputStream抽象了读取数据的方式

OutputStream抽象了写数据的方式

(2)EOF = End 读到-1就读到结尾

(3)输入流基本方法

int b = in.read();读取一个字节，无符号填充到int低八位，-1是EOF

in.read(byte[] buf)读取数据填充到字节数组buf中

in.read(byte[] buf,int start, int size)

(4)输出流基本方法

out.write(int b) 写出一个byte到流，b的低8位

out.write(byte[] buf)将buf 字节数组都写入到流

out.write(byte[] buf,int start, int size)

(5)FileInputStream

子类，具体实现了在文件上读取数据

/**
     * 读取指定文件内容，按照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){
            System.out.print(Integer.toHexString(b&0xff)+"  ");
            if((i++)%10==0)
                System.out.println();
        }
        in.close();//读取完毕记得一定要close
        
    }

        FileInputStream in = new FileInputStream(fileName);
        byte[] buf = new byte[20*1024];
        //从in 中批量读取字节，放入到buf这个字节数组中，从第0个位置开始放，最多放buf.length个
        //返回的是读到的字节的个数
        int bytes = in.read(buf, 0, buf.length);//一次性读完，说明字节数组足够大

数组不够大时，有可能一次文件读不完，则需要在外面加上while((bytes = in.read(buf, 0, buf.length))!=-1)，这样才能保证读到完整的文件

byte类型8位，int类型32位，为避免数据转换错误，通过&0xff将高24位清零

(6)FileOutputStream

实现了向文件中写出byte数据的方法

FileOutputStream(File file,boolean append)

如果该文件不存在，则直接创建

如果该文件存在，为ture,则向文件中追加内容，如果没写或为false，删除后再创建

(7)DataOutputStream/DataInputStream

对“流”功能的扩展，可以更加方便的读取int,long,字符等类型的数据

DataOutputStream

writeInt()/writeDouble()/writeUTF(),只是包装好了可以直接用 

(8)BufferedInputStream&BufferedOutputStream

这两个流类为IO提供了带缓冲区的操作，一般打开文件进行写入或读取时，都会加上缓冲，这种流模式提高了IO的性能

从应用程序中把输入放入文件，相当于将一缸水倒入到另一个缸中：

FileOutputStream--->write()相当于一滴一滴的把水转移到水缸里

DataOutputStream--->writeXxx()方便一些，相当于一瓢一瓢的将水转移过去

BufferedOutputStream--->write更方便，相当于一瓢水一瓢水先放入桶中，再从桶中倒入到水缸里

批量读取（使用数组方式，先把文件内容存在数组中），效率最高！！！高了不止一点点

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 = 0;
        while ((b = in.read(buf, 0, buf.length)) != -1) {
            out.write(buf, 0, b);
            out.flush();// 最好加上
        }
    }

要记得刷新缓冲区 .flush

五、字符流的使用

(1)编码问题

(2)认识文本和文本文件

Java的文本（char）是16位无符号整数，是字符的unicode编码（双字节编码）

文件是byte  byte byte的数据序列

文本文件是文本（char）序列按照某种编码方案（utf-8，utf-16be，gbk）序列化为byte的存储结果

(3)字符流（reader，writer）--->操作的是文本文件，其他文件类型用字符流没有意义

字符的处理，一次处理一个字符

字符的底层仍然是基本的字节序列

字符流的基本实现，默认为gbk

InputStreamReader  完成byte流解析为char流，按照编码解析

OutputStreamWriter 提供char流到byte流，按照编码处理

 

FileReader/FileWrite用于文件的读写

(4)字符流的过滤器

BufferedReader--->readLine一次读一行 String line，

BufferedWriter/PrintWrite--->写一行

不认识换行，需要单独写出换行.newLine() 

六、对象的序列化和反序列化

(1)对象序列化，就是将Object转换成byte序列，反之叫对象的反序列化

(2)序列化流（ObjectOutputStream），是过滤流--->writeObject

反序列化流（ObjectInputStream）--->readObject

(3)序列化接口（Serializable）

对象必须实现序列化接口 implements Serializable，才能进行序列化，否则将出现异常

接口没有任何方法，只是一个标准

(4)transient关键字

用于不想序列化的元素

用transient修饰的元素不会进行jvm默认的序列化，但可以自己完成元素的序列化

(5)父类和子类

一个类实现了序列化接口，那么其子类都可以进行序列化

对子类对象进行反序列化操作时，如果其父类没有实现序列化接口，那么其父类的构造函数会被调用，如果其父类实现了序列化接口，则其父类的构造函数不会被调用