Java中的IO流

很重要的一个java基础内容

什么是流 ？

在Java程序中，数据的输入/输出操作以“流”（Stream）方式进行；JavaAPI提供了各式各样的流类，用以获取不同种类的数据。

Java中IO流分为几种

• 按流向分，可以分为输出流和输入流
• 按操作单元划分，可以分为字节流和字符流
• 按流的角色分，可以分为节点流和处理流

Java IO流中涉及40多个类，但都是从4个抽象类派生出来的。

• Writer/OutputStream:所有输出流的基类，前者是字符流，后者是字节流
• Reader/InputStream:所有输入流的基类，前者是字符流，后者是字节流

按操作方式化分流

按操作对象划分

• 节点流：相当于一根管道，给数据一个通道，进入或出去
• 处理流：包裹管道的一个东西，所以处理流构造方法中一般会传入一个 它的父类型的对象

常用的几个IO流

1.缓冲流

• BufferedOutputStream

  //向文件中输入字符
  public class BufferedOutputStreamDemo1 {
      public static void main(String[] args) throws Exception {
          BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test.txt"));
          for(int i=48;i<100;i++) {
              bos.write((char)i);
          }
          bos.flush();
      }
  }
  

• BufferedInputStream

public class BufferedInputStreamDemo1 {
    public static void main(String[] args) throws Exception {
        int b = 0;
        FileInputStream fis = new FileInputStream("offeroffer.iml");
        BufferedInputStream bis = new BufferedInputStream(fis);
//        System.out.println((char) bis.read());
//        System.out.println((char) bis.read());

        bis.mark(1);//在第20个字符处标记
        for (int i = 0; i < 10 && (b = bis.read()) != -1; i++) {
            System.out.print((char) b);
        }
        System.out.println();
        bis.reset();//让光标位置重新回到标记处
        b = 0;
        for (int i = 0; i < 10 && (b = bis.read()) != -1; i++) {
            System.out.print((char) b);
        }
        System.out.println();
        bis.reset();//让光标位置重新回到标记处
        b = 0;
        for (int i = 0; i < 10 && (b = bis.read()) != -1; i++) {
            System.out.print((char) b);
        }
    }
}

2.文件流

• FileInputStream

/**
 * 文件输入流Demo1
 * 用字节流读取文件内容含有中文的时候会出现乱码
 * 原因是因为  字节流读取的单位是8位 一个字节
 * 中文的单位为16位  两个字节  所以每次读取都只能读取一半的字节  就会出现乱码。
 * 当有中文的时候，建议使用FileReader 每次读取一个字符，英文和中文都能正常显示
 */
public class FileInputStreamDemo1 {

    public static void main(String[] args) {

        int b = 0;//接收返回的数据字节

        FileInputStream fis = null;
        try {
            fis = new FileInputStream(new File("E:/java/cd5m/offeroffer/src/com/iostream/FileInputStreamDemo1.java"));
        } catch (FileNotFoundException e) {
            System.out.println("未找到指定文件");
            System.exit(-1);
        }

        int num = 0;//记录总共读取的字节数

        try {
            while ((b = fis.read()) != -1) {
                //读取到-1的时候说明已经到了文件末尾了
                System.out.print((char)b);
                num++;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("总共读取了 "+num+" 个字节");
    }

}

• FileOutputStream

/**
 * 文件输出流练习
 * 字节输出流当输出的内容占2个字节 也会出现乱码的前情况
 */
public class FileOutputStreamDemo1 {
    public static void main(String[] args) {
        int b = 0;
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try {
            fis = new FileInputStream(new File("offeroffer.iml"));//读取文件内容
            fos = new FileOutputStream(new File("test.txt"));//输出内容到文件
        } catch (FileNotFoundException e) {
            System.out.println("未找到指定文件");
            System.exit(-1);
        }

        try {
            while ((b=fis.read())!=-1){
                fos.write(b);
            }
        } catch (IOException e) {
            System.out.println("复制文件失败");
        }

        System.out.println("文件复制成功");

    }
}

• FileWriter && FileReader

public class FileWriterReaderDemo1 {
    public static void main(String[] args) throws IOException {
        //将1~~6000的字符数据写入到文件 data.dat中
        FileWriter fw = null;
        try {
            fw = new FileWriter(new File("data.dat"));
            for (int i=1;i<=60000;i++){
                fw.write(i);
            }
        } catch (IOException e) {
            System.out.println("写入数据失败");
            System.exit(-1);
        }

        FileReader fr = new FileReader(new File("data.dat"));
        int b = 0;
        while((b=fr.read())!=-1){
            System.out.println(b);
        }


        fw.close();


    }
}

3.数据流

• DataOutputStream & DataInputStream

public class DataStreamDemo1 {
    public static void main(String[] args) throws IOException {
        //调用构造方法的时候会在内存中创建一个ByteArray字节数组
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        //套接上一层数据流，用来处理int double 类型的数据
        DataOutputStream dos = new DataOutputStream(baos);
        //写入的数据都会存放在  ByteArrayOutputStream  的Byte 数组buf里面
        dos.writeBoolean(false); //写入boolean类型的数据
        dos.writeDouble(Math.random());

        //读取刚刚的数据，要按照存放的顺序读取
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        System.out.println(bais.available());
        //包装一层数据流，用来读取int double 类型的数据
        DataInputStream dis = new DataInputStream(bais);
        System.out.println(dis.readBoolean());
        System.out.println(dis.readDouble());

    }
}

4.转换流

• OutputStreamWriter

public class OutputStreamWriterDemo1 {
    public static void main(String[] args) throws Exception {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("test.txt"));
        osw.write("Hello World!");
        System.out.println(osw.getEncoding());
        osw.close();

    }
}

• InputStreamReader

public class InputStreamReaderDemo1 {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        String s = br.readLine();
        while (s != null) {
            if (s.equals("exit")) break;
            System.out.println(s);
            s = br.readLine();
        }
        br.close();
        isr.close();
    }
}

暂时就记录到这里，学到了更多的知识再进行记录 有问题请联系 QQ914456697

不怕学得少，就怕不学习