5、java的IO操作

1、byte与String相互转化：
1.1 String转byte:
String str = “哈哈666”;
byte[] bytes = str.getBytes(“gbk”); //str转为bytes，告诉系统我要将gbk转为bytes,如果这里不声明gbk,就是用项目默认编码
1.2 byte转String:
1.2.1 不声明转码会默认用项目编码将byte转为字符串：
String str1 = new String(bytes)
System.out.println(str1)
1.2 声明编码：
String str3 = new String(bytes,’gbk’)//哈哈666
String str4 = new String(bytes,’utf8’) //乱码
String str5 = new String(bytes,’utf16be’)//乱码
【注】：如果str是GBK，就是转成字节是GBK转过去的字节bytes,如果在把bytes转出来显示也必须是转成gbk，转成其他的都会乱码

2、File类(java.io.File) ：File表示文件、目录信息(名称、大小等)，不能访问文件内容
2.1 常用api：
file.exists(); //文件是否存在
file.getName();//获取文件名称
file.delete(); //删除文件
file.createNewFile();//创建新文件
file.mkdir();//创建以及目录
file.mkdirs();//创建多级目录
file.getAbsolutePath();//返回文件绝对路径
file.getAbsoluteFile();//返回文件绝对路径
file.getPath();//返回文件相对路径
file.getParent();//返回父目录
file.getParentFile();//返回父文件
file.list();//返回目录所有列表

2.2 列出目录下所有文件：
public void listDir(String fileDir) throws Exception{

    System.out.println(fileDir);
    File dir = new File(fileDir);
    if(!dir.exists()){
        throw new Exception("文件不存在");
    }
    if(!dir.isDirectory()){
        throw new Exception("必须要传入一个文件夹");
    }

// String filenames[] = file.list(); //返回当前目录下所有名称，字符串数组
File[] files = dir.listFiles(); //返回当前目录下所有文件，文件数组
if(files != null && files.length > 0){
for(File file : files){
if(file.isDirectory()){
this.listDir(file.getAbsolutePath());
}else{
System.out.println(fileDir + ‘/’ + file.getName());
}
}
}
}

3、RandomAccessFile：既可以读取文件内容，又可以写文件，并且可以随机访问文件，访问文件任何位置
3.1 硬盘上的文件是byte、byte、byte存储的,是数据的集合
3.2 打开文件有两种方式：
rw(读写)、r(读)
RandomAccessFile raf = new RandomAccessFile(file,’rw’);
打开文件时，指针在开头poiner = 0
3.3 写方法
raf.write(int) —–>只写一个字节(后8bit)，同时指针指向下个位置，准备写入
3.4 读方法
int b = raf.read()—>都一个字节
3.5 文件读写完成后一定要关闭

4、IO流（输入、输出流）
4.1 字节流：
4.1.1 InputStream、OutputStream(都是抽象类)
InputStream：抽象了应用程序读取数据的方式
OutputStream抽象了应用程序写出数据的方式
4.1.2 结束：EOF=End 读到-1就读到结尾
4.1.3 输入流基本方法
int b = in.read();读取一个字节无符号填充到int第8位，-1是EOF
in.read(byte[] buf);读取数据直接填充到字节数组
in.read(byte[] buf,int start,int size);读取数据直接填充到字节数组,从start开始放，放多少size长度的数据
4.1.4 输出流基本方法
out.write(int b) 写出一个byte到流，b的第8位
out.write(byte[] buf);
out.write(byte[] buf,int start,int size);
4.1.5 FileInputStream：具体实现了在文件上读取数据到内存
FileOutputStream：从内存读取到文件
创建：FileOutputStream out = new FileOutputStream(“E:/aa.dat”);
追加：FileOutputStream out = new FileOutputStream(“E:/aa.dat”,true); //如果第二个参数不传true，则被清空

【FileInputStream事例】从文件中读取
            方法一：一个一个字节读取
            /**
             * 一个一个字节读取，读取指定文件内容,按照16进制输出到控制台，并且每输出10bit换行
             * @param dir
             * @throws Exception
             */
            public void test(String filename) throws Exception{
                //把文件作为字节流进行操作
                FileInputStream in = new FileInputStream(filename);
                int b;
                int i = 1;
                while((b = in.read()) != -1){  //一次一个字节
                    System.out.println(Integer.toHexString(b)+" ");
                    if(i++ % 10 == 0){
                        System.out.println("\n");
                    }
                }
            }
            方法二：一块一块读取
            /**
             * 批量读取，开辟内存读取一块一块读取，非一个一个字节读取，读取指定文件内容,按照16进制输出到控制台，并且每输出10bit换行
             * @param dir
             * @throws Exception
             */
            public void test(String filename) throws Exception{
                FileInputStream in = new FileInputStream(filename);
                byte[] buf = new byte[20*1024]; //暂时缓冲
                //从in中批量读取字节吗放入到buf这个字节数组中，从第0个位置开始放，最多放buf.length个，返回的是读到的字节个数
                int bytes = 0;
                int j = 1;
                while((bytes = in.read(buf,0,buf.length)) != -1){
                    for(int i=0;i<bytes;i++){
                        System.out.println(Integer.toHexString(buf[i])+" ");
                        if(j++ % 10 == 0){
                            System.out.println("\n");
                        }
                    }
                }
            }


            【FileOutputStream事例】向文件中写入

            创建：FileOutputStream out = new FileOutputStream("E:/aa.dat");
            追加：FileOutputStream out = new FileOutputStream("E:/aa.dat",true); //如果第二个参数不传true，则被清空

            方法一：一个字节一个字节写入：
            /**
             * 拷贝文件
             * @param src
             * @param des
             * @throws Exception
             */
            public void copyFile(File src,File des) throws Exception{

                if(!src.isFile()){
                    throw new Exception("src不是一个文件");
                }

                FileInputStream in = new FileInputStream(src);
                FileOutputStream out = new FileOutputStream(des);

                int b ;
                while( (b= in.read()) != -1){ //读取文件到buf(缓冲区)
                    out.write(b);//从buf(缓冲区)读取出来写到文件
                    out.flush();//手动清空缓冲数据
                }
                in.close();
                out.close();
            }

             方法二：批量写入
            /**
             * 批量写入文件
             * 拷贝文件
             * @param src
             * @param des
             * @throws Exception
             */
            public void copyFile(File src,File des) throws Exception{

                if(!src.isFile()){
                    throw new Exception("src不是一个文件");
                }

                FileInputStream in = new FileInputStream(src);
                FileOutputStream out = new FileOutputStream(des);
                byte[] buf = new byte[8*1024];
                int b ;
                while( (b= in.read(buf,0,buf.length)) != -1){ //读取文件到buf(缓冲区)
                    out.write(buf,0,b);//从buf(缓冲区)读取出来写到文件
                    out.flush();//手动清空缓冲数据
                }
                in.close();
                out.close();
            }


    4.1.6  DataOutputStream、DataInputStream （就是对FileOutputStream\FileInputStream包装了一层）：对"流"功能的扩展,可以更方便读取int、long、字符等类型数据
        4.1.6.1 DataOutputStream:   
            writeInt()\writeDouble()\writeUTF()//UTF:中文汉字以utf8编码输出

            事例：
                String file = "E:/www/test66";
                DataOutputStream dos = new DataOutputStream(new FileOutputStream(file));
                dos.writeInt(10);
                dos.writeInt(-10);
                dos.writeLong(10l);
                dos.writeDouble(10.8);
                dos.writeUTF("牛逼");//以UTF-8形式写出
                dos.close();

        4.1.6.2 DataInputStream:
            readInt()\readDouble()\readUTF()//UTF:中文汉字以utf8编码输出

            事例：
                    String file = "E:/www/test66";
                    DataInputStream dis = new DataInputStream(new FileInputStream(file));
                    int i1 = dis.readInt();
                    System.out.println(i1);
                    int i2 = dis.readInt();
                    System.out.println(i2);
                    long i3 = dis.readLong();
                    System.out.println(i3);
                    Double i4 = dis.readDouble();
                    System.out.println(i4);
                    String i5 = dis.readUTF();
                    System.out.println(i5);


    4.1.7 BufferedInputStream、BufferedOutputStream：为IO读写提供了缓冲区，性能更高

          性能高体现：
          从应用程序中把输入放入文件，相当于把一缸水到入另一缸中：
          FileOutputStream->wirte :相当于一滴一滴转移
          DataOutputStream->writeXxx:相当于一瓢一瓢转移
          BufferedOutputStream->write:相当于一瓢一瓢先放入桶(缓冲)中,然后一起把桶中的倒入缸中

        利用缓冲区写入
        /**
         * 拷贝文件
         * @param src
         * @param des
         * @throws Exception
         */
        public void test(File src,File des) throws Exception{

            if(!src.isFile()){
                throw new Exception("src不是一个文件");
            }

            BufferedInputStream in = new BufferedInputStream(new FileInputStream(src));
            BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(des));
            int b ;
            while( (b= in.read()) != -1){ //读取文件到buf(缓冲区)
                out.write(b);//从buf(缓冲区)读取出来写到文件
                out.flush();//刷新缓冲区
            }
            in.close();
            out.close();
        }



4.2 字符流  
    4.2.1 编码问题
    4.2.2 认识文本和文本文件：
        4.2.2.1 java的文本（char）是16位无符号整数,是字符的unicode编码(双字节编码)文件是byte byte byte...的数据序列
        4.2.2.2 文本文件是文本(char)按照某种编码方案(utf-8、utf-16be、gbk..)序列化为byte存储的
    4.2.3 字符流（Reader\Writer）：操作的是文本文件
        字符处理：一次处理一个字节，字符底层依然是基本的字节序列
        字符流基本实现：
            InputStreamReader   完成byte流解析为char流，按照编码解析
            OutputStreamWrite   提供char流到byte流，按照编码处理

            事例：
            【读取文件操作】：
            FileInputStream in = new FileInputStream("E:/www/MyEclipse10/note.java");
            InputStreamReader isr = new InputStreamReader(in,"utf-8"); //如果note.java是utf-8,那这里就要设置utf-8,否则读出来就是乱码,不写的话默认是项目编码
            int b;

    //      //一次读一个字符
    //      while((b = isr.read()) != -1){
    //          System.out.println((char)b);
    //      }

            //批量读取
            char[] buffer = new char[8*1024];//一次读8M
            while((b = isr.read(buffer,0,buffer.length)) != -1){
                String s = new String(buffer,0,b);
                System.out.println(s);
            }



            【读取、写入】
            //获取InputStreamReader对象
            FileInputStream in = new FileInputStream("E:/www/MyEclipse10/note.java");
            InputStreamReader isr = new InputStreamReader(in,"gb2312");
            //获取OutputStreamWriter对象
            FileOutputStream out = new FileOutputStream("E:/www/MyEclipse10/note2.java");
            OutputStreamWriter osw = new OutputStreamWriter(out,"gb2312");

            //批量读取、写入
            int b;
            char[] buffer = new char[8*1024];//一次读8M
            while((b = isr.read(buffer,0,buffer.length)) != -1){
                osw.write(buffer, 0, b);
                osw.flush();
            }
            isr.close();
            osw.close();



    4.2.4 FileReader\FileWrite:专门处理文件的
            【注】：无法设置读、取编码，只能根据项目便来来读取
            FileReader fr = new FileReader("E:\\www\\MyEclipse10\\note2.java");
            FileWriter fw = new FileWriter("E:\\www\\MyEclipse10\\note4.java",true); //第二个参数true是追加
            char[] buffer = new char[2048];
            int b ;
            while((b = fr.read(buffer,0,buffer.length))!=-1){
                fw.write(buffer,0,b);
                fw.flush();
            }

            fr.close();
            fw.close();
        }

    4.2.5 字符流过滤器(BufferedReader、BufferedWriter)：

        【读取、写入】
        方法一：
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("E:/www/MyEclipse10/note2.java")));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("E:/www/MyEclipse10/note3.java")));

        String line;
        while((line = br.readLine()) != null){ //一次读取一行，不会自动加换行
            System.out.println(line);
            bw.write(line);
            bw.newLine(); //换行操作
            bw.flush();
        }

        br.close();
        bw.close();


        方法二：使用PrintWriter替代BufferedWriter
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("E:/www/MyEclipse10/note2.java")));
//      BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("E:/www/MyEclipse10/note3.java")));
        PrintWriter pw = new PrintWriter("E:/www/MyEclipse10/note4.java");
        String line;
        while((line = br.readLine()) != null){ //一次读取一行，不会自动加换行
            System.out.println(line);
            pw.println(line); //换行直接println，不换行print
            pw.flush();
        }

        br.close();
        pw.close();

5、序列化：
5.1 对象序列化、反序列化
5.2 对象序列化，就是将Object转换成bytexulie,反之叫对象的反序列化
5.3 序列化流(ObjectOutputStream),是过滤流—writeObject
反序列化流(ObjectInputStream),是过滤流—readObject
5.4 序列化接口(Serializable)
对象序列化必须实现接口Serializable，才能进行序列化，否则将出现异常，这个接口没有任何方法，只是一个标准

【事例】

    public class Student implements Serializable{

        private String stuno;
        private String stuname;
        private int stuage;

        public Student(){

        }

        public Student(String stuno,String stuname,int stuage){
            this.stuno = stuno;
            this.stuname = stuname;
            this.stuage = stuage;
        }

        public String getStuno() {
            return stuno;
        }
        public void setStuno(String stuno) {
            this.stuno = stuno;
        }
        public String getStuname() {
            return stuname;
        }
        @Override
        public String toString() {
            return "Student [stuno=" + stuno + ", stuname=" + stuname + ", stuage="
                    + stuage + "]";
        }
        public void setStuname(String stuname) {
            this.stuname = stuname;
        }
        public int getStuage() {
            return stuage;
        }
        public void setStuage(int stuage) {
            this.stuage = stuage;
        }
    }

    //序列化保存
    String file = "E:/www/MyEclipse10/stu.dat";
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
    Student stu = new Student("1001","张三",20);
    oos.writeObject(stu);
    oos.flush();
    oos.close();

    //反序列化读取
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
    Student oldstu = (Student)ois.readObject();
    ois.close();
    System.out.println(oldstu.getStuage());
    System.out.println(oldstu.getStuname());
    System.out.println(oldstu.getStuno());


5.5 transient  : transient修饰的属性，不会被jvm默认序列化，可以自己完成序列化

    例子：private transient int stuage;


    public class Student implements Serializable{

        private String stuno;
        private String stuname;
        private transient int stuage; //本来不会在jvm默认序列化，但是writeObject、readObject会使其序列化

        public Student(){

        }

        public Student(String stuno,String stuname,int stuage){
            this.stuno = stuno;
            this.stuname = stuname;
            this.stuage = stuage;
        }

        public String getStuno() {
            return stuno;
        }
        public void setStuno(String stuno) {
            this.stuno = stuno;
        }
        public String getStuname() {
            return stuname;
        }
        @Override
        public String toString() {
            return "Student [stuno=" + stuno + ", stuname=" + stuname + ", stuage="
                    + stuage + "]";
        }
        public void setStuname(String stuname) {
            this.stuname = stuname;
        }
        public int getStuage() {
            return stuage;
        }
        public void setStuage(int stuage) {
            this.stuage = stuage;
        }

        private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
            s.defaultWriteObject();//将jvm能序列化的都给序列化
            s.writeInt(this.stuage); //自定义序列化
        }

        private void readObject(java.io.ObjectInputStream s) throws java.io.IOException,ClassNotFoundException{
            s.defaultReadObject(); //将jvm能反序列化的都给反序列化
            this.stuage = s.readInt(); //自定义反序列化
        }
    }




5.6 序列化中父类与子类构造方法的问题：序列化中如果父类序列化了，子类就不需要序列化

  5.6.1 ：子类序列化时，父类、子类都会调用构造方法
  5.6.2 : 反序列化时，如果父类没有实现序列化接口，会调用父类构造方法，如果父类实现了序列化接口，则父类不会被调用构造方法