黑马程序员 IO流

——- android培训、java培训、期待与您交流！ ———-

1，IO流概述

(a)IO流是用来处理不同设备间的数据传输问题

(b)Java对数据的操作是通过流的方法

(c)Java用于操作流的对象都在IO包中

(d)流按操作数据分为两种：字节流与字符流

(e)流按流向分为：输入流，输出流

(f)使用流要记得关流和处理异常。

2，IO流常用对象

(a)字节流：InputStream OutputStream

(b)字符流：Reader Writer

注意：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。所以转换流名称显而易见。

如InputStream的子类FileinputStream。
如Reader的子类FileReader。
转换流：InputStreamReader OutputStreamWriter

3，IO流的常用方法演示

FileWriter fw=new FileWriter(“demo.txt”);
创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件，而且该文件会被创建到指定目录下，如果该目录下已有同名文件，将被覆盖。

想要在原来的文件上面进行续写：当boolean型的为true的时候，在文件的末尾处进行续写；

FileWrite fw = new FileWriter(“demo.txt”,true);

fw.write(“hao”);

调用write方法，将字符串写入到流中。

fw.flush();

刷新流对象中的缓冲中的数据。将数据刷到目的地中。

fw.close();

关闭流资源，但是关闭之前会会调用flush()刷新一次内部的缓冲中的数据。将数据刷到目的地中。和flush的区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。

注意：对异常的处理：在外面建立引用，在里面进行初始化；

体现

public class FileOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        // 创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");
        //写数据
        fos.write("IO".getBytes());
        fos.write("java".getBytes());
        //刷新
        fos.flush();
        //释放资源
        //关闭此文件输出流并释放与此流有关的所有系统资源。
        fos.close();
    }
}

import java.io.*;  
/*续写文件和IO异常处理*/
class FileWriterDemo3   
{  
    public static void main(String[] args)   
    {  
        FileWriter fw = null;  
        try  
        {  
//传递一个true参数，代表不覆盖已有的文件，并在已有文件的末尾处进行续写  
            fw = new FileWriter("demo.txt",true);//对已有文件的数据进行续写。  
            //在windows里面的换行是\r\n,而在Linux里面换行的是\n
            fw.write("hao\r\nshiwo");//加了一个换行符；  
        }  
        catch (IOException e)  
        {  
            System.out.println(e.toString());  
        }  
        finally  
        {  
            try  
            {  
                if(fw!=null)  
                    fw.close();  
            }  
            catch (IOException e)  
            {  
                System.out.println(e.toString());  
            }  
        }  
    }  
}

4， IO流的读操作

FileReader：用来读取字符文件的便捷类。

第一种：一次读取单个字符。

第二种：通过字符数组进行读取；int read(char[] cbuf) 返回的是个数，读取几个就返回几个。

步骤：
1、定义一个字符数组，用于存储读到字符，该read(char[] cbuf)返回的是读到的一个字符个数；

2、当缓冲区里面的数据存满了以后，就将数据打印出去；

体现

import java.io.*;  
class FileReaderDemo   
{  
    public static void main(String[] args)   
    {  
//      创建一个文件读取流对象，和指定名称的文件相关联  
//      要保证该文件已经存在的，如果不存在，会发生异常  
        FileReader fr =null; 
        //第一种方式 
        try  
        {  
            fr = new FileReader("demo.txt");  
            int ch =0;  
//          调用读取流对象的read方法；  
//          read()方法：一次读取一个自读，而且会自动往下读；  
//          返回的整数类型int，作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)，如果已到达流的末尾，则返回 -1             

            while((ch=fr.read())!=-1)  
            {  
                System.out.print((char)ch);  
            }   
        }  
        /* 
        //第二种方式
        try  
        {  
            fr = new FileReader("demo.txt");  
//          缓冲区通常情况下会定义1024的倍数；  
            char[] buf = new char[1024];//读取一个数组。通过字符数据进行读取  
//          定义一个变量，因为每一次返回来的个数不一样  
            int num =0;  
//          num的值只要不等于-1，就可以一直读  
*/
//            while((num=fr.read(buf))!=-1)  
//            {  
//              把数组中从什么位置开始，读几个，读到几个，就几个    
//              System.out.println(new String(buf,0,num));  
//            }  

        catch (IOException e)  
        {  
            System.out.println(e.toString());  
        }  
        finally  
        {  
            try  
            {  
                    if(fr!=null)  
                    fr.close();  
            }  
            catch (IOException e)  
            {  
                System.out.println(e.toString());  
            }  
        }  
    }  
}

5，字符流拷贝操作

体现

/*将一个文本文件复制到另一个文本文件中*/  
import java.io.*;  
class CopyTest   
{  
    public static void main(String[] args)   
    {  
        copy();  
    }  
    public static void copy()  
    {  
        FileWriter fw=null;  
        FileReader fr=null;  
        try  
        {  
            fw=new FileWriter("Demo_copy.java");//创建一个存储文件  
            fr=new FileReader("Demo.java");//创建已有文件关联  
            char[] buf=new char[1024];//创建一个数组  
            int len=0;  
            while((len=fr.read(buf))!=-1)//读取Demo文件内容返回字符个数  
            {  
                fw.write(buf,0,len);//写出数组中已存储的内容  
            }  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("读写失败");  
        }  
        finally  
        {  
            if(fw!=null)  
                try  
                {  
                    fw.close();//关闭流资源  
                }  
                catch (IOException e)  
                {  
                }  
            if(fr!=null)  
                try  
                {  
1.                      fr.close();  
                }  
                catch (IOException e)  
                {  
                }  
        }  
    }  
}  

6，字节流

available()可以获取字节数。利用这个方法可以定义一个刚刚好的缓冲区，这样可以省略循环。慎用，文件过大，导致崩溃。

需要操作图片，音乐等数据就要用到字节流。

复制一个图片步骤：

(a)用字节读取流对象和图片相关联；

(b)用字节写入流对象创建一个图片文件，用于存储获取到的图片数据；

(c)通过循环读写，完成数据的存储；

最后不要忘了要关闭资源。close()

体现

/* 
复制一个图片文件 
*/  
import java.io.*;  
class CopyPic   
{  
    public static void main(String[] args)   
    {  
        FileOutputStream fos =null;  
        FileInputStream fis =null;  
        try  
        {  
            fos = new FileOutputStream("c:\\2.bmp");  
//          源 
            fis = new FileInputStream("c:\\1.bmp");  
//          定义缓冲区  
            byte[] buf = new byte[1024];  
            int len =0;  
            while((len=fis.read(buf))!=-1)  
            {  
                fos.write(buf,0,len);  
            }   
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("读写失败");  
        }  
        finally  
        {  
            try  
            {  
                if(fis!=null)  
                    fis.close();  
            }  
            catch (IOException e)  
            {  
                throw new RuntimeException("读取关闭失败");  
            }  
            try  
            {  
                if(fos!=null)  
                    fos.close();  
            }  
            catch (IOException e)  
            {  
                throw new RuntimeException("写入关闭失败");  
            }  
        }  
    }  
}

7，缓冲区

(a)缓冲区的出现提高了对数据的读写效率。

(b)对应类：BufferedWriter，BufferedReader，
BufferedInputStream，BufferedOutputStream

(c)缓冲区要结合流才可以使用。

(d)需要高效就是用缓冲区，增强功能。

8，键盘读取与录入

System.out：对应的是标准输出设备，控制台。

System.in：对应的标准输入设备，键盘。

InputStream in=System.in;//键盘输入

in.read();//读取键盘输入
体现

class  ReadIn  
{  
    public static void main(String[] args) throws IOException  
    {  
        InputStream in = System.in;  
//      定义一个缓冲区，用于存储数据  
        StringBuffer sb = new StringBuffer();  
        while(true)  
        {  
//          回车的时候把数据一次性打印出来  
            int ch = in.read();  
            if(ch=='\r')  
                continue;  
            if(ch=='\n')  
            {  
//              把缓冲区里面的数据变成字符串  
                String s = sb.toString();  
//              判断字符串内容是否相同  
                if("over".equals(s))  
                    break;  
                System.out.println(s.toUpperCase());  
                sb.delete(0,sb.length());//清空缓冲区。  
            }  
            else  
                sb.append((char)ch);  
        }  
        in.close();    
    }  
}

9，转换流

读取转换流：InputStreamReader
写入转换流：OutputStreamReader

体现

class TransStreamDemo   
{  
    public static void main(String[] args) throws IOException  
    {  
        //获取键盘录入对象  
        InputStream in=System.in;  
        //将字节流对象转成字符流对象，使用转换流，InputStreamReader  
        InputStreamReader isr=new InputStreamReader(in);  
        //将字符串进行缓冲区技术高效操作，使用BufferedReader  
        BufferedReader bufr=new BufferedReader(isr);  
        String line=null;  
        while((line=bufr.readLine())!=null)  
        {  
            if("over".equals(line))//输入over时，跳出录入  
                break;  
            System.out.println(line.toUpperCase());//转成大写  
        }  
        bufr.close();  
    }  
}  

10，流的操作规律

(a)明确源和目的：
源：输入流 InputStream和Reader
目的： 输出流 OutputStream和Writer

(b)数据操作是否为纯文本。
是：字符流
否：字节流

(c)是否要使用具体的对象：
源设备：内存、硬盘、键盘
目的设备：内存、硬盘、控制台

(d)是否需要额外的更能增强。
是就用Buffered

操作规律练习：

a，将一个图片文件中的数据存储到另一个文件中，复制文件，按照流操作的规律完成。

b，源：InputStream Reader

c，是不是操作的文本文件：是！就用字符流：Reader

d，设备：键盘，对应的是键盘System.in

e，不是选择Reader吗？System.in对应的不是字节流吗？

f，为了操作键盘的文件数据方便，转成字符流按照字符串操作是最方便的，

g，所以既然明确了Reader，那么就将System.in转成了Reader

h，用了Reader体系中的转换流，InputStreamReader

i，需要提高效率吗？

j，需要，用BufferedReader；

k，目的：OutputStream Writer

l，是否是纯文本文件：是！用Writer

m，是否需要提高效率？需要，用BufferedWriter