IO流——常用IO流详解

时间：2024-04-30 16:15:20

1：字节流

　　字节流：用于处理以字节为单位的二进制文件（如音乐，图片等）

　　InputStream 是抽象类 它的对应子类FileInputStream可以被实例化

　　构造方法：

FileInputStream常用构造方法：

FileInputStream(File file) ：通过File对象创建FileInputStream对象。

FileInputStream(String name) ：通过文件（非“目录”）路径创建FileInputStream对象。

　　常用方法：

int read()：从输入流中读取单个字节的数据；如果已到达文件末尾，则返回 -1。

int read(byte[] b)：从输入流中将最多b.length个字节的数据读入一个byte数组中，以整数形 式返回存入数组中的实际字节个数；如果已到达文件末尾，则返回 -1。                           void close()：关闭此文件输入流并释放与此流有关的所有系统资源

OutputStream是抽象类，它的子类FileOutputStream可以被实例化

　　构造方法：　　　

FileOutputStream(File file) ：通过File对象创建FileOutputStream对象。

FileOutputStream(String name) ：通过文件（非“目录”）路径创建 FileOutputStream对象。

FileOutputStream(File file, boolean append)：通过File对象创建 FileOutputStream对象；第二个参数如果为true ，则字节将被写入文件的末尾而不是开头

　　常用方法：

FileOutputStream常用方法：

void write(int b)：将指定的单个字节数据写入此文件输出流。

void write(byte[] b, int off, int len)：将byte数组中从off开始的len个字节写入此文件输出流。

void flush()：刷新字节输出流并强制写出缓冲内所有字节数据。

void close()：关闭此文件输出流并释放与此流有关的所有系统资源。

package com.xt.io;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

public class FileInputStreamTest {

    public static void main(String[] args) {

        FileInputStream fis=null;

        FileOutputStream fos=null;

        try {

            /**

             * 读和写都是站在程序的角度来看的，读文件用FileInputStream  写文件用FileOutPutStream

             */

            fis=new FileInputStream("C:\\中心.jpg");

            fos=new FileOutputStream("D:\\重要.jpg");

            //第一种方法：一个字节一个字节的读

            /*int date;

            while((date=fis.read())!=-1) {

                System.out.println(date);

            }*/

            //第二种方法：1024个字节1024个字节的读

            byte[] bufferDate=new byte[1024];

            int length;

            while((length=fis.read(bufferDate))!=-1) {

                fos.write(bufferDate, 0, length);

            }

            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();

                }

            }

        }

    }

}

1.1：缓冲字节流

　　缓冲输入流：BufferedInputStream      BufferedInputStream(InputStream in)：

　　缓冲输出流：BufferedOutputStream  BufferedOutputStream(OutputStream out)

package com.xt.io;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

public class BufferInputStreamTest {

    public static void main(String[] args) {

        try {

            BufferedInputStream bufferedInputStream=new BufferedInputStream(new FileInputStream("C:\\中心.jpg"));

            BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(new FileOutputStream("D:\\重要k.jpg"));

            /*int b;

            while((b=bufferedInputStream.read())!=-1) {

                bufferedOutputStream.write(b);

            }*/

            byte[] bufferByte=new byte[1024];

            int length;

            while((length=bufferedInputStream.read(bufferByte))!=-1) {

                bufferedOutputStream.write(bufferByte, 0, length);

            }

            bufferedOutputStream.flush();

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

}

2：字符流

Reader是抽象类，它的子类FileReader 可以被实例化

　　构造方法：　　　

FileReader常用构造方法： FileReader(File file) ：通过File对象创建FileReader对象。

　　　　　　　　　　　　　　　　 FileReader(String fileName) ：通过文件（非“目录”）路径创建FileReader对象。

　　常用方法：

　　　　　　　　FileReader常用方法： int read()：从输入流中读取单个字符的数据，如果已到达流的末尾，则返回 -1 。

　　　　　　　　　　　　　　　　　　 int read(char[] cbuf)：从输入流中将最多cbuf.length个字符的数据读入一个char数组中，以整数形式返回存入

　　　　　　　　　　　　　　　　　　　　　　　数组中的实际字节个数，如果已到达流的末尾，则返回 -1 。

　　　　　　　　　　　　　　　　　　 void close()：关闭此文件输入流并释放与此流有关的所有系统资源。

　　Writer是抽象类，它的子类FileWriter可以被实例化

　　构造方法：

　　　　　　FileWriter(File file) ：通过File对象创建FileWriter对象。

　　　　　　　　　　　　FileWriter(String fileName) ：通过文件（非“目录”）路径创建FileWriter对象。

　　　　　　　　　　　　 FileWriter(File file, boolean append)：通过File对象创建FileWriter对象；第二个参数如果为true ，则字节将被写入文件的末尾而不是开头。

　　常用方法：

　　　　　　void write(int c)：将指定的单个字符数据写入此文件输出流。

　　　　　　 void write(char[] cbuf, int off, int len)：将char数组中从off开始的len个字符写入此文件输出流。

　　　　　　　　void flush()：刷新字符输出流缓冲。

　　　　　　 void close()：关闭此文件输出流并释放与此流有关的所有系统资源。

package com.xt.io;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.Reader;

import java.io.Writer;

class FileReaderAndFileWriter {

    public static void main(String[] args) {

        Reader reader=null;

        Writer writer=null;

        try {

            reader=new FileReader("C:\\unintall.log");

            writer=new FileWriter("D:\\unintall.log");

            char[] buffer=new char[1024];

            int length;

            while((length=reader.read(buffer))!=-1) {

                writer.write(buffer, 0, length);

            }

            writer.flush();

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }finally {

            try {

                if(writer!=null) {

                    writer.close();

                }

            } catch (IOException e) {

                e.printStackTrace();

            }

            try {

                if(reader!=null) {

                    reader.close();

                }

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }

}

2.1：缓冲字符流

　　BufferedReader:缓冲字符输入流      BufferedReader(Reader in)：

　　BufferedWriter :缓冲字符输出流 BufferedWriter(Writer out)

package com.xt.io;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

public class BufferReaderTest {

    public static void main(String[] args) {

        try {

            BufferedReader bufferedReader =new BufferedReader(new FileReader("C:\\unintall.log"));

            BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("D:\\unintall.log"));

            //第一种方法

//            int date;

//            while((date=bufferedReader.read())!=-1) {

//                bufferedWriter.write(date);

//            }

//            bufferedWriter.flush();

//

//

            //第二种方法

            char[] bufferDate=new char[1024];

            int length;

            while((length=bufferedReader.read(bufferDate))!=-1) {

                bufferedWriter.write(bufferDate, 0, length);

            }

            bufferedWriter.flush();

            //第三种方法

//            String lineDate;

//            while((lineDate=bufferedReader.readLine())!=null) {

//                bufferedWriter.write(lineDate);

//                bufferedWriter.newLine();

//            }

//            bufferedWriter.flush();

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

3:转换流

转化只能是字节向字符转化

　　InputStreamReader(Reader in)　　

　　OutputStreamWriter(Writer out)

因为InputStreamReader是Reader的子类，所以同样可以用缓冲字符流BufferedReader(new InputStreamReader(Reader in))

t同理

package com.xt.io;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.UnsupportedEncodingException;

public class InputStreamReaderTest {

    public static void main(String[] args) {

        try {

            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream("C:\\aa.txt"),"UTF-8"));

            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\bb.txt"), "UTF-8"));

            String lineDate;

            while((lineDate=bufferedReader.readLine())!=null) {

                bufferedWriter.write(lineDate);

                bufferedWriter.newLine();

            }

            bufferedWriter.flush();

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (UnsupportedEncodingException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

数据流

package com.xt.io;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.EOFException;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

public class DataInputStreamTest {

    public static void main(String[] args) {

        double[] scores = {20,50,42,62};

        DataOutputStream dataOutputStream=null ;

        try {

            dataOutputStream = new DataOutputStream(new FileOutputStream("D:\\data.data")) ;

            for (double score : scores) {

                dataOutputStream.writeDouble(score);

            }

            dataOutputStream.flush();

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        }finally {

            if(dataOutputStream!=null) {

                try {

                    dataOutputStream.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

        }

        try {

            DataInputStream dataInputStream=new DataInputStream(new FileInputStream("D:\\data.data"));

            while(true) {

                System.out.println(dataInputStream.readDouble());

            }

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        }catch(Exception e) {

        }

    }

}

相关文章