Java 运用流传输文件

实例1

package IO;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.Reader;
import java.io.Writer;

/**
 * 案例：利用字符流实现字符文件的拷贝1.txt -> 3.txt
 * 1.字符文件的读取：FileReader
 * 2.字符文件的写入：FileWriter
 * 3.循环上面的过程
 */
public class FileCopyDemo1 {
    public static void main(String[] args) throws Exception{

        /**
         * 1.创建字符文件输入流指向1.txt
         * 2.创建文件输出流指向文件3.txt
         */
        Reader reader = new FileReader("1.txt");
        Writer writer = new FileWriter("3.txt");
        /**
         * 3.对接流，并循环输出
         * 4.判断循环条件：当输入流没有数据输入时结束循环
         */
        int i;
        while((i = reader.read()) != -1) {
            writer.write(i);
        }
        // 5.关闭流
        reader.close();
        writer.close();

    }
}

实例2

package IO;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.Reader;
import java.io.Writer;

/**
 * 案例：利用字符流实现字符文件的拷贝1.txt -> 3.txt
 * 1.字符文件的读取：FileReader
 * 2.字符文件的写入：FileWriter
 * 3.循环上面的过程
 * 4.添加上异常处理
 */
public class FileCopyDemo2 {
    public static void main(String[] args) {

        /**
         * 1.创建字符文件输入流指向1.txt
         * 2.创建文件输出流指向文件3.txt
         */
        Reader reader = null;
        Writer writer = null;

        try {
            reader = new FileReader("1.txt");
            writer = new FileWriter("3.txt");
            /**
             * 3.对接流，并循环输出
             * 4.判断循环条件：当输入流没有数据输入时结束循环
             */
            int i;
            while((i = reader.read()) != -1) {
                writer.write(i);
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            /**
             * 5.关闭流
             * (1).关闭流的时候也可能回出异常，所以也要进行异常处理。
             * (2).如果出现异常，就要强制关流，把流置为空就可以。
             */

            /**
             *     IO流用过之后必须关闭，但是IO流的代码中往往存在大量的异常，为了保证关流的操作一定会被执行，所以通过关流都在finally代码块中进行。
    而为了保证finally中可以看到流对象，通常都要外置定义流对象。
    又由于close方法本身有异常，需要再次捕获异常。
    而在finally里通过将引用置为null 使其成为垃圾 可以被回收。

             */
            try {
                reader.close();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                reader = null;
            }

            try {
                writer.close();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                writer = null;
            }

        }

    }
}

实例3

package IO;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.Reader;
import java.io.Writer;

/**
 * 案例：利用字符流实现字符文件的拷贝1.txt -> 3.txt
 * 1.字符文件的读取：FileReader
 * 2.字符文件的写入：FileWriter
 * 3.循环上面的过程
 * 4.添加上异常处理
 * 5.利用字符数组加快传输效率
 */
public class FileCopyDemo3 {
    public static void main(String[] args) {

        /**
         * 1.创建字符文件输入流指向1.txt
         * 2.创建文件输出流指向文件3.txt
         */
        Reader reader = null;
        Writer writer = null;

        try {
            reader = new FileReader("1.txt");
            writer = new FileWriter("3.txt");
            /**
             * 3.对接流，并循环输出
             * 4.判断循环条件：当输入流没有数据输入时结束循环
             * (1).创建一个指定容量的字符数组来存储数据
             * (2).读取数据的时候一次性读取1024个字符 ,将读入的字符放入ch字符数组里面
             * (3).写的时候将ch字符数组里面的数据从0位置开始一直写到第 i 个位置
             * (4).read()方法返回的是一个int值，其实就是返回ch字符数组里面存储内容的大小
             */
            int i = 0;
            char[] ch = new char[1024];

            while((i = reader.read(ch)) != -1) {
                writer.write(ch, 0, i);
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            /**
             * 5.关闭流
             * (1).关闭流的时候也可能回出异常，所以也要进行异常处理。
             * (2).如果出现异常，就要强制关流，把流置为空就可以。
             */
            try {
                reader.close();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                reader = null;
            }

            try {
                writer.close();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                writer = null;
            }

        }

    }
}

实例4

package IO;

import java.io.FileReader;
import java.io.Reader;

/**
 * 案例：编写一个流，来读取外部文件中的字符数据
 * 1.根据数据流动的方向：输入流
 * 2.根据操作数据的类型：字符流
 * 3.字符输入流：Reader
 * 4.操作的是文件：FileReader
 */
public class FileReaderDemo {
    public static void main(String[] args) throws Exception{
        /**
         * 选用类的时候我们先找到Reader类，发现是一个抽象类，所以去找它的子类
         * 找到了InputStreamReader类，它是字节流通向字符流的桥梁
         * 在它里面我们可以找到FileReader子类，他是用来读取字符文件的便捷类
         *
         * 构造方法：
         *         FileReader(File file) 在给定从中读取数据的 File 的情况下创建一个新 FileReader。
         *         FileReader(String fileName) 在给定从中读取数据的文件名的情况下创建一个新 FileReader。
         * 读取数据的方法：
         *         int read() 读取单个字符。
         *         int read(char[] cbuf) 将字符读入数组中的某一部分。
         * 关闭流：
         *         close()
         */

        // 1.创建一个文件字符输入流链接到指定文件
        Reader reader = new FileReader("1.txt");
        /**
         * 2.通过流读取文件中的数据
         * read()方法读取reader流里面的内容，一个字符一个字符的读取
         * 将读取的字符都放在i里面，当没有字符得时候就读入-1结束
         */
        int i = 0;
        while((i = reader.read()) != -1) {
            System.out.print((char)i);
        }
        // 3.关闭流
        reader.close();

    }
}

实例5

package IO;

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

/**
 * 案例：编写一个流，来将指定的字符写到外部文件中
 * 根据数据流动的方向：输出流
 * 根据操作数据的类型：字符流
 * 字符输出流：Writer
 * 操作的是文件：FileWriter
 */
public class FileWriterDemo {
    public static void main(String[] args) throws Exception {
        /**
         * 构造方法：
         *         FileWriter(File file) 根据给定的 File 对象构造一个 FileWriter 对象
         *         FileWriter(String fileName) 根据给定的文件名构造一个 FileWriter 对象
         * 输出数据的方法：
         *         write(int c) 写入单个字符。
         *         write(char[] cbuf) 写入字符数组的某一部分。
         * 刷新流：
         *         flush() 刷新该流的缓冲。
         * 关闭流：
         *         close() 关闭此流，但要先刷新它。
         */

        // 1.创建文件字符输出流
        Writer writer = new FileWriter("2.txt");
        // 2.通过字符输出流输出数据
        writer.write(97);
        // 3.冲刷流
        writer.flush();
        // 4.关闭流
        writer.close();
    }
}

实例6

package IO;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

/**
 * 1.案例：使用缓冲流BufferedReader BufferedWriter复制文本文件
 * 2.java提供了自带缓冲区的流 BufferedReader bufferedWriter，内部自带缓冲区
 * 3.功能：
 *         装饰其他流 提升读写性能
 *         装饰起来流 提供额外方法
 * 4.BufferedReader BufferedWriter会将文件中的内容先读取到缓冲区里面，
 *   然后read()方法读取数据的时候不再从文件里面直接读取，而是在缓冲区里面读取数
 *   据，这样可以极大地提高文件的读取效率。
 */
public class BufferedReader_BufferedWriterDemo1 {
    public static void main(String[] args) throws Exception {

        /** 步骤一：创建文件输入流和文件输出流，并用缓冲字符流将其包装起来
         *
         * 1.BufferedReader(Reader in)
         *         创建一个使用默认大小输入缓冲区的缓冲字符输入流。
         * 2.BufferedReader(Reader in, int sz)
         *          创建一个使用指定大小输入缓冲区的缓冲字符输入流。
         * 3.缓冲字符流可以自己指定缓存区大小，但是不建议自己指定，系统给定的缓冲区已经很合理
         */
        FileReader reader = new FileReader("1.txt");
        FileWriter writer = new FileWriter("3.txt");

        BufferedReader breader = new BufferedReader(reader);
        BufferedWriter bwriter = new BufferedWriter(writer);

        /** 步骤二：连接流，进行文件复制
         *
         * 1.read(char[] cbuf, int off, int len)
         *       将字符读入数组的某一部分。
         * 2.close()
         *       关闭该流并释放与之关联的所有资源。
         */
        int i = 0;
        char[] buf = new char[1024];

        while((i = breader.read(buf)) != -1) {
            bwriter.write(buf, 0, i);
        }
        // 关闭流
        breader.close();
        bwriter.close();
    }
}

实例7

package IO;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;

/**
 * 1.案例：使用缓冲流BufferedReader BufferedWriter复制文本文件
 * 2.使用readline()和newLine()方法进行文本文件的复制
 * 3.原理：BufferedReader先把文本内容读取到其内部的缓冲区里面，
 *        当readline()方法从缓冲区里面拿数据的时候通过识别 \r\n直接
 *   一行一行的拿,然后输出。
 * 4.原理：BufferedWriter中的newLine()方法可以将缓冲区里
 *   面的内容一行一行的拿取，然后输出。
 */
public class BufferedReader_BufferedWriterDemo2 {
    public static void main(String[] args) throws Exception {
        /** 步骤一：创建文件输入流和文件输出流，并用缓冲字符流将其包装起来
         *
         */

        BufferedReader breader = new BufferedReader(new FileReader("1.txt"));
        BufferedWriter bwriter = new BufferedWriter(new FileWriter("3.txt"));

        /** 步骤二：对接流，进行文件复制
         *
         * 1.BufferedReader  readLine()
         *          读取一个文本行。通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行。
         * 2.BufferedWriter  newLine()
         *         写入一个行分隔符。行分隔符字符串由系统属性 line.separator 定义，并且不一定是单个新行 ('\n') 符。
         * 3.两个方法同时用可以极大的提升程序运行的效率。
         */
        String line = null;

        while((line = breader.readLine()) != null) {
            bwriter.write(line);
            bwriter.newLine();
        }
        // 关闭流
        breader.close();
        bwriter.close();
    }
}