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 : 反序列化时，如果父类没有实现序列化接口，会调用父类构造方法，如果父类实现了序列化接口，则父类不会被调用构造方法