JAVA基础-I/O流学习笔记（一）

　　第一次写博文，内心无比激动，成长在此开始！

　　最近一直在自学java基础，看到I/O流这章了，先写下对I/O流的了解吧！

一、I/O流简介

　　I/O是实现java编程输入和输出的基础，可以方便的将数据进行输入/输出操作。java把不同的输入/输出源（硬盘、文件、网络连接等）抽象的描述成“流”，由于流的存在，实现了不同输入/输出源之间的交换数据。

　　java中关于流的操作的类都在java.io包中。

二、流的分类

　　2.1按照流向

　　按照流向来分，流分为输入流和输出流。

　　输入流：从输入源向内存中输入数据。

　　输出流：从内存中向输出源输出数据。

　　此处的输入和输出是从程序运行时的内存来说的。

　　输入流主要是以InpuStream和Reader作为基类，输出流主要以OutputStream和Writer作为基类，基类都为抽象类，无法直接建立对象。

　　2.2按照操作数据

　　按照操作数据来分，流分为字节流和字符流。字节流和字符流的用用法几乎一致。区别是操作的单元不同，字节流操作的是字节，字符流操作的是字符。

　　字节流是以InputStream和OutputStream为基类，字符流是以Writer和Reader作为基类。

　　2.3按照流的角色

　　按照流的角色可以分为节点流和包装流。

　　可以从一个具体的输入/输出源（硬盘、文件、网络连接等）读/写数据的流，称为节点流，使用节点流时，程序直接操作实际的数据源。

　　包装流是对已存在的流进行包装，通过包装后的流实现对数据的读/写。

　　（java包装流来包装节点流是一种典型的装饰者模式，通过使用包装流来包装不同的节点流）

三、InputStream和Reader

　　先来介绍一下两个输入流基类。

InputSream中常用的方法:

int read(); 从输入流中读取数据的下一个字节

int read(byte[] b); 从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中
      int read(byte[] b,int off, int len); 将输入流中最多 len 个数据字节读入 b 数组中，放入数组b时，不是从数组起点开始，而是从off位置开始的，返回实际读取的字节数。

void close(); 关闭此输入流并释放与该流关联的所有系统资源。

Reader中常用的方法：

int read(); 从输入流中读取数据的下一个字符

int read(char[] c); 从输入流中读取一定数量的字符，并将其存储在缓冲区数组c中
      int read(char[] c,int off, int len); 将输入流中最多 len 个数据字符读入 c  数组中，放入数组c时，不是从数组起点开始，而是从off位置开始的，返回实际读取的字符数。

void close(); 关闭此输入流并释放与该流关联的所有系统资源。

对比可以看到InputStream和Reader所提供的功能基本一致。InputStream和Reader是抽象类，不能建立实例，下面是FileInputStream类来实现读取自身的效果。

package it.study.io;

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

public class InputStreamDemo {
    public static void main(String[] args) throws IOException{
        //创建文件目录
        File f=new File("InputStreamDemo.java");
        //建立文件输入流对象
        FileInputStream in=new FileInputStream(f);
        //建立缓冲数组
        byte[] by=new byte[1024];
        //用于保存实际读取的字节数
        int l=0;        
        while((l=in.read(by))!=-1)
            //打印字节数组中写入的数据
            System.out.print(new String(by,0,l));
        //close()放在finally里会更加安全
        in.close();
    }
}

         

执行以上程序会产生读取自身的效果并且将此显示出来。

下面是用FileReader类实现。

package it.study.io;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class ReaderDemo {
    public static void main(String[] args){
            //创建文件目录
        File f=new File("ReaderDemo.java");
        //如果在try中声明和赋值FileReader，则只在try中生效，即在try外面声明，内部赋值。
        FileReader fr=null;
        try{
            fr=new FileReader(f);
            
            //建立字符数组
            char[] ch=new char[64];
            //实际有效的字符数
            int l=0;
            while((l=fr.read(ch))!=-1){
                System.out.print(new String(ch,0,l));
                
            }
            
        }
        catch(IOException i){
            i.printStackTrace();
            
        }
        finally{
            //关闭流时需要进行判断该流是否为空，如果为空，进行close()，会报错。
            if(null!=fr){
                try{
                    fr.close();
                }
                catch(IOException i){
                    i.printStackTrace();
                }
            }
            
        }
    }
}

 

四、OutputStream和Writer

OutputSteam中常用的方法：

void write(int b); 将指定的字节写入的输出流中

void write(byte[] b); 将指定的字节数组写入到输出流中

void write(byte[] b,int off,int len); 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流中。

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

Writer中常用的方法：

void write(int c); 写入单个字符

void write(String str); 将指定的字符串写入的输出流中

void wirte(String str,int off,int len); 将指定的字符串从偏移量off开始的len个字符写入到输出流中

void write(char[] b); 将指定的字符数组写入到输出流中

void write(char[] b,int off,int len); 将指定 char 数组中从偏移量 off 开始的 len 个字符写入此输出流中。

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

使用FileOutputStream类，将该自身复制到电脑d盘下的Demo.txt文件中。

package it.study.io;

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

public class OutputStreamDemo {
    public static void main(String[] args){
        FileOutputStream fos=null;
        FileInputStream fis=null;
        try{
            //建立输入流对象
            fis=new FileInputStream("OutputStreamDemo.java");
            //建立输出流对象，将本文件复制到d盘下中，文件名为Demo.txt
            fos=new FileOutputStream("D:\Demo.txt");
            //建立缓冲字节数组
            byte[] b=new byte[1024];
            //实际的字节数量
            int len=0;
            while((len=fis.read(b))!=-1){
                
                //将字节数组的有效字节写入到Demo.txt中。
                fos.write(b,0,len);
            }
            
        }
        catch(IOException i){
            i.printStackTrace();
        }
        finally{
            
            //关闭流对象
            if(null!=fis){
                try{
                    fis.close();
                }
                catch(IOException i){
                    i.printStackTrace();
                }
            }
            if(null!=fos){
                try{
                    fos.close();
                }
                catch(IOException i){
                    i.printStackTrace();
                }
            }
            
        }
    }
}

下面使用FlieWriter来实现：

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

public class WriterDemo {

    public static void main(String[] args)throws IOException {
        // TODO Auto-generated method stub
        FileReader fr=new FileReader("WriterDemo.java");
        FileWriter fw=new FileWriter("D:\wirte.txt");
        char[] c=new char[64];
        int len=0;
        while((len=fr.read(c))!=-1){
            fw.write(c,0,len);
            
        }
        fr.close();
        fw.close();

    }

}

这篇先写到这，下一篇将针对常用的包装流进行详细说明！