zoukankan      html  css  js  c++  java

  • IO流学习

    什么是IO

    clipboard

    IO流的分类？

    有多种分类方式：

          一种方式是按照流的方向进行分类：

               以内存作为参照物，

                      往内存中去，叫做输入（input）。或者叫做读（Read）。

                      从内存中出来，叫做输出（Output）。或者叫做写（Write）。

         另一种方式是按照读取数据方式不同进行分类：

              有的流是按照字节的方式读取数据，依次读取1个字节byte，等同于一次读取8个二进制位。

              这种流是万能的，什么类型的文件都可以读取。包括：文本文件、图片、声音视频等。

                   假设文件file.txt，采用字节流的话是这样读的：

    a中国bc

    第一次读：一个字节，正好读到'a'

    第二次读：一个字节，正好读到'中'字符的一半。

    第三次读：一个字节，正好读到'中'字符的另外一半。

             有的流是按照字符的方式读取数据的，一次读取一个字符，这种流是为了方便读取普通文本

             文件而存在的，这种流不能读取：图片、声音、视频等文件。只能读取纯文本文件，连word

             文件都无法读取。

             假设文件file.txt，采用字符的方式的话是这样读的：

    a中国bc

    第一次读：'a'字符('a'字符在Windows中占用1个字节)

    第二次读：'中'字符（'中'字符在Windows中占用2个字节）

    综上所述：流的分类

    输入流、输出流

    字节流、字符流

    Java中的IO流都已经写好了，我们不需要关心。

    注意：IDEA默认的当前路径在哪里？工程Project的根就是IDEA的默认当前路径

    Java IO流这块有四大家族：

    java.io.InputStream 字节输入流

    java.io.OutputStream 自字节输出流

    java.io.Reader 字符输入流

    java.io.Writer 字符输出流

    流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭，不然会耗费（占用）很多资源。养成好习惯，用完流一定要关闭。

    所有的输出流都实现了：

    java.io.Flushable接口，都是可刷新的，都有flush()方法。

    养成一个好习惯，输出流在最终输出之后，一定要记得flush()刷新一下。

    这个刷新表示将通道/管道当中剩余未输出的数据强行输出玩（清空管道！）刷新的作用就是清空管道。注意：如果没有flush()可能会导致丢失数据。

    注意：在Java中只要“类名”以Stream结尾的都是字节流。以“Reader/Writer”结尾的都是字符流。

    java.io包下需要掌握的流有16个：

    文件专属：
java.io.FileInputStream    (掌握)
java.io.FileOutputStream   （掌握）
java.io.FileReader
java.io.FileWriter

转换流：（将字节流转换成字符流）
java.io.InputStreamReader
java.io.OutputStreamWriter

缓冲流专属：
    java.io.BufferedReader
    java.io.BufferedWriter
    java.io.BufferedInputStream
    java.io.BufferedOutputStream

数据流专属：
    java.io.DataInputStream
    java.io.DataOutputStream

标准输出流：
    java.io.PrintWriter    （掌握）
    java.io.PrintStream

对象专属流：
    java.io.ObjectInputStream   （掌握）
    java.io.ObjectOutputStream   （掌握

    案例1

    缺点：一次读取一个字节byte，这样内存和硬盘交互太频繁，基本上时间/资源都耗费在交互上面了。

    package com.superman.readertest;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Readtest {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("C:\test.txt");
//            while (true){
//                int readData = fis.read();
//                if (readData == -1){
//                    break;
//                }
//                System.out.println(readData);
//            }
            //改造while循环
            int readData = 0;
            while((readData = fis.read()) != -1){
                System.out.println(readData);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

    案例2 循环读取

    package com.superman.readertest;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamTest02 {
    //一次最多读取ｂ．ｌｅｎｇｔｈ个字节
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis =new FileInputStream("C:\test.txt");
            byte[] bytes = new byte[4];
//            while (true){
//                int readCount = fis.read(bytes);
//                if (readCount == -1){
//                    break;
//                }
//                System.out.println(new String(bytes,0,readCount));
//            }
            int readCount = 0;
            while((readCount =fis.read(bytes)) != -1){
                System.out.println(new String(bytes,0,readCount));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

    案例3 这种方式不适合大文件，因为byte[]数组不能太大

    package com.superman.readertest;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamTest02 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("C:\test.txt");
            System.out.println("总字节数" + fis.available());
            byte[] bytes = new byte[fis.available()];
            int readCount = fis.read(bytes);
            System.out.println(new String(bytes));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

    以追加的方式在文件末尾写入，不会清空源文件内容

    package com.superman.readertest;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamTest {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            fos  = new FileOutputStream("C:\test.txt",true);
            byte[] bytes = {97,98,99,100};
            fos.write(bytes);
            String s = "我是一个中国人";
            byte[] bs = s.getBytes();
            fos.write(bs);
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

    文件复制

    clipboard

    案例代码

    package com.superman.readertest;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopy {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("D:\test.avi");
            fos = new FileOutputStream("C:\test.avi");
            byte[] bytes =new byte[1024 * 1024];
            int readCount = 0;
            while((readCount = fis.read(bytes)) != -1){}
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }
}

    BufferedReader：

    带有缓冲区的字符输入流。

    使用这个流的时候不需要自定义char数组，或者说不需要自定义byte数组。自带缓冲。

    代码示例（读的时候不带换行符）

    package com.superman.readertest;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class BufferReaderTest {
    public static void main(String[] args) throws IOException {
        FileReader reader = null;
        try {
            reader = new FileReader("C:\test.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        BufferedReader br = new BufferedReader(reader);
        String s =null;
        while ((s = br.readLine()) != null){
            System.out.println(s);
        }
        try {
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

    数据专属流

    java.io.DataOutputStream : 数据专属的流，数据字节输出流。

    这个流可以将数据连同数据的类型一并写入文件。注意：这个文件不是普通的文本文档（这个文件记事本打不开）

    package com.superman.readertest;

import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataOutputStreamTest1 {
    public static void main(String[] args) {

        try {
            //创建数据专属的字节输出流
            DataOutputStream dos = new DataOutputStream(new FileOutputStream("data"));
            // 写数据
            byte b = 100;
            short s = 200;
            int i = 300;
            long l = 400L;
            float f = 3.0F;
            double d = 3.14;
            boolean sex = false;
            char c = 'a';
            //写
            dos.writeByte(b);
            dos.writeShort(s);
            dos.writeInt(i);
            dos.writeLong(l);
            dos.writeFloat(f);
            dos.writeDouble(d);
            dos.writeBoolean(sex);
            dos.writeChar(c);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

    java.io.DataInputStream： 数据字节输入流

    DataOutputStream写的文件，只能使用DataInputStream去读。并且读的时候你需要提前知道写入的顺序。读的顺序需要和写的顺序一致。才可以正常取出数据。

    package com.superman.readertest;

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class DataInputStreamTest1 {
    public static void main(String[] args) {
        try {
            DataInputStream dis = new DataInputStream(new FileInputStream("data"));
            //开始读
            byte b = dis.readByte();
            short s = dis.readShort();
            int i = dis.readInt();
            long l = dis.readLong();
            float f = dis.readFloat();
            double d = dis.readDouble();
            boolean sex = dis.readBoolean();
            char c = dis.readChar();

            System.out.println(b);
            System.out.println(s);
            System.out.println(i);
            System.out.println(l);
            System.out.println(f);
            System.out.println(d);
            System.out.println(sex);
            System.out.println(c);


        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }


    }
}

    标准输出流

    java.io.PrintStream：标准的字节输出流。默认输出到控制台。

    clipboard

    clipboard

    关于序列化和反序列化

    objectOutputStream负责序列化，ObjectInputStream负责反序列化

    clipboard

    1、参与序列化和反序列化的对象，必须实现Serializable接口

    2、如果不想要某个字段参与序列化操作，使用transient关键字，表示游离的，不参与序列化。
  • 相关阅读:
    KVM---利用 libvirt+qemu-kvm 创建虚拟机
    docker---安装docker
    Ubuntu---VIM 常用命令
    Ubuntu--- 安装VMware 报错 Build enviroment error!
    Ubuntu---不能打开 exfat 文件系统格式的 U盘解决方法
    Ubuntu---gedit 打开windows 下 .txt 文件乱码的解决方法
    MCS-51单片机的串行口及串行通信技术
    MCS-51单片机的定时器/计数器
    MCS-51单片机的中断系统
    计算机网络——网络层
  • 原文地址：https://www.cnblogs.com/sup3rman/p/15439314.html
Copyright © 2011-2022 走看看