文件传输基础----Java IO流

编码问题

一个很著名的奇怪现象：当你在 windows 的记事本里新建一个文件，输入"联通"两个字之后，保存，关闭，然后再次打开，你会发现这两个字已经消失了，代之的是几个乱码！呵呵，有人说这就是联通之所以拼不过移动的原因。
其实这是因为GB2312编码与UTF8编码产生了编码冲撞的原因。
GB系中“联通”的二进制编码为：11000001 10101010 11001101 10101000

注意到了吗？第一二个字节、第三四个字节的起始部分的都是"110"和"10"，正好与UTF8规则里的两字节模板是一致的，于是再次打开记事本时，记事本就误认为这是一个UTF8编码的文件，让我们把第一个字节的110和第二个字节的10去掉，我们就得到了"00001 101010"，再把各位对齐，补上前导的0，就得到了"0000 0000 0110 1010"，不好意思，这是UNICODE的006A，也就是小写的字母"j"，而之后的两字节用UTF8解码之后是0368，这个字符什么也不是。这就是只有"联通"两个字的文件没有办法在记事本里正常显示的原因。

而如果你在"联通"之后多输入几个字，其他的字的编码不见得又恰好是110和10开始的字节，这样再次打开时，记事本就不会坚持这是一个utf8编码的文件，而会用ANSI的方式解读之，这时乱码又不出现了。

package com.imooc.io;import java.io.UnsupportedEncodingException;/** * Created by N3verL4nd on 2017/3/8. */public class EncodeDemo {    public static void main(String[] args) throws UnsupportedEncodingException {        String str = "慕课ABC";        byte[] bytes = str.getBytes("GBK");        //gbk编码中文占用两个字节，英文占用1个字节        for (byte b : bytes) {            //把字节(转换成了int)以16进制的方式显示            System.out.print(Integer.toHexString(b & 0xff) + " ");        }        /**         * 当你的字节序列使用某种编码时，如果把字节序列转化为         * 字符串，也需要使用相同的编码方式，否则出现乱码         */        System.out.println(new String(bytes));//用项目默认的编码方式        System.out.println("\n" + new String(bytes, "UTF-8"));        System.out.println(new String(bytes, "GBK"));        bytes = str.getBytes("UTF-8");        //UTF-8编码中文占用三个字节，英文占用1个字节        for (byte b : bytes) {            System.out.print(Integer.toHexString(b & 0xff) + " ");        }        System.out.println("\n" + new String(bytes));        //java是双字节编码 UTF-16BE        bytes = str.getBytes("UTF-16BE");        //utf-16be 中文占用2个字节，英文占用两个字节        for (byte b : bytes) {            System.out.print(Integer.toHexString(b & 0xff) + " ");        }        System.out.println("\n" + new String(bytes, "UTF-16BE"));        /**         * 文本文件保存的字节序列         * 可以死任意编码的字节序列         * 在中文机器上创建的文本文件默认是ANSI         */    }}

c4 bd bf ce 41 42 43 
Ľ��ABC
Ľ��ABC
慕课ABC
e6 85 95 e8 af be 41 42 43 
慕课ABC
61 55 8b fe 0 41 0 42 0 43 
慕课ABC

参考：

http://www.iteedu.com/topic/charset/utf8.php

http://oznyang.iteye.com/blog/30692

https://www.zhihu.com/question/25367290

File类的使用

作用：用于表示文件（目录），只能表示文件（目录）的信息，不能用于文件的访问。

package com.imooc.io;import java.io.File;import java.io.IOException;/** * Created by N3verL4nd on 2017/3/9. */public class FileDemo {    public static void main(String[] args) {        File file = new File("D:/Java/IdeaProjects/JavaProj/JTest/src/com/imooc/io/doc");        //System.out.println(file.isDirectory());        if (!file.exists()) {            file.mkdir();            System.out.println("路径 " + file.getAbsolutePath() + " 被创建！");        } else {            file.delete();            System.out.println("路径 " + file.getAbsolutePath() + " 被删除！");        }        file = new File("D:/Java/IdeaProjects/JavaProj/JTest/src/com/imooc/io/doc.txt");        //file = new File("D:/Java/IdeaProjects/JavaProj/JTest/src/com/imooc/io/", "doc.txt");        //System.out.println(file.isFile());        if (!file.exists()) {            try {                //创建文件                file.createNewFile();                System.out.println("文件 " + file.getName() + " 被创建！");            } catch (IOException e) {                e.printStackTrace();            }        } else {            //删除文件            file.delete();            System.out.println("文件 " + file.getName() + " 被删除！");        }    }}

package com.imooc.io;import java.io.File;/** * Created by N3verL4nd on 2017/3/9. * 列出File类的一些常用操作，比如过滤、遍历等 */public class FileUtils {    /**     * 列出指定目录下（包括其子目录）的所有文件     * @param file     */    public static void listDirectory(File file) throws IllegalArgumentException {        if (!file.exists()) {            throw new IllegalArgumentException("目录 " + file + " 不存在！");        }        if (!file.isDirectory()) {            throw new IllegalArgumentException(file + " 不是目录！");        }        /*//返回字符串数组，包括该目录下的目录名和文件名，不包括子目录        for (String patName : file.list()) {            System.out.println(file + "\\" + patName);        }*/        for (File f : file.listFiles()) {            if (f.isFile()) {                System.out.println("[文件]:" + f);            } else if (f.isDirectory()) {                System.out.println("[目录]:" + f.getAbsolutePath());                listDirectory(f);            }        }    }}

RandomAccessFile的使用

java提供的对文件内容的访问，既可以读文件，也可以写文件。

RandomAccessFile支持随机访问文件，即可以访问问价你的任意位置。

1、Java文件模型

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

2、打开文件

"rw"(读写) "r"(读)

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

其封装由文件指针

3、写方法

raf.write(int)-->只写1个字节（后8位），同时文件指针指向下一个位置

4、读方法

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

5、文件读写完成后一定要关闭

raf.close();

package com.imooc.io;import java.io.File;import java.io.IOException;import java.io.RandomAccessFile;import java.util.Arrays;/** * Created by N3verL4nd on 2017/3/9. */public class rafDemo {    public static void main(String[] args) throws IOException {        File file = new File("JTest/doc.txt");        if (!file.exists())            file.createNewFile();        RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");        //指针的位置        System.out.println(randomAccessFile.getFilePointer());        randomAccessFile.write('A');//只写了1个字节 'A'-->65-->01000001        System.out.println(randomAccessFile.getFilePointer());        randomAccessFile.write('B');        System.out.println(randomAccessFile.getFilePointer());        int x = 0x7fffffff;        randomAccessFile.write(x >>> 24);//高8位        randomAccessFile.write(x >>> 16);        randomAccessFile.write(x >>> 8);        randomAccessFile.write(x);        System.out.println(randomAccessFile.getFilePointer());        //randomAccessFile.writeInt(x);        randomAccessFile.write("李广辉".getBytes());        System.out.println("文件长度：" + randomAccessFile.length());        //读文件，必须把指针移到头部        randomAccessFile.seek(0);        byte[] buf = new byte[(int) randomAccessFile.length()];        randomAccessFile.read(buf);        System.out.println(Arrays.toString(buf));        for (byte b : buf) {            System.out.print(Integer.toHexString(b & 0xff) + " ");        }        System.out.println();        System.out.println(new String(buf, "UTF-8"));        randomAccessFile.close();    }}

字节流的使用

InputStream:抽象了应用程序读取数据的方式

OutputStream:抽象了应用程序写入数据的方式

EOF end of file：读到-1就读到了结尾

输入流的基本方法：

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

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

in.read(byte[] buf, int start, int size);读取数据填充到字节数组buf，从buf的start位置开始，存放size长度的数据。

输出流：

out.write(int b);写出1个byte到流，b的低八位

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

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

FileInputStream-->具体实现了在文件上的输入操作

package com.imooc.io;import java.io.FileInputStream;import java.io.IOException;/** * Created by N3verL4nd on 2017/3/10. */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) {            i++;            if (b <= 0xf) {                //单位数前面补0                System.out.print("0");            }            System.out.print(Integer.toHexString(b) + " ");            if (i % 10 == 0) {                System.out.println();            }        }        in.close();    }    public static void printHexByByteArray(String fileName) throws IOException{        FileInputStream in = new FileInputStream(fileName);        byte[] buf = new byte[20 * 1024];        /**         * 从in中批量读取字节，放入buf这个字节数组中         * 从第0个位置开始做，最多放buf.length个字节         * 返回的是读到的字节的个数         */        /*int bytes = in.read(buf, 0, buf.length);        int j = 1;        for (int i = 0; i < bytes; i++) {            j++;            if (buf[i] <= 0xf) {                System.out.print("0");            }            System.out.print(Integer.toHexString(buf[i]) + " ");            if (j % 10 == 0) {                System.out.println();            }        }*/        int bytes;        while ((bytes = in.read(buf, 0, buf.length)) != -1) {            int j = 1;            for (int i = 0; i < bytes; i++) {                j++;                if (buf[i] <= 0xf) {                    System.out.print("0");                }                System.out.print(Integer.toHexString(buf[i] & 0xff) + " ");                if (j % 10 == 0) {                    System.out.println();                }            }        }    }}

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

package com.imooc.io;import java.io.FileOutputStream;import java.io.IOException;/** * Created by N3verL4nd on 2017/3/10. */public class FileOutDemo {    public static void main(String[] args) throws IOException {        //如果该文件不存在，则直接创建，如果不存在，则删除后创建        FileOutputStream out = new FileOutputStream("D:\\Java\\IdeaProjects\\JavaProj\\JTest\\doc.txt");        //out.write('A');        //out.write('B');        int x = 3389;        out.write(x >>> 24);        out.write(x >>> 16);        out.write(x >>> 8);        out.write(x);        //out.write("中国".getBytes());        IOUtil.printHex("D:\\Java\\IdeaProjects\\JavaProj\\JTest\\doc.txt");        out.close();    }}

package com.imooc.io;import java.io.*;/** * Created by N3verL4nd on 2017/3/10. */public class FileCopy {    public static void Copy(File src, File dst) throws IOException {        if (!src.exists()) {            throw new IllegalArgumentException(src + "不存在！");        }        if (!src.isFile()) {            throw new IllegalArgumentException(src + "不是文件！");        }        FileInputStream in = new FileInputStream(src);        FileOutputStream out = new FileOutputStream(dst);        int len;        byte[] buf = new byte[1024];        while ((len = in.read(buf, 0, 1024)) != -1) {            out.write(buf, 0, len);        }        in.close();        out.close();    }    public static void main(String[] args) {        try {            Copy(new File("D:\\N3verL4nd\\Desktop\\Pro.txt"), new File("D:\\Java\\IdeaProjects\\JavaProj\\JTest\\doc.txt"));        } catch (IOException e) {            e.printStackTrace();        }    }}

DataOutputStream/DataInputStream

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

DataOutputStream

writeInt()，writeDouble()，writeUTF()

package com.imooc.io;import java.io.*;/** * Created by N3verL4nd on 2017/3/11. */public class DosDemo {    public static void main(String[] args) throws IOException {        String filename = "D:\\Java\\IdeaProjects\\JavaProj\\JTest\\doc.txt";        DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));        out.writeInt(100);        out.writeDouble(1.1);        //采用UTF-8编码写出        out.writeUTF("你好");        //采用UTF-16BE编码写出        out.writeChars("中国");        out.close();//        IOUtil.printHex(filename);        DataInputStream in = new DataInputStream(new FileInputStream(filename));        System.out.println(in.readInt());        System.out.println(in.readDouble());        System.out.println(in.readUTF());        System.out.println(in.readChar());        System.out.println(in.readChar());        in.close();    }}

BufferedInputStream/BufferedOutputStream

这两个流为IO提供了带缓冲区的操作，一般打开文件进行读写都会加上缓冲区，从而提高IO性能。

字符流的使用

文本和文本文件：

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

文件是byte byte byte的数据序列

文本文件是文本序列按照某种编码方案（UTF-8/UTF-16BE,GBK）序列化为byte的存储文件

字符流（Reader和Writer）

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

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

字符流的基本实现

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

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

package com.imooc.io;import java.io.*;/** * Created by N3verL4nd on 2017/3/12. */public class OSWDemo {    public static void main(String[] args) {        String fileName = "D:\\N3verL4nd\\Desktop\\Pro.txt";        InputStreamReader isr = null;//默认项目编码        try {            isr = new InputStreamReader(new FileInputStream(fileName), "UTF-8");        } catch (UnsupportedEncodingException | FileNotFoundException e) {            e.printStackTrace();        }        /*try {            int c;            while ((c = isr.read()) != -1) {                System.out.print((char)c);            }            isr.close();        } catch (IOException e) {            e.printStackTrace();        }*/        char[] buf = new char[1024];        int len;        try {            //批量读取，放入buffer这个字符数组，从第0个位置开始，最多放1024个            //返回读取字符的个数            while ((len = isr.read(buf, 0, 1024)) != -1) {                System.out.print(new String(buf, 0, len));            }            isr.close();        } catch (IOException e) {            e.printStackTrace();        }    }}

FileReder/FileWriter继承自InputStreamReader/OutputStreamWriter，使其对文件读写更加方便。

package com.imooc.io;import java.io.FileNotFoundException;import java.io.FileReader;import java.io.IOException;/** * Created by N3verL4nd on 2017/3/12. */public class FRFW {    public static void main(String[] args) throws IOException {        FileReader reader = new FileReader("D:\\N3verL4nd\\Desktop\\Pro.txt");        int c;        while ((c = reader.read()) != -1) {            System.out.println(c);        }        reader.close();    }} 

字符流的过滤器

BufferedReader -->readLine 一次读一行
BufferedWriter -->writeLine一次写一行

package com.imooc.io;import java.io.*;/** * Created by N3verL4nd on 2017/3/10. */public class FileCopy {    public static void Copy(File src, File dst) throws IOException {        if (!src.exists()) {            throw new IllegalArgumentException(src + "不存在！");        }        if (!src.isFile()) {            throw new IllegalArgumentException(src + "不是文件！");        }        FileInputStream in = new FileInputStream(src);        FileOutputStream out = new FileOutputStream(dst);        int len;        byte[] buf = new byte[1024];        while ((len = in.read(buf, 0, 1024)) != -1) {            out.write(buf, 0, len);        }        in.close();        out.close();    }    public static void CopyFileByBuffer(File src, File dst) throws IOException {        if (!src.exists()) {            throw new IllegalArgumentException(src + "不存在！");        }        if (!src.isFile()) {            throw new IllegalArgumentException(src + "不是文件！");        }        BufferedInputStream in = new BufferedInputStream(new FileInputStream(src));        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(dst));        int len;        byte[] buf = new byte[1024];        while ((len = in.read(buf, 0, 1024)) != -1) {            out.write(buf, 0, len);//            out.flush();//刷新缓冲区        }        in.close();        out.close();    }    public static void main(String[] args) {        try {            long start = System.currentTimeMillis();            CopyFileByBuffer(new File("F:\\H4ck\\bjut\\db.html"), new File("D:\\Java\\IdeaProjects\\JavaProj\\JTest\\doc.txt"));            //Copy(new File("F:\\H4ck\\bjut\\db.html"), new File("D:\\Java\\IdeaProjects\\JavaProj\\JTest\\doc.txt"));            long end = System.currentTimeMillis();            System.out.println(end - start);        } catch (IOException e) {            e.printStackTrace();        }    }}

package com.imooc.io;import java.io.*;/** * Created by N3verL4nd on 2017/3/12. */public class BRBW {    public static void main(String[] args) throws IOException {        BufferedReader reader = new BufferedReader(                new InputStreamReader(                        new FileInputStream("D:\\N3verL4nd\\Desktop\\Pro.txt")                ));        while (reader.ready()) {            System.out.println(reader.readLine());        }        reader.close();    }}

对象的序列化和反序列化

对象的序列化就是将Objext转换成byte序列，反之叫做反序列化。

序列化流：ObjextOutputStream--->writeObject

反序列化：ObjectInputStream--->readObject

序列化接口（Serializable）

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

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

package com.imooc.io;import java.io.Serializable;/** * Created by N3verL4nd on 2017/3/12. */public class Student implements Serializable{    private String stuNO;    private String name;    private int age;    public Student() {    }    public Student(String stuNO, String name, int age) {        this.stuNO = stuNO;        this.name = name;        this.age = age;    }    public String getStuNO() {        return stuNO;    }    public void setStuNO(String stuNO) {        this.stuNO = stuNO;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    @Override    public String toString() {        return "Student{" +                "stuNO='" + stuNO + '\'' +                ", name='" + name + '\'' +                ", age=" + age +                '}';    }}

package com.imooc.io;import java.io.*;/** * Created by N3verL4nd on 2017/3/12. */public class ObjectSerializable {    public static void main(String[] args) {        String fileName = "D:\\Java\\IdeaProjects\\JavaProj\\JTest\\src\\com\\imooc\\io\\doc\\data.dat";        Student student = new Student("10010", "lgh", 24);        try {            //对象的序列化            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(fileName));            //把student对象保存起来            out.writeObject(student);            out.close();            ObjectInputStream in = new ObjectInputStream(new FileInputStream(fileName));            Student stu = (Student) in.readObject();            System.out.println(stu);        } catch (IOException | ClassNotFoundException e) {            e.printStackTrace();        }    }}

private transient int age;//该元素不会进行虚拟机默认的序列化工作

该元素不会进行虚拟机默认的序列化工作，也可以自己完成这个元素的序列化

我们可以参考ArrayList的相关操作：

private void readObject(java.io.ObjectInputStream s)    throws java.io.IOException, ClassNotFoundException {    elementData = EMPTY_ELEMENTDATA;    // Read in size, and any hidden stuff    s.defaultReadObject();    // Read in capacity    s.readInt(); // ignored    if (size > 0) {        // be like clone(), allocate array based upon size not capacity        ensureCapacityInternal(size);        Object[] a = elementData;        // Read in all elements in the proper order.        for (int i=0; i<size; i++) {            a[i] = s.readObject();        }    }}

private void writeObject(java.io.ObjectOutputStream s)    throws java.io.IOException{    // Write out element count, and any hidden stuff    int expectedModCount = modCount;    s.defaultWriteObject();    // Write out size as capacity for behavioural compatibility with clone()    s.writeInt(size);    // Write out all elements in the proper order.    for (int i=0; i<size; i++) {        s.writeObject(elementData[i]);    }    if (modCount != expectedModCount) {        throw new ConcurrentModificationException();    }}

package com.imooc.io;import java.io.IOException;import java.io.ObjectOutputStream;import java.io.Serializable;import java.util.ArrayList;/** * Created by N3verL4nd on 2017/3/12. */public class Student implements Serializable{    private String stuNO;    private String name;    private transient int age;//该元素不会进行虚拟机默认的序列化工作    public Student() {    }    public Student(String stuNO, String name, int age) {        this.stuNO = stuNO;        this.name = name;        this.age = age;    }    public String getStuNO() {        return stuNO;    }    public void setStuNO(String stuNO) {        this.stuNO = stuNO;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    @Override    public String toString() {        return "Student{" +                "stuNO='" + stuNO + '\'' +                ", name='" + name + '\'' +                ", age=" + age +                '}';    }    private void writeObject(java.io.ObjectOutputStream s)            throws java.io.IOException{        //按照jvm默认序列化的元素进行序列化操作        s.defaultWriteObject();        //自己完成age的序列化操作        s.writeInt(age);    }    private void readObject(java.io.ObjectInputStream s)            throws java.io.IOException, ClassNotFoundException {        s.defaultReadObject();        this.age = s.readInt();    }}

transient Object[] elementData; // non-private to simplify nested class access

ArrayList所做的是数组有效数据元素的序列化操作

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

序列化中子类和父类构造函数的调用问题：

对子类对象进行反序列化操作时，

如果其父类没有实现序列化接口，那么其父类的构造函数会被调用。

package com.imooc.io;import java.io.*;/** * Created by N3verL4nd on 2017/3/12. */class A{    public A() {        System.out.println("A");    }}class B extends A implements Serializable{    public B() {        System.out.println("B");    }}class C extends B{    public C() {        System.out.println("C");    }}public class Demo {    public static void main(String[] args) {        C c = new C();        try {            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("data.dat"));            out.writeObject(c);            out.close();            System.out.println("---------------------");            ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.dat"));            in.readObject();        } catch (IOException | ClassNotFoundException e) {            e.printStackTrace();        }    }}