六IO流技术

IO流技术

IO流的基本概念

   ·流的原理

1. 在java程序中，对于数据的输入\输出操作以“流”（stream）方式进行；
2. J2SDK提供了各种各样的“流”类，用以获取不同种类的数据；程序中通过标准的方法输入或输出数据；
3. java的流类型一般位于java.io包中

   ·流的概念

　　数据源：1.data source. 提供原始数据的原始媒介。常见的：数据库、文件、其他程序、内存、网络连接、IO设备。

　　　　　　2.数据源就像水箱，流就像水管中流着的水流，程序就是我们最终的用户。流是一个抽象、动态的概念，是一连串连续动态的数据集合。

流的细分和体系_四大抽象类

   ·流的分类

　　流的方向：1.输入流：数据源到程序（InputStream、Reader读进来）

　　　　　　　2.输出流：程序到目的地（OutPutStream、Writer写出去）

　　处理数据单元：1.字节流：按照字节读取数据（InputStream、OutputStream）

　　　　　　　　　2.字符流：按照字符读取数据（Reader、Writer）

　　注意：输入输出是相对于程序而言，而不是相对于源和目标而言。

　　功能不同：1.节点流：可以直接从数据源或目的地读写数据。

　　　　　　　2.处理流(包装流)：不直接连接到数据源或目的地，是其他流进行封装。目的主要是简化操作和提高性能。

　　节点流和数据流的处理关系：1.节点流处于io操作的第一线，所有操作必须通过他们进行；

　　　　　　　　　　　　　　　2.处理流可以对其他流进行处理（提高效率或操作灵活性）

   ·IO流的体系

　　InputStream和OutputStream:java语言中最基本的两个字节输入输出类。

　　　　　　　　　　　　　　　其他所有字节输入输出流类都继承自这两个基类。

　　　　　　　　　　　　　　　这两个类都是抽象类，不能创建它们的实例，只能使用它们的子类。

　　Reader和Writer:java语言中最基本的两个字符输入输出类。

文件字节流

   ·FileInputStream/FileOutputStream

　　使用FileInputStream读取文件内容

　　1.abstract int read();

package com.zqf.ioproject;

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

public class TestInputStream {
    public static void main(String[] args) throws IOException {
        //(1)数据源与应用程序之间搭建管理(通过创建对象)
        FileInputStream fis = new FileInputStream(new File("C:\\test.txt"));
        //(2)从数据源开始向程序中读数据
        int count = fis.available();        //统计文件中字符的个数
        System.out.println(count);
        //中转站比较小，一次读一个字节
        //System.out.println(fis.read( ));    //读取一个字节
        //System.out.println(fis.available());
        int buf = 0;    //存储读到的字节
        while((buf=fis.read())!=-1){
            System.out.println((char)buf);
        }
        //(3)关闭
        fis.close();
    }
}

 

　　2.int read(byte b[]);

package com.zqf.ioproject;

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

public class TestInputStream2 {
    public static void main(String[] args) throws IOException {
        //(1)搭桥
        FileInputStream fis = new FileInputStream("C:\\test.txt");
        //(2)创建大一些的中转站
        byte [] buf = new byte[1024];
        int len = 0;    //用于存储每次读到的实际字符
        while((len=fis.read(buf))!=-1){
            //借助String类构造方法
            System.out.println(new String(buf,0,len));
        }
        //(3)关闭
        fis.close();
    }
}

 

　　3.int read(byte b[],int off,int len);

　　4.int available();

　　5.close();

　　使用FileOutputStream写内容到文件　

　　1.abstract void write(int b);

　　2.void write(byte b[]);

　　3.void write(byte b[],int off,int len);

　　4.void flush();

　　5.void close()

package com.zqf.ioproject;

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

public class TestOutputStream {
    public static void main(String[] args) {
        //(1)搭桥
        FileOutputStream fos=null;
        try {
            fos = new FileOutputStream("C:\\test.txt");
            //(2)写数据，一次写一个字节
            //fos.write(97);
            //(3)一次写多个字节
            byte[] buf ="helloworld".getBytes();
            fos.write(buf);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            //(3)关闭
        try {
            if(fos!=null){
                fos.close();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        }
    }
}

使用字节流实现文件复制

   ·文件复制的原理

   ·文件复制的代码实现

package com.zqf.ioproject;

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

public class TestFileCopy {
    public static void main(String[] args) {
        //数据源是文件
        FileInputStream fis=null;
        //目的地
        FileOutputStream fos;
        try {
            fis = new FileInputStream("D:\\test.txt");
            fos = new FileOutputStream("C:\\target.txt");
            
            byte [] buf=new byte[1024];        //中转站
            int len=0;    //用于存储每次读到的字节个数
            while((len=fis.read(buf))!=-1){
                fos.write( buf,0,len);
            }
            
            /*int b=0;//用于存储读到的字节，（中转站）
            while ((b=fis.read())!=-1){
                //写入文件
                fos.write(b);
            }*/
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
        //关闭
        try {
            if(fis!=null){
                fis.close();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        }
    }
}

文件字符流

   ·Reader/Writer

　　使用Reader读取文件内容

1. int read();
2. int read(char [] cbuf);
3. int read (char [] cbuf,int off,int len);
4. int available();
5. close();

   package com.zqf.reader;
   
   import java.io.FileNotFoundException;
   import java.io.FileReader;
   import java.io.IOException;
   
   public class TestFileReader {
       public static void main(String[] args) throws IOException {
           //(1)搭桥
           FileReader reader = new FileReader("C:\\test.txt");
           //(2)读取
           //int b = reader.read();         //读到的字符的int类型数据
           //System.out.println((char)b);
           /*int b=0;    //用于存储每次读到的字符数据的整数值
           while ((b=reader.read())!=-1){
               System.out.println((char)b);
           }*/
           
           char [] cbuf = new char[1024];
           int len = 0;    //用于存储读到的字符的个数
           while((len=reader.read(cbuf))!=-1){
               System.out.println(new String (cbuf,0,len));
           }
           //（3）关闭
           reader.close();
       }
   }

    

   ·使用Writer写内容到文件

1. void write(int c);
2. void write(char[] cbuf);
3. abstract void write(char [] cbuf,int off,int len);
4. void write(String str);
5. abstract void flush()

 

package com.zqf.writer;

import java.io.FileWriter;
import java.io.IOException;

public class TestWriter {
    public static void main(String[] args)  {
        //创建对象
        FileWriter writer=null;
        try {
            writer = new FileWriter("C:\\a.txt");
            //写数据
            writer.write("你好吗？");    //写到缓冲区中
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
        //关闭
            if(writer!=null){
                try {
                    writer.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}