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的序列化与反序列化：实质是一个数组，但是这个数组并不一定放满了，因此我们不需要讲后面没有使用的地方进行序列化，可以根据自己的需要定制序列化，只是序列化数组中的有效元素，提高性能。

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

秒客网

Java——再看IO

相关文章