[Java培训]IO流读写文件大全 _常州电脑培训_常州网络营销培训_常州软件开发培训

核心课程

开班动态

SolidWorks制图班开班[3月12日]

网络推广工程师开班[3月22日]

商务办公自动化开班[3月5日]

专题服务

您当前所在位置：首页 > 中心动态

[Java培训]IO流读写文件大全

常州Java培训学习课程报名咨询：常州文化宫校区：0519-69886161、新北校区：0519-68877558！

1.1 I/O流概述

流(stream)的概念源于UNIX中管道(pipe)的概念。在UNIX中，管道是一条不间断的字节流，用来实现程序或进程间的通信，或读写外围设备、外部文件等。

一个流，必有源端和目的端，它们可以是计算机内存的某些区域，也可以是磁盘文件，甚至可以是Internet上的某个URL。

流的方向是重要的，根据流的方向，流可分为两类：输入流和输出流。用户可以从输入流中读取信息，但不能写它。相反，对输出流，只能往输入流写，而不能读它。

实际上，流的源端和目的端可简单地看成是字节的生产者和消费者，对输入流，可不必关心它的源端是什么，只要简单地从流中读数据，而对输出流，也可不知道它的目的端，只是简单地往流中写数据。

形象的比喻——水流，文件======程序，文件和程序之间连接一个管道，水流就在之间形成了,自然也就出现了方向：可以流进，也可以流出.便于理解，这么定义流：流就是一个管道里面有流水，这个管道连接了文件和程序。

1、java.io包中定义了多个流类型(类或抽象类)来实现输入/输出功能。

2、流的分类

（1）按照处理的数据类型分类：字节流、字符流。

一个字符 = 两个字节（16位，Unicode编码）。

处理字节的流：InputStream、OutputStream；（都是抽象类）

处理字符的流：Reader、Writer。（都是抽象类）

（2）按照流的方向分类：输入流、输出流；

（3）按照流的角色分类：节点流、处理流。

节点流：可以从/向一个特定的IO设备读/写数据的流；（又称低级流）

处理流：实现对一个已存在的流进行连接和封装。（又称高级流）

1.2 流的层次

1.2.1 InputStream的层次

1.2.2 OutputStream的层次

1.2.3 Reader的层次

1.2.4 Writer类层次

缓冲流：对节点流进行缓冲，对读写数据进行缓冲，提高程序的效率。

– BufferedReader

– BufferedWriter

– BufferedInputStream

– BufferedOutputStream

1.2.5 常见的IO流

关于IO流：

File f=new File("指定要读的文件路径");

String path="c://01.txt";

样例代码大全：

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.URL;

/**
* 字节流测试
*/
public class InputStreamTest {

    /**
    * 采用FileInputStream读取文件
    * 注意：InputStream是字节流，是不适合读取含中文的txt文件的，因为一个中文是2个字节
    * 如：文件内容是：123好，2个字节一读取的话，第一次地区到12，第二次读取到3和好的第一个字节
    * 那么好一定会乱码
    */
    public static void readFile(){
        try {
            //System.getProperty()：获取系统属性，user.dir代表用户当前工作目录
            FileInputStream fis = new FileInputStream(System.getProperty("user.dir") + "/src/a.txt");
            //1024个字节一次缓冲读入，如果一个字节一次读取，那么中文输出会乱码（长度改成1或者2试试？）
            byte[] buff = new byte[1024];
            int x = fis.read(buff);
            while(x != -1){
                //输出字符数据(0表示从byte数组第0个位置输出，x表示输出x个字节的内容)
                String s = new String(buff,0,x);
                System.out.print(s);
                x = fis.read(buff);
            }

            //关闭通道，释放资源
            fis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
    * 利用BufferedInputStream提高效率
    * 不带缓冲的操作，每读一个字节就要写入一个字节，由于涉及磁盘的IO操作相比内存的操作要慢很多，所以不带缓冲的流效率很低
    * 带缓冲的流，可以一次读很多字节，但不向磁盘中写入，只是先放到内存里。等凑够了缓冲区大小的时候一次性写入磁盘。
    * 这种方式可以减少磁盘操作次数，速度就会提高很多
    */
    public static void readBufferdFile() throws Exception{
        FileInputStream fis = new FileInputStream(System.getProperty("user.dir") + "/src/a.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);

        byte[] b = new byte[1024];
        int x = bis.read(b);//x代表读取的字节数
        while(x != -1){
            String s = new String(b,0,x);
            System.out.print(s);
            x = bis.read(b);
        }

        bis.close();
        fis.close();
    }

    /**
    * 利用FileInputStream和FileOutputStream进行文件复制
    */
    public static void copyFiles() throws Exception{
        FileInputStream fis = new FileInputStream(System.getProperty("user.dir") + "/src/a.txt");
        FileOutputStream fos = new FileOutputStream(new File(System.getProperty("user.dir") + "/src/b.txt"));
        //尝试改成1或者2试试？是否都是正常的
        byte[] b = new byte[1024];
        int x = fis.read(b);
        while(x != -1){
            fos.write(b);
            x = fis.read(b);
        }

        fis.close();
        fos.close();
    }

    /**
    * 利用FileInputStream和FileOutputStream进行文件复制
    * 升级版的文件拷贝，计算文件大小，计算拷贝进度和拷贝量
    * copyFiles2("D:/MetInfo5.3.zip","D:/test.zip"); 找一个大文件测试一下
    */
    public static void copyFiles2(String fromdir,String todir) throws Exception{
        FileInputStream fis = new FileInputStream(fromdir);
        File fromfile = new File(fromdir);//源文件
        File tofile = new File(todir);//目标文件
        FileOutputStream fos = new FileOutputStream(tofile);
        //尝试改成1或者2试试？是否都是正常的
        byte[] b = new byte[1024];
        int x = fis.read(b);
        int c = 1;
        while(x != -1){
            fos.write(b);
            x = fis.read(b);

            System.out.println("已经拷贝" + c + "KB" + "，拷贝了" +
                    String.format("%.2f", c * 1024.0 / fromfile.length() * 100) + "%");
            c++;
        }

        fis.close();
        fos.close();
    }

    /**
    * 利用BufferedInputStream和BufferedOutputStream提高效率
    * 并对比两个拷贝分别花的时间
    * long a = System.currentTimeMillis();
    * bufferedCopy("D:/MetInfo5.3.zip","D:/test.zip");
    * long b = System.currentTimeMillis();
    * System.out.println(b - a);
    */
    public static void bufferedCopy(String from,String to) throws Exception{
        File fromfile = new File(from);
        File tofile = new File(to);

        FileInputStream fis = new FileInputStream(fromfile);
        FileOutputStream fos = new FileOutputStream(tofile);

        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        //用来存放读取的内容
        byte[] b = new byte[1024];
        int x = bis.read(b);

        int c = 1;
        //如果没有读取到文件的末尾
        while(x != -1){
            bos.write(b);
            x = bis.read(b);

            System.out.println("已经拷贝" + c + "KB，拷贝" +
            String.format("%.2f", c * 1024.0 / fromfile.length() * 100) + "%");
            c++;
        }

        bis.close();
        bos.close();
        fis.close();
        fos.close();
    }

    /**
    * 利用Reader来读取字符流
    */
    public static void readerFile(String file) throws Exception{
        FileReader reader = new FileReader(file);
        //尝试改成1试试
        char[] buff = new char[1024];
        int x = reader.read(buff);
        while(x != -1){
            String s = new String(buff,0,x);
            System.out.print(s);
            x = reader.read(buff);
        }
        reader.close();
    }

    /**
    * 利用BufferedReader来提高效率
    */
    public static void bufferedReader(String file) throws Exception{
        FileReader reader = new FileReader(file);
        BufferedReader br = new BufferedReader(reader);

        //按行读取
        String s = br.readLine();
        while(s != null){
            System.out.println(s);
            s = br.readLine();
        }

        br.close();
        reader.close();
    }

    /**
    * 读取网络流
    * @param url
    */
    public static void readURL(String domain) throws Exception{
        URL url = new URL(domain);
        InputStreamReader is = new InputStreamReader(url.openStream(),"utf-8");
        BufferedReader br = new BufferedReader(is);
        String s = br.readLine();

        while(s != null){
            System.out.println(s);
            s = br.readLine();
        }

        is.close();
    }

    /**
    * 读取网络流后把网址内容写下来（采集网站内容）
    * @param url
    */
    public static void copyUrl(String domain,String to) throws Exception{
        URL url = new URL(domain);
        InputStreamReader is = new InputStreamReader(url.openStream(),"utf-8");
        BufferedReader br = new BufferedReader(is);
        String s = br.readLine();

        //字符写入流
        OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(new File(to)),"utf-8");
        BufferedWriter bw = new BufferedWriter(writer);

        while(s != null){
            System.out.println(s);
            s = br.readLine();
            bw.append(s + "\n");
        }

        is.close();
    }

    public static void main(String[] args) {
        try {
            copyUrl("http://www.sina.com.cn","D:/a.html");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

精彩文章推荐

	【常州电脑培训】互联网广告风暴十年	[2014-5-12]
	传统企业需要突破互联网思维壁垒	[2014-3-8]
	传统企业转型应重理念转变	[2014-2-27]
	常州招聘-制图员【机械设计】	[2014-1-8]
	常州东方博宜教学环境展示	[2013-12-27]
	常见的软件测试方法——东方博宜软件测试课程	[2012-7-8]
	安卓中的文件布局—常州电脑培训	[2012-6-21]
	常州Java培训——Tomcat安装	[2011-9-28]