Java IO流

IO流用来处理设备之间的数据传输；

所有的数据都可以用字节流来进行传输（因为最终都是转化为二进制数据来传输）；而常见的文件就可以用字符流来进行传输，效率更高，更方便；

JavaIO中四个顶层抽象类：

  InuputStream：输入字节流；

  OutputStream：输出字节流；

  Reader：输入字符流；

  Writer：输出字符流；

四个基类的子类名称都以四个基类作为后缀，前面就表示子类的功能；

通过InputStream读文件内容的步骤：（读数据的过程）

1、找到所读文件路径（找到文件路径）

2、创建输入流对象（创建流对象）

3、读文件内容（读写内容）

4、关闭输入流（关闭流）

通过OutputStream写内容仅文件的步骤：（写数据的过程）

1、找到写入内容的文件路径；

2、创建输出流对象；

3、定义需要写入的内容；

4、将内容写入文件；

5、关闭输出流；

流操作的基本规律：

1.明确来源和目的；

  来源：输入流； InputStream  Reader

  目的：输出流；  OutputStream  Writer

2.明确是否是纯文本；

    是：字符流

    不是：字节流

3.前两步明确后，再明确具体的对象；

   通过设备来进行区分：

     来源：内存、硬盘、键盘；

     目的：内存、硬盘、控制台；

4.需不需要提高效率；

5.是否需要加入指定的编码表，默认是GBK，指定用UTF-8，只有转换流能指定编码表；

流只能操作数据，而想要操作文件，必须用File对象；

一些实例：

package IO;

/**
 * FileWriter
 * 代码有很大缺陷
 */
import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo 
{
    public static void main(String[] args) throws IOException 
{
        // 明确数据存放位置
        FileWriter fw = new FileWriter("demo.txt");  // 文件可以不存在；如果已存在，会被覆盖掉
        // FileWriter fr = new FileWriter("f:\demo.txt");
        // 将字符串写入流中，文件中现在并没有数据，流的内部有缓冲，先保存数据
        fw.write("abcd");
        // 将流中缓存的数据刷到文件中，这步必须要有
        fw.flush();
        // 先刷新一次流中的数据，再关闭
        // 与flush()的区别：flush()之后可以再接着flush()，而close()之后，流被关闭，不能再被flush()，因为不能再写入数据了
        fw.close();
    }
}

package IO;

/**
 * IO的异常处理
 */
import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo2
{
    public static void main(String[] args)
    {
        FileWriter fw = null;  // 在try外创建引用
        try
        {
// 在try内进行初始化
            fw = new FileWriter("demo.txt"); // 注意点1：路径可能会写错
            fw.write("abcdef");
        }
        catch (IOException e)
        {
            System.out.println(e);
        } 
        finally
        {
            try
            {    // 注意点3：关闭流本身也还会抛出异常
// 关闭流操作要写到finally中
// 如果有多个流都没关闭，要分别进行关闭，不要一次性全关闭
                if (fw != null) // 注意点4：如果fw为空，则fw.close()这样写肯定报空指针异常，所以必须进行非空判断
                {
                    fw.close(); // 注意点2：变量的作用域问题
                }
            } 
            catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    }
}

package IO;

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

/**
 * 对已有文件数据续写：写在文件的末尾
 */
public class FileWriterDemo3
{
    public static void main(String[] args)
    {
        FileWriter fw = null;
        try
        {
            // 通过构造函数，实现在文件末尾添加数据
// 且：传递一个true参数，代表不覆盖已有文件
            fw = new FileWriter("demo.txt",true);
            fw.write("abc
def");  // 
表示换行
        } catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(fw != null)
            {
                try
                {
                    fw.close();
                } catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }
}

  

package IO;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
 * 通过字符流读取文件内容
 */
public class FileReaderDemo
{
    public static void main(String[] args)
    {
        FileReader fr = null;
        try
        {
            // 文件必须存在，不然会抛出文件未找到异常
            fr = new FileReader("demo.txt");  
            
            int ch = 0;
            // 字符在计算机中是以数字存在的，所以要用int来接收
            // read()：一次读一个字符，而且会自动往下读
            // -1：表示到了数据末尾，没有数据了
            while((ch=fr.read()) != -1)  
            {
                System.out.print((char)ch);
            }
        } 
        catch (FileNotFoundException e)
        {
            e.printStackTrace();
        } 
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null != fr)
            {
                try
                {
                    fr.close();
                } catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }
}

package IO;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
 * 通过字符数组读取文件内容
 */
public class FileReaderDemo2
{
    public static void main(String[] args)
    {
        FileReader fr = null;
        try
        {
            fr = new FileReader("demo.txt");
            int ch = 0;
            // 通常情况下定义成1024的整数倍
            char[] buff = new char[1024];  //2K空间
            // 返回读取的字符数
            while((ch=fr.read(buff)) != -1)
            {
                // 以字符串形式输出，只截取需要的部分
                System.out.println(new String(buff,0,ch));
            }
        } 
        catch (FileNotFoundException e)
        {
            e.printStackTrace();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null != fr)
            {
                try
                {
                    fr.close();
                } catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }
}

package IO;
/**
 * 读文件内容并打印到控制台
 */
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Practise1
{
    public static void main(String[] args)
    {
        FileReader fr = null;
        try
        {
            // 只要指定文件名就可以了
            fr = new FileReader("f:\DeadLockTest.java");
            char[] buff = new char[1024];
            int num = 0;
            while((num=fr.read(buff)) != -1)
            {
                // 不要用println()；如果读到数据到了1024个字符，会空一行再打印内容
// 输出就相当于打印到控制台上
                System.out.print(new String(buff,0,num));
            }
        } 
        // 读文件必出现的两个异常：文件未找到异常
        catch (FileNotFoundException e)   
        {
            e.printStackTrace();
        }
        // 读文件必要的两个异常：IO异常
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null != fr)
            {
                try
                {
                    fr.close();
                } catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }
}

package IO;
/**
 * 文件拷贝
 */
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileCopyDemo
{
    public static void main(String[] args)
    {
        // methodOne();
         methodTwo();
    }
    
    // 法一：一次只读一个字符
    public static void methodOne()
    {
        FileWriter fw = null;
        FileReader fr = null;
        try
        {
            fw = new FileWriter("d:\DeadLockTest_copy.txt");
            fr = new FileReader("f:\DeadLockTest.java");
            
            int ch = 0;
            while((ch=fr.read()) != -1)
            {
                fw.write(ch);
            }
        } 
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null != fw)
            try
            {
                fw.close();
            } catch (IOException e)
            {
                e.printStackTrace();
            }
            if(null != fr)
            try
            {
                fr.close();
            } catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    }
    
    // 法二：一次读一个字符数组
    public static void methodTwo()
    {
        FileWriter fw = null;
        FileReader fr = null;
        try
        {
            fw = new FileWriter("d:\DeadLockTest_Copy.txt");
            fr = new FileReader("f:\DeadLockTest.java");
            
            char[] buff = new char[1024];
            int num = 0;
            
            while((num=fr.read(buff)) != -1)
            {
                fw.write(buff,0,num);
            }
        } 
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null != fw)
            try
            {
                fw.close();
            } catch (IOException e)
            {
                e.printStackTrace();
            }
            if(null != fr)
            try
            {
                fr.close();
            } catch (IOException e)
            {
                e.printStackTrace();
            }
        }
        
    }
}

package IO;
/**
 * 文件缓冲流：BufferedReader
 * 装饰者模式：当想要对已有功能对象进行增强时，自定义类，将对象放入，基于已有的功能，提供加强功能；
 * 这个自定义类就是装饰类；（以前读一个字符，现在可以直接读一行的字符）
 */
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderDemo
{
    public static void main(String[] args)
    {
        FileReader fr = null;
        BufferedReader br = null;
        try
        {
            fr = new FileReader("demo1.txt");  // 有异常
            br = new BufferedReader(fr);  // 有异常
            String line = null;
            // 读到末尾返回空
            while((line=br.readLine()) != null)  // 有异常
            {
                System.out.println(line);
            }
        } 
        catch (FileNotFoundException e)
        {
            e.printStackTrace();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null != br)
            {
                try
                {
// 关闭缓冲区，其实就是在关闭缓冲区中的流对象，所以不用再一次关闭流对象了
                    br.close();  // 有异常
                } catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }
}

package IO;
/**
 * 文件缓冲流：BufferedWriter
 */
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterDemo
{
    public static void main(String[] args) throws IOException
    {
        FileWriter fw = new FileWriter("f:\demo.txt");
        // 构造函数中必须要有流对象
        BufferedWriter bw = new BufferedWriter(fw);
        bw.write("asdfghjkl");
        // 换行，跨平台
        bw.newLine();
        bw.write("zxcvbnm");
        // 这条语句必须加：只要用到缓冲区，就要记得刷新
        bw.flush();
        // 缓冲流关闭之后，文件流不需要再手动关闭了
        bw.close();
        
        test();
    }
    
    public static void test() throws IOException
    {
        // 如果事先不存在这个文件，会自动创建这个文件
        FileWriter fw = new FileWriter("f:\demo1.txt");
        // 构造函数中必须要有流对象
        BufferedWriter bw = new BufferedWriter(fw);
        for(int i=1;i<100;i++)
        {
            bw.write("asdf");
            bw.newLine();
            // 建议写一次，刷一次
            bw.flush();
        }
        // 缓冲流关闭之后，文件流不需要再手动关闭了
        bw.close();
    }
}

package IO;
/**
 * 文件拷贝，BufferedReader/BufferedWriter实现
 */
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 FileCopyDemo2
{
    public static void main(String[] args)
    {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try
        {
            br = new BufferedReader(new FileReader("demo.txt"));
            bw = new BufferedWriter(new FileWriter("demo1.txt"));
            
            String line = null;
            // readLine()只返回回车符之前的内容，并不返回回车符，所以要添加换一行那个方法
            while((line=br.readLine()) != null)
            {
                bw.write(line);
                // 这行必须要写
                bw.newLine();
                bw.flush();
            }
        } 
        catch (FileNotFoundException e)
        {
            e.printStackTrace();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null != br)
            try
            {
                br.close();
            } catch (IOException e)
            {
                e.printStackTrace();
            }
            if(null != bw)
            try
            {
                bw.close();
            } catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    }
}

package IO;
/**
 * 装饰者模式：当想要对已有对象的功能进行增强时，自定义类，将对象放入，基于已有的功能，提供加强功能；
 * 这个自定义类就是装饰类；（以前读一个字符，现在可以直接读一行的字符）
 * 
 * 装饰者通常通过构造函数加入被装饰者对象，然后基于被装饰对象的功能，提供更强的功能；
 */
class Person
{
    public void chifan()
    {
        System.out.println("吃饭");
    }
}

class SuperPerson
{
    private Person p;
    public SuperPerson(Person p)
    {
        this.p = p;
    }
    public void chifan()
    {
        System.out.println("开胃酒");
        p.chifan();
        System.out.println("甜点");
        System.out.println("来一根");
    }
}
public class PersonDemo
{
    public static void main(String[] args)
    {
        /*Person p = new Person();
        p.chifan();*/
        
        Person p = new Person();
        SuperPerson sp = new SuperPerson(p);
        sp.chifan();
    }
}

package IO;
/**
 * LineNumberReader缓冲流的使用，BufferedReader的子类
 */
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;

public class LineNuberReaderDemo
{
    public static void main(String[] args)
    {
        FileReader fr = null;
        LineNumberReader lnr = null;
        try
        {
            fr = new FileReader("f:\DeadLockTest.java");
            lnr = new LineNumberReader(fr);
            String line;
            // 设置行号从20开始，默认从0开始
            lnr.setLineNumber(20);
            while((line=lnr.readLine()) != null)
            {
                // 获取行号（在显示中添加行号）
                System.out.println(lnr.getLineNumber() + ":" + line);
            }
        } 
        catch (FileNotFoundException e)
        {
            e.printStackTrace();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null != lnr)
            {
                try
                {
                    lnr.close();
                } catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
            if(null != fr)
            {
                try
                {
                    fr.close();
                } catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }
}

/**
 * 功能：FileInputStream的使用
 */
package IO;

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

public class FileStreamDeno
{
    public static void main(String[] args)
    {
        // writeFile();
        // readFile_1();
        // readFile_2();
        // readFile_3();
        readFile_4();
    }

    // 一次读一个字节
    public static void readFile_1()
    {
        FileInputStream fis = null;
        try
        {
            fis = new FileInputStream("f:\fos.txt");
            int ch = 0;

            while ((ch = fis.read()) != -1)
            {
                System.out.println((char) ch);
            }

        } catch (FileNotFoundException e)
        {
            e.printStackTrace();
        } catch (IOException e)
        {
            e.printStackTrace();
        }

    }
    
    // 一次读多个字节
    public static void readFile_2()
    {
        FileInputStream fis = null;
        try
        {
            fis = new FileInputStream("f:\fos.txt");
            byte[] btr = new byte[2];
            int ch = 0;
            while((ch=fis.read(btr)) != -1)
            {
                System.out.println(new String(btr,0,ch));
            }
        }
        catch(FileNotFoundException e)
        {
            e.printStackTrace();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null != fis)
            try
            {
                fis.close();
            } catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    }
    
    // 读文件内容的字节数
    public static void readFile_3()
    {
        FileInputStream fis = null;
        try
        {
            fis = new FileInputStream("f:\fos.txt");
// 包括换行符
            int num = fis.available();
            System.out.println(num);
        }
        catch(FileNotFoundException e)
        {
            e.printStackTrace();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null != fis)
            try
            {
                fis.close();
            } catch (IOException e)
            {
                e.printStackTrace();
            }
        }
        
    }
    
    // 定义大小相等的缓冲区，不需要再循环读
    public static void readFile_4()
    {
        FileInputStream fis = null;
        try
        {
            fis = new FileInputStream("f:\fos.txt");
            // 数据太大时，不建议使用
            byte[] btr = new byte[fis.available()];
            fis.read(btr);
            System.out.println(new String(btr));
        }
        catch(FileNotFoundException e)
        {
            e.printStackTrace();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null != fis)
            try
            {
                fis.close();
            } catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    }

    // 写内容
    public static void writeFile()
    {
        FileOutputStream fos = null;
        try
        {
            fos = new FileOutputStream("f:\fos.txt");
            // 要写入的内容
            String str = "asdfghj";
            // 将字符串转换成字节数组
            byte[] btr = str.getBytes();
            // 写入内容，不刷新不关闭的情况下也可以写入文件，因为写的是字节，不需要缓冲，所以可以直接写入
            // 但是资源关闭还是必须的
            fos.write(btr);

        } catch (FileNotFoundException e)
        {
            e.printStackTrace();
        } catch (IOException e)
        {
            e.printStackTrace();
        } finally
        {
            if (null != fos)
                try
                {
                    fos.close();
                } catch (IOException e)
                {
                    e.printStackTrace();
                }
        }

    }
}

/**
 * 功能：复制图片
 */
package IO;

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

public class FileStreamDemo2
{
    public static void main(String[] args) throws Exception
    {
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try
        {
            fis = new FileInputStream("f:\1.jpg");
            fos = new FileOutputStream("f:\2.jpg");

            byte[] btr = new byte[1024];
            int len = 0;

            while ((len = fis.read(btr)) != -1)
            {
                fos.write(btr,0,len);
            }
        } catch (FileNotFoundException e)
        {
            throw new Exception("The file is null");
        } catch (IOException e1)
        {
            throw new Exception("Failed to read or write file");
        } finally
        {
            if(null != fis)
                try
                {
                    fis.close();
                } catch (IOException e)
                {
                    e.printStackTrace();
                }
            if (null != fos)
                try
                {
                    fos.close();
                } catch (IOException e)
                {
                    e.printStackTrace();
                }
                    
        }
    }
}

/**
 * 功能；多媒体文件复制（视频、音乐）
 */
package 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 FileStreamDemo3
{
    public static void main(String[] args)
    {
        copy_1();
    }

    public static void copy_1()
    {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bfis = null;
        BufferedOutputStream bfos = null;
        try
        {
            fis = new FileInputStream("f:\1.avi");
            bfis = new BufferedInputStream(fis);
            fos = new FileOutputStream("f:\2.avi");
            bfos = new BufferedOutputStream(fos);
            
            // BufferedInputStream bfis = new BufferedInputStream(new FileInputStream("f:\1.avi"));
            // 不需要再定义用于缓冲的字节数组
            int len = 0;

            while ((len = bfis.read()) != -1)
            {
                bfos.write(len);
            }
        } catch (FileNotFoundException e)
        {
            e.printStackTrace();
        } catch (IOException e)
        {
            e.printStackTrace();
        } finally
        {
            if (null != bfos)
            try
            {
                bfos.close();
            } catch (IOException e)
            {
                e.printStackTrace();
            }
            if (null != fos)
            try
            {
                fos.close();
            } catch (IOException e)
            {
                e.printStackTrace();
            }
            if (null != bfis)
            try
            {
                bfis.close();
            } catch (IOException e)
            {
                e.printStackTrace();
            }
            if (null != fis)
            try
            {
                fis.close();
            } catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    }
}