美文网首页Java学习笔记
Java中的输入输出流

Java中的输入输出流

作者: 篱开罗 | 来源:发表于2017-03-08 17:17 被阅读126次

    InputStream(OutputStream)

    InputStream(OutputStream)每次只能读写一个字节或一个字
    节数组,若要读取或者写入如int,double等数据需要自行处理成字
    节再进行读写。

    FileInputStream为InputStream接口的一个实现类,方便文件
    读取

    • 单字节读取
        public static void inputStreamTest(String fileName) throws IOException {
        
                FileInputStream fileInputStream  = new FileInputStream(fileName);
                int i = 0;
                while ((i = fileInputStream.read()) != -1) {
                    System.out.print(Integer.toHexString(i) + " ");
                }
                fileInputStream.close();
            }
        
    //每次写入一个字节
        public static void fileOutputStreamTest(String fileName) throws IOException {
    
            FileOutputStream out = new FileOutputStream(fileName, true);
            //写出A字符的低8位
            out.write('A');
            out.write(1);
            out.write("哈喽".getBytes());
    
    
            out.close();
        }
    
    • 读取到字节数组
        public static void inputStreamTest2(String fileName) throws IOException {
        
                FileInputStream fileInputStream = new FileInputStream(fileName);
                byte[] buf = new byte[1024 * 2];
                int size = 0;
        
                while ((size = fileInputStream.read(buf)) != -1) {
                    for (int i = 0; i < size; i++) {
                        if (i % 10 == 0 && i != 0) {
                            System.out.println();
                        }
                        System.out.print(Integer.toHexString(buf[i] & 0xff) + " ");
                    }
                }
        
                fileInputStream.close();
        
            }
    
    //每次读写一个字节数组的数据比读取单个字节效率高很多
        public static void copyByBytes(File srcFile, File destFile) throws IOException {
    
            if (!srcFile.exists()) {
                throw new IllegalArgumentException("source file not exists!");
            } else if (!srcFile.isFile()) {
                throw new IllegalArgumentException("source file must be file!");
            }
    
            FileInputStream inputStream = new FileInputStream(srcFile);
            FileOutputStream outputStream = new FileOutputStream(destFile);
    
            byte[] buf = new byte[1024 *1024];
            int size = 0;
            while ((size = inputStream.read(buf)) != -1) {
                outputStream.write(buf, 0, size);
                outputStream.flush();
            }
    
            inputStream.close();
            outputStream.close();
        }
    
    • DataInputStream的使用

    DataOutputStream(DataInputStream)为InputStream
    (OutputStream)提供包装,方便读取int,double,UTF等
    数据类型

        public static void DataInputStreamTest(String fileName) throws IOException {
        
                DataInputStream dataInputStream =
                        new DataInputStream(new FileInputStream(fileName));
        
                System.out.println(dataInputStream.readInt());
                System.out.println(dataInputStream.readDouble());
                System.out.println(dataInputStream.readUTF());
                System.out.println(dataInputStream.readChar());
        
            }
        
        public static void DataOutputStreamTest(String fileName) throws IOException {
        
                DataOutputStream dataOutputStream =
                        new DataOutputStream(new FileOutputStream(fileName));
        
                dataOutputStream.writeInt(1);
                dataOutputStream.writeDouble(1.1);
                dataOutputStream.writeUTF("哈喽");
                //UTF-16be编码格式,char占两个字节
                dataOutputStream.writeChars("哈哈");
        
                dataOutputStream.close();
        
            }
    
    
    • 使用BufferedInputStream

    BufferedInputStream提供了缓冲读取,读取时判断是否可以
    从该类自带的缓冲区中读取,提高效率。

    多次从流中读取少量字节时候效率较高

    使用read(byte[] b)进行读取时,若缓冲区小于b的大小则每次
    直接从流中读取,并更新缓冲区,效率与直接使用InputStream
    的read(byte[])相当,若缓冲区大小大于b,则效率反而会降低

    public static void copyByBuffer(File srcFile, File destFile) throws IOException {
    
            if (!srcFile.exists()) {
                throw new IllegalArgumentException("source file not exists!");
            } else if (!srcFile.isFile()) {
                throw new IllegalArgumentException("source file must be file!");
            }
    
            BufferedInputStream bis = new BufferedInputStream(
                    new FileInputStream(srcFile));
    
            BufferedOutputStream bos = new BufferedOutputStream(
                    new FileOutputStream(destFile));
    
            byte[] buf = new byte[1024 * 1024];
    
            int c = 0;
            while ((c = bis.read(buf)) != -1) {
                bos.write(buf, 0, c);
            }
    
            bis.close();
            bos.close();
    
        }
    

    Reader(Writer)

    Reader和Writer简化了字符的读写,可以不用手动对字节进行
    处理,而直接面向字符。

    • InputStreamReader(Writer)
        public static void InputStreamReaderTest(File file) throws IOException {
        
                FileInputStream fi = new FileInputStream(file);
                InputStreamReader reader = new InputStreamReader(fi);
                OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(new File("c.txt")));
        
        
                int c = 0;
                char[] buf = new char[1024];
                while ((c = reader.read(buf, 0, buf.length)) != -1){
                    String s = new String(buf, 0, c);
                    writer.write(s);
                    System.out.println(s);
                }
        
                reader.close();
                writer.close();
        
            }
    
    • FileReader(Writer)

    FileReader(Writer)简化了对文件的字符的读写

        public static void fileReaderTest(File file) throws IOException {
        
                FileReader fileReader = new FileReader(file);
                FileWriter fileWriter = new FileWriter("c.txt");
        
                char[] buf = new char[1024];
                int c = 0;
                while ((c = fileReader.read(buf, 0, buf.length)) != -1) {
                    fileWriter.write(buf, 0, c);
                }
        
                fileReader.close();
                fileWriter.close();
            }
    
    • BufferedReader(Writer)

    BufferedReader(Writer)对Reader(Writer)进行包装,简化
    字符的读写操作。

        public static void bufferedReaderTest(File file) throws IOException {
        
                BufferedReader br = new BufferedReader(new FileReader(file));
                BufferedWriter bw = new BufferedWriter(new FileWriter("c.txt"));
                //PrintWriter更方便
                PrintWriter pw = new PrintWriter("d.txt");
        
        
                String line = "";
                while ((line = br.readLine()) != null) {
                    pw.println(line);
                    bw.write(line);
                    bw.newLine();//换行
                }
        
        
                br.close();
                bw.close();
                pw.close();
        
            }
    

    ObjectInputStream(OutputStream)

    需要实现Serializable接口才能进行序列化

    没有实现Serializable接口的父类,反序列化时构造函数会被调用

    transient关键字指定某个属性不进行序列化,并手动进行序列化

    • Student类
    public class Student implements Serializable{
    
        private transient int age;
        private String name;
    
        public Student() {
        }
    
        public Student(int age, String name) {
            this.age = age;
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    
        //手动反序列化
        private void readObject(java.io.ObjectInputStream s)
                throws java.io.IOException, ClassNotFoundException {
            s.defaultReadObject();//jvm默认可以反序列化的反序列化
            age = s.readInt();//默认不行的手动反序列化
        }
    
        //手动序列化
        private void writeObject(java.io.ObjectOutputStream s)
                throws java.io.IOException{
            s.defaultWriteObject();//jvm默认可以序列化的进行序列化
            s.writeInt(age);//不能序列化的手动序列化
        }
    }
    
    • 序列化操作
    public static void objectSeriaTest(Student student) throws IOException, ClassNotFoundException {
    
            ObjectOutputStream outputStream = new ObjectOutputStream(
                    new FileOutputStream("object.txt")
            );
    
            ObjectInputStream inputStream = new ObjectInputStream(
                    new FileInputStream("object.txt")
            );
    
            outputStream.writeObject(student);
            Student stu = (Student) inputStream.readObject();
            System.out.println(stu);
    
            outputStream.close();
            inputStream.close();
    
        }
    

    Reference

    文件传输基础——Java IO流

    相关文章

      网友评论

        本文标题:Java中的输入输出流

        本文链接:https://www.haomeiwen.com/subject/ewabgttx.html