一、流的概述

流是一种有序的数据序列，根据操作的类型，可分为输入流和输出流（可理解为一座桥）。

1、按数据流向分类：输入流和输出流

2、按数据类型分类：字节流和字符流

（1）字节流和字符流的区别

• 字节流：一次读入或读出是8位二进制

• 字符流：一次读入或读出是16位二进制

• 处理纯文本数据，优先考虑使用字符流。 其他的都使用字节流。

二、输入流和输出流

1、字节输入流(InputStream)：适用于处理字节

InputStream类是字节输入流的抽象类，是所有字节输入流的父类。

(1)InputStream的方法及说明

说明：并不是所有的InputStream类的子类都支持InputStream类中定义的方法，如skip()、mark()、reset()、等方法只对某些子类有用。

2、字节输出流(outputStream) 

outputStream类是字节输出流的抽象类，是所有的输出字节流的父类。

 outputStream的方法及说明：

3、字符输入流(reader)：适用于处理字符文本.

reader类是字符输入流的抽象类，是所有字符输入流的父类。

4、字符输出流(writer)：

writer类是字符输出流的抽象类，是所有的输出字符流的父类。

 三、File类

File类是java.io包中唯一代表磁盘文件本身的对象，可以通过调用File类中的方法来实现创建、删除、重命名文件等操作。

1、文件的创建和删除：

示例：在项目中创建FileTest,在主方法中判断D盘中是否存在word.txt文件，如果该文件存在则将其删除，如果不存在则创建该文件。

public class FileTest {                                     //创建类
    public static void main(String[] args) {                //主方法
        File file = new File("D:\myWord.txt");             //创建文件对象
        if(file.exists()){                                  //判断该文件是否存在
            file.delete();                                  //将文件删除
            System.out.println("文件已删除");                //输出提示语句
        }else{                                              //如果不存在
            try{                                            //捕获可能出现的异常
                file.createNewFile();                       //创建文件
                System.out.println("文件已创建");            //输出提示语句
            }
            catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

结果：

 File常用方法：

2、文件的输入流和输出流：

程序运行期间，大部分数据都在程序内部进行，当程序关闭运行时，这些程序就会消失。如果需要将数据永久保存，可使用文件输入/输出流与指定的文件简历关系，将需要的数据永久保存到文件中。

（1）字节输入流(FileInputStream类)和字节输出流(FileOutputStream类)

• FileInputStream常用构造方法：

FileInputStream(String name)
FileInputStream(File file)

• FileOutputStream常用构造方法：

FileOutputStream(String name)
FileOutputStream(File file)

第一个构造方法使用给定的文件名name，创建一个FileInputStream对象。
第二个构造方法使用File对象创建FileInputStream，且允许在把文件连接输入流之前对文件做进一步解析。

（2）字符输入流(FileReader)类和字符输出流(FileWriter)类

使用FileInputStream类和FileOutputStream类想文件写入或从文件读取内容都存在一个不足，即这两个类都只提供了对字节或字节数组的读取方法。由于汉字在文件中占两个字节，如果使用字节流，可能会出现读取乱码的现象，此时使用FileReader类和FileWriter类可避免这样的情况发生。

• FileReader常用方法

int read()：读取单个字符 

int read(char[] cbuf) ：将字符读入数组

abstract int read(char[] cbuf, int off, int len)： 将字符读入数组的某一部分

long skip(long n)：跳过字符

abstract void close()：关闭该流并释放与之关联的所有资源

• FileWriter常用方法

void write(char[] cbuf)：写入字符数组

abstract void write(char[] cbuf, int off, int len)： 写入字符数组的某一部分

void write(int c)： 写入单个字符

void write(String str)：写入字符串

void write(String str, int off, int len)：写入字符串的某一部分writer

Writer append(char c)：将指定字符添加到此writer

Writer append(CharSequence csq)：将指定字符序列添加到此

writer.Appendable Writer append(CharSequence csq, int start, int end)：将指定字符序列的子序列添加到此

abstract void close()： 关闭此流，但要先刷新它

abstract void flush()：刷新该流的缓冲

 示例：

public class FileTest {                                     //创建类
    public static void main(String[] args) throws IOException {

        File f = new File("a.txt");
        FileOutputStream fop = new FileOutputStream(f);
        // 构建FileOutputStream对象,文件不存在会自动新建

        OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
        // 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk

        writer.append("中文输入");
        // 写入到缓冲区

        writer.append("rn");
        // 换行

        writer.append("English");
        // 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入

        writer.close();
        // 关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉

        fop.close();
        // 关闭输出流,释放系统资源

        FileInputStream fip = new FileInputStream(f);
        // 构建FileInputStream对象

        InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
        // 构建InputStreamReader对象,编码与写入相同

        StringBuffer sb = new StringBuffer();
        while (reader.ready()) {
            sb.append((char) reader.read());
            // 转成char加到StringBuffer对象中
        }
        System.out.println(sb.toString());
        reader.close();
        // 关闭读取流

        fip.close();
        // 关闭输入流,释放系统资源

    }

3、带缓存的输入/输出流

缓存是I/Ode1一种性能优化。缓存流为I/O流增加了内存缓存区，有了缓存区，使得在留上执行skip()、mark()、reset()都成为了可能。

（1）字节缓存流BufferedInputStream和BufferedOutputStream

BufferedInputStream构造方法

BufferedInputStream(InputStream in)：创建一个 BufferedInputStream并保存其参数，即输入流in，以便将来使用。

BufferedInputStream(InputStream in, int size)：创建具有指定缓冲区大小的 BufferedInputStream并保存其参数，即输入流in以便将来使用

 BufferedOutputStream构造方法：

构造方法：

BufferedOutputStream(OutputStream out)：创建一个新的缓冲输出流，以将数据写入指定的底层输出流

BufferedOutputStream(OutputStream out, int size)：创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流

常用方法：

void write(byte[] b, int off, int len)：将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流

void write(int b)： 将指定的字节写入此缓冲的输出流

void flush()： 刷新此缓冲的输出流

(2)字符缓冲流BufferedReader和BufferedWriter

 BufferedReader常用方法：

构造方法：

BufferedReader(Reader in)：创建一个使用默认大小输入缓冲区的缓冲字符输入流

BufferedReader(Reader in, int sz)：创建一个使用指定大小输入缓冲区的缓冲字符输入流

特有方法：

String readLine()：读取一个文本行

BufferedWrite常用方法：

构造方法：

BufferedWriter(Writer out)：创建一个使用默认大小输出缓冲区的缓冲字符输出流

BufferedWriter(Writer out, int sz)：创建一个使用给定大小输出缓冲区的新缓冲字符输出流

特有方法：

void newLine()：写入一个行分隔符

示例：

   FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4");
        BufferedInputStream bis = new BufferedInputStream(inputStream);
        FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
        BufferedOutputStream bos = new BufferedOutputStream(outputStream);
        int len;
        byte[] bs = new byte[1024];
        // 开始时间
        long begin = System.currentTimeMillis();
        while ((len = bis.read(bs)) != -1) {
            bos.write(bs, 0, len);
        }
        // 用时毫秒
        System.out.println(System.currentTimeMillis() - begin);// 78

        bis.close();
        bos.close();

4、数据输入流和输出流

 压缩流操作主要的三个类 ZipOutputStream、ZipFile、ZipInputStream 。

在 ZIP 输入输出流中，压缩包中的每个文件或目录都是一个ZipEntry对象，通过调用 putNextEntry(new ZipEntry(path)和getNextEntry() 就可以放入或取出这些文件对象，其实就是对应着压缩和解压的操作

（1）压缩文件：

利用ZipOutputStream类对象，可将文件压缩为.zip文件。

ZipOutputStream构造方法：

示例：

import java.io.File ; 
import java.io.FileInputStream ; 
import java.io.InputStream ; 
import java.util.zip.ZipEntry ; 
import java.util.zip.ZipOutputStream ; 
import java.io.FileOutputStream ; 
public class ZipOutputStreamDemo02{ 
    public static void main(String args[]) throws Exception{    // 所有异常抛出 
        File file = new File("d:" + File.separator + "mldn") ;  // 定义要压缩的文件夹 
        File zipFile = new File("d:" + File.separator + "mldndir.zip") ;    // 定义压缩文件名称 
        InputStream input = null ;  // 定义文件输入流 
        ZipOutputStream zipOut = null ; // 声明压缩流对象 
        zipOut = new ZipOutputStream(new FileOutputStream(zipFile)) ; 
        zipOut.setComment("www.mldnjava.cn") ;  // 设置注释 
        int temp = 0 ; 
        if(file.isDirectory()){ // 判断是否是文件夹 
            File lists[] = file.listFiles() ;   // 列出全部文件 
            for(int i=0;i<lists.length;i++){ 
                input = new FileInputStream(lists[i]) ; // 定义文件的输入流 
                zipOut.putNextEntry(new ZipEntry(file.getName() 
                    +File.separator+lists[i].getName())) ;  // 设置ZipEntry对象 
                while((temp=input.read())!=-1){ // 读取内容 
                    zipOut.write(temp) ;    // 压缩输出 
                } 
                input.close() ; // 关闭输入流 
            } 
        } 
        zipOut.close() ;    // 关闭输出流 
    } 
}; 

（2）解压文件

ZipInputStream类可读取ZIP压缩格式的文件，包括已压缩和未压缩的条目(entry)。ZipInputStream类的构造方法如下：

ZipInputStream(inputStream in)

常用方法：

``
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
/**
 * 实现文件[夹]解压
 * @author ljheee
 *
 */
public class UnZip{

    /**
     * 解压到指定目录
     * @param zipPath
     * @param descDir
     */
    public static void unZipFiles(String zipPath, String descDir) throws IOException {
        unZipFiles(new File(zipPath), descDir);
    }

    /**
     * 解压文件到指定目录
     * 解压后的文件名，和之前一致
     * @param zipFile	待解压的zip文件
     * @param descDir 	指定目录
     */
    @SuppressWarnings("rawtypes")
    public static void unZipFiles(File zipFile, String descDir) throws IOException {

        ZipFile zip = new ZipFile(zipFile,Charset.forName("GBK"));//解决中文文件夹乱码
        String name = zip.getName().substring(zip.getName().lastIndexOf('\')+1, zip.getName().lastIndexOf('.'));

        File pathFile = new File(descDir+name);
        if (!pathFile.exists()) {
            pathFile.mkdirs();
        }

        for (Enumeration<? extends ZipEntry> entries = zip.entries(); entries.hasMoreElements();) {
            ZipEntry entry = (ZipEntry) entries.nextElement();
            String zipEntryName = entry.getName();
            InputStream in = zip.getInputStream(entry);
            String outPath = (descDir + name +"/"+ zipEntryName).replaceAll("\*", "/");

            // 判断路径是否存在,不存在则创建文件路径
            File file = new File(outPath.substring(0, outPath.lastIndexOf('/')));
            if (!file.exists()) {
                file.mkdirs();
            }
            // 判断文件全路径是否为文件夹,如果是上面已经上传,不需要解压
            if (new File(outPath).isDirectory()) {
                continue;
            }
            // 输出文件路径信息
//			System.out.println(outPath);

            FileOutputStream out = new FileOutputStream(outPath);
            byte[] buf1 = new byte[1024];
            int len;
            while ((len = in.read(buf1)) > 0) {
                out.write(buf1, 0, len);
            }
            in.close();
            out.close();
        }
        System.out.println("******************解压完毕********************");
        return;
    }

    //测试
    public static void main(String[] args) {
        try {
            unZipFiles(new File("C:/Users/Desktop/helloWord.zip"), "C:/Users/king/Desktop/");  //第一个路径为待解压文件  第二个为解压后的文件存放路径
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

最后

以上就是勤劳鲜花为你收集整理的JAVA IO流一、流的概述二、输入流和输出流 三、File类的全部内容，希望文章能够帮你解决JAVA IO流一、流的概述二、输入流和输出流 三、File类所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。