Java——再看IO

一。编码问题

• utf-8编码中，一个中文占3个字节，一个英文占1个字节；gbk编码中，一个中文占2个字节，一个英文占1个字节。
• Java是双字节编码，为utf-16be编码，是说一个字符（无论中文还是英文，都占用2个字节）。因此如果这么问：Java字符串中一个字符可以放一个中文吗？是可以的！
• 如果一直某个字节序列的编码方式，当我们想将它还原成字符串时，应明确指定其编码格式，否则会出现乱码。
• 文本文件就是字节序列，可以是任意编码的字节序列。如果在中文机器上，直接创建文本文件，该文本文件只认识ANSI编码

public static void main(String[] args) throws UnsupportedEncodingException {
        // TODO Auto-generated method stub

        /*
         * 在utf-8编码中中文占3个字节，而bgk编码中中文占2个字节
         */
        String s = "慕课ABC";
        byte[] byte1 = s.getBytes();
        for(byte b : byte1)  //byte 8bits, int 32 bits. xx vs xxxxxxxx
            System.out.print(Integer.toHexString(b & 0xff) + " "); //e6 85 95 e8 af be 41 42 43 (code: utf-8)
        System.out.println();

        byte[] byte2 = s.getBytes("gbk");
        for(byte b : byte2)
            System.out.print(Integer.toHexString(b & 0xff) + " "); //c4 bd bf ce 41 42 43 

        /*
         * java是双字节编码，utf-16be编码。意思是Java里的字符串的一个字符占用2个字节
         * 面试官会问：Java一个字符中可不可以放汉字呢？如果是gbk编码，是可以的。
         */
        System.out.println();
        byte[] byte3 = s.getBytes("utf-16be");
        for(byte b : byte3)
            System.out.print(Integer.toHexString(b & 0xff) + " "); //61 55(慕) 8b fe(课) 0 41(A) 0 42(B) 0 43(C) 

        System.out.println();
        String s1 = new String(byte3);
        System.out.println(s1); //乱码
        String s2 = new String(byte3, "utf-16be");
        System.out.println(s2); //慕课ABC

    }

二。File类的使用

• java.io.File类用于表示文件（目录）；
• File类值用于表示文件（目录 ）的信息（名称、大小等），不能用于文件内容的访问。
• 静态方法：File.seperator可以直接当成分隔符使用，无论在什么系统下都可以使用，避免\\ or /的困扰。

/**
     * 递归遍历一个目标及所有子目录下的文件，打印其文件名
     * @param dir
     */
    public void listDirectory(File dir) {
        if(!dir.exists())
            throw new IllegalArgumentException("目录" + dir + "不存在");
        if(!dir.isDirectory())
            throw new IllegalArgumentException(dir + "不是一个目录");
        //String[] fileNames = dir.list();
        File[] files = dir.listFiles();

        //如果要遍历子目录下的内容，就要构造File对象做递归操作
        if(files != null && files.length > 0) {
            for(File file : files) {
                if(file.isDirectory())
                    listDirectory(file);
                else System.out.println(file.getName());
            }
        }

    }

三。RandomAccessFile的使用

• Java提供的对文件内容的访问，既可以读文件，也可以写文件。
• 支持随机访问文件，可以访问文件的任意位置。
• Java文件模型：
  • 在硬盘上的文件是byte byte byte存储的，是数据的集合。
• 打开文件
  • 有两种模式“rw”和“r”
  • RandomAccessFile raf = new RandomAccessFile(file, "rw");
  • 文件指针，打开文件是指针在开头 pointer = 0；
• 写文件
  • raf.write(int) —— 只写一个字节（后8位），同时指针指向下一个位置，准备再次写入
• 读方法
  • int b = raf.read() —— 读一个字节
• 文件读写完成后一定要关闭

public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        File demo = new File("demo");
        if(!demo.exists())
            demo.mkdir();
        File file = new File(demo, "raf.dat");
        if(!file.exists())
            file.createNewFile();

        RandomAccessFile raf = new RandomAccessFile(file, "rw");
        //指针的位置，输出为0，随机读取文件好处：文件下载时，文件很大，分成程序同时下载，灭个下载
        //然后在拼接在一起，迅雷每个线程下载文件的一部分，需要知道拼接的位置在哪里，所以需要随机读取
        System.out.println(raf.getFilePointer());

        raf.write('A'); //只写了一个字节（后8位）
        System.out.println(raf.getFilePointer());

        int i = 0x7fffffff;
        //用write方法，每次只能写一个字节，所以得写4次
        raf.write(i >>> 24);
        raf.write(i >>> 16);
        raf.write(i >>> 8);
        raf.write(i);
        System.out.println(raf.getFilePointer());

        //可以直接写一个int
        raf.writeInt(i);
        String s = "中";
        byte[] utf = s.getBytes("gbk");
        raf.write(utf);
        System.out.println(raf.getFilePointer());

        //读文件，必须把指针移到头部
        raf.seek(0);
        byte[] buf = new byte[(int)raf.length()];
        raf.read(buf);
        System.out.println(Arrays.toString(buf));
        System.out.println(new String(buf, "utf-8"));
        for(byte b : buf) {
            System.out.print(Integer.toHexString(b & 0xff) + " ");
        }

    }

四。字节流的使用

• IO流（输入流、输出流； 字节流、字符流）
• InputStream  
  • 抽象了应用程序读取数据的方式；
  • int b = in.read(); //读取一个字节，无符号填充到int的低八位。-1是EOF
  • in.read(byte[] buf) //读取数据填充到字符数组buf中
• OutputStream
  • 抽象了应用程序写出数据的方式；
  • out.write(int b) //只写出一个byte到流，b的低八位
  • out.write(byte[] buf) //将buf字节数组都写入到流
• EOF = End 读到-1就读到结尾了
• FileInputStream —— 具体实现了在文件上读取数据

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

批量读取与单独读取有什么区别？用批量读取会节省很多时间。

//批量读取，适合大文件
public static void printHexByByteArray(String fileName) throws IOException {
        FileInputStream in = new FileInputStream(fileName);
        byte[] buf = new byte[20 * 1024];
        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();
            }
        }
}

//单字节读取
/**
     * 读取指定文件内容，按照16进制输出到控制台
     * 每输出10个byte就换行
     * @param fileName
     * @throws IOException
     */
    public static void printHex(String fileName) throws IOException {
        //把文件作为字节流进行读操作
        FileInputStream in = new FileInputStream(fileName);
        int b;
        int i = 0;
        while((b = in.read()) != -1) {
            if(b <= 0xf)
                System.out.print("0");
            System.out.print(Integer.toHexString(b) + " ");
            if(i++ % 10 == 0)
                System.out.println();
        }
        in.close();
    }

• DataInputDtream 和 DataOutputStream
  • 对流功能的扩展，可以更加方便的读取int，long，字符等类型数据，如writeInt()/writeDouble()/writeUTF()
• BufferedInoutStream 和 BufferedOutputStream
  • 这两个类为IO提供了带缓冲区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式提高了IO的性能
  • 从应用程序中把输入放入文件，相当于将一桶水倒入另一个桶中：
    • FileOutputStream的write()方法相当于一滴一滴地把水转移过去；
    • DataOutputStream的writexxx()方法相当于用一个非常小的容器转移；
    • BufferedOutputStream的write()方法相当于用一个更大的容器做缓存，提高性能。

/**
     * 通过缓冲区的方法拷贝文件
     * @param srcFile
     * @param dstFile
     * @throws IOException
     */
    public static void copyFileByBuffer(File srcFile, File dstFile) throws IOException {
        if(!srcFile.exists())
            throw new IllegalArgumentException("File: " + srcFile + " not exist.");
        if(!srcFile.isFile())
            throw new IllegalArgumentException(srcFile + "not a file.");
        BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(dstFile));
        int c;
        while((c = bis.read()) != -1) {
            bos.write(c);
            bos.flush();
        }
        bis.close();
        bos.close();
    }
    

五。字符流的使用

• 文本和文本文件
  • Java中的文本（char）是16位无符号整数，是字符的Unicode编码（双字节编码）；
  • 文件是byte byte byte的数据序列；
  • 文本文件是文本（char）序列按照某种编码方案（utf-8, utf-16be,gbk）序列化为byte的存储。
• 字符流（Reader，Writer）—— 操作的是文本文件
  • 字符的处理，一次处理一个字符；
  • 字符的底层仍然是基本的字节序列。
  • 字符流的基本实现：
    • InputStreamReader 完成byte流解析为char流，按照编码解析
    • OutputStreamReader 提供char流解析为byte流，按照编码处理
  • 文件读写流：
    • FileReader
    • FileWriter
  • 字符流的过滤
    • BufferedReader —— 可以readLine,一次读一行
    • BufferedWriter/Printer —— 写一行

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(
                new InputStreamReader(
                        new FileInputStream("demo/out.data")));
        BufferedWriter bw = new BufferedWriter(
                new OutputStreamWriter(
                        new FileOutputStream("demo/out1.data")));
        PrintWriter pw = new PrintWriter("demo/out2.data");
        String line;
        while((line = br.readLine()) != null) {
            System.out.println(line);
            pw.println(line);
            pw.flush();
//            bw.write(line);
//            bw.newLine();
//            bw.flush();
        }
        pw.close();
        bw.close();
        br.close();

    }

六。序列化与反序列化

• 对象的序列化和反序列化
  • 对象序列化是指将Object对象转化成byte序列，反之叫做对象的反序列化；
  • 序列化流（ObjectOutputStream）是过滤流——writeObject();
  • 反序列化流（ObjectInputStream）—— readObject();
  • 序列化接口（Serializable）
    • 对象必须实现序列化接口才能实现序列化，否则将出现异常，这个接口没有任何方法，只是一个标准。
  • 对象的序列化和反序列化将那些实现了Serialization接口的对象转换成一个字节序列，并能够在以后将这个字节完全恢复为原来的对象；
    • 这样做的一个好处是：能够自动弥补不同操作系统之间的差异。可以在运行Windows操作系统的计算机上创建一个对象，将其序列化，通过网络将它发送给一台运行Unix系统的计算机，然后在那里能够准确的重新组装，而不必担心数据在不同机器上的表示会不同，也不必关心字节的顺序或者其他任何细节；
    • 将序列化的概念加入java中主要是为了支持两种特性：
      • 一是java的远程方法调用(Remote Method Invocation,RMI)，它使存活在其他计算机上的对象使用起来就像存活于本机上一样，当向远程对象大宋消息时，需要通过对象序列化来传输参数和返回值；
      • 二是对于java Bean来说，序列化也是必须的。使用一个Bean时，一般情况是在设计阶段对他的状态信息进行配置。这种状态信息必须保存下来，并在程序启东市进行后期恢复。

public static void main(String[] args) throws IOException, IOException {
        String file = "demo/obj.txt";
        //1. 对象序列化
        ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream(file));
        StudentDemo st = new StudentDemo("aaa", "12", 15);
        oos.writeObject(st);
        oos.flush();
        oos.close();

        //2.反序列化
        ObjectInputStream pis = new ObjectInputStream(
                new FileInputStream(file));
        try {
            StudentDemo stu = (StudentDemo) pis.readObject();
            System.out.println(stu);
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        pis.close();
    }

• transient 修饰后，不会进行虚拟机默认的序列化；也可以自己完成这个元素的序列化
  • 为什么要使用transient关键字呢？
  • 分析ArrayList的序列化与反序列化：实质是一个数组，但是这个数组并不一定放满了，因此我们不需要讲后面没有使用的地方进行序列化，可以根据自己的需要定制序列化，只是序列化数组中的有效元素，提高性能。

• 序列化中子父类构造函数调用问题
  • 一个类实现了序列化接口，其子类都可以进行序列化
  • 对子类对象进行反序列化操作时，如果其父类没有实现序列化接口，那么其父类的构造函数会被调用；反之不会。