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();
    }
}

原文地址：https://www.cnblogs.com/chuijingjing/p/9574773.html

时间： 2024-10-11 14:24:18

Java 运用流传输文件的相关文章

java socket通信-传输文件图片--传输图片

ClientTcpSend.java   客户端发送类 package com.yjf.test; import java.io.DataOutputStream; import java.io.File; import java.io.FileInputStream; import java.net.InetSocketAddress; import java.net.Socket; public class ClientTcpSend { public static String clien

Java:IO流与文件基础

Java:IO流与文件基础 说明: 本文所有内容包含图片均为MrSaber自己编写,转载请练习我哦. 本章内容将会持续更新,大家可以关注一下并给我提供建议,谢谢啦. 走进流 什么是流 流:从源到目的地的字节的有序序列. 在Java中,可以从其中读取一个字节序列的对象称作 输入流,可以向其中写入一个字节序列的对象称作 输出流. ? 这些字节序列的来源可以是:文件.网络连接.内存块等. ? 抽象类InputStream和OutputStream是构成输入/输出(I/O)的基础. ? 因为面向字节的流

java io流 创建文件、写入数据、设置输出位置

java io流 创建文件 写入数据 改变system.out.print的输出位置 //创建文件 //写入数据 //改变system.out.print的输出位置 import java.io.*; public class Index{ public static void main(String[] args) throws Exception{ /** * 存储为二进制,给计算机看的 */ //创建文件 DataOutputStream sjl = new DataOutputStrea

Java使用Socket传输文件遇到的问题(转)

1.写了一个socket传输文件的程序,发现传输过去文件有问题.找了一下午终于似乎找到了原因,记录下来警示一下: 接受文件的一端,向本地写文件之前使用Thread.sleep(time)休息一下就解决了问题. 个人认为可能是传输过程中,接收端向磁盘写速度有点慢,被后面的覆盖导致错误. //---------------------------------------------------------------------------------------------------------

Java IO流和文件操作

Java.io 包几乎包含了所有操作输入.输出需要的类.所有这些流类代表了输入源和输出目标. Java.io 包中的流支持很多种格式,比如:基本类型.对象.本地化字符集等等. 一个流可以理解为一个数据的序列.输入流表示从一个源读取数据,输出流表示向一个目标写数据. Java 为 I/O 提供了强大的而灵活的支持,使其更广泛地应用到文件传输和网络编程中. 控制台输入 BufferedReader br = new BufferedReader(new InputStreamReader(Syste

关于java io流操作文件探讨

1.任务描述    2.读取一个字符 3.读取整个文件 4.复制文件 5.复制大文件 6.利用字符流解决乱码问题 一.任务描述 大家都知道程序是程序的运行是离不开内存的,但是很多东西并不在程序当中,而程序也需要操作它们.所以就需要一个东西与内存外的资源打交道,我们就把这个东西称为io流.io流分为输出流和输入流,输出流是将内存中的东西输出到内存之外,输入流是将内存之外的东西读取到内存中.一旦有了io流之后,与内存之外的资源打交道就十分方便了.为什么这么说,其实总体上就只需要三步操作,第一步,定位

java io流与文件操作

Java的文件操作 File类位于java.io包中 我们可以使用File操作文件 首先创建对象 File file=new File("路径")//关联文件 创建文件:file.createNewFile()//首先这里会抛异常需要try...catch处理,其次如果有同名文件则不会创建. 创建文件夹:file.mkdir文件操作 File类位于java.io包中 我们可以使用File操作文件 首先创建对象 File file=new File("路径")//关联

Java IO流 之 文件复制

http://www.verejava.com/?id=16994676228912 package com.io; import java.io.*; public class TestCopy { public static void main(String[] args) { InputStream is=null; OutputStream os=null; try { //读取文件 english.txt is=new FileInputStream(new File("res/1.p

Java通过流对文件加密

加密目标文件 代码如下: 不建议进行二次加密,若二次加密必须要二次解密 package com.xgt.util; import java.io.*; public class VideoEncodeUtil { public static void main(String[] args) throws Exception { encrypt("D:\\py交易\\11.mp4","fuckyourself"); decrypt("D:\\py交易\\11