Java第十四章I/O

绪论：

在变量、数组和对象中存储的数据是暂时存在的，程序结束后就会自动丢失，将数据永久的保存在磁盘文件中使用I/O

流概述：

//流是一种有序的数据序列，根据操作类型，可以分为输入流和输出流俩种。

File类

文件的创建与删除（三种构造方法）
File file =new File(String pathname);
例：File file =new File("D:/1.txt");
File file =new File(String parent,String child);
例：File file = new File("D:/","1.txt");
File file = new File(File f,String child);
例：File file = new File("D://","1.txt");
//判断在某个路径下有没有word.txt文件，若无则创建，有则删除
package 输入输出;

import java.io.File;

public class FileTest {
public static void main(String args[]){
    File file = new File("word.txt");  //创建文件对象
    if (file.exists()){
        file.delete();
        System.out.println("此文件已删除");
    }
    else {
        try {
            file.createNewFile();
            System.out.println("该文件已被创建");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
}

获取文件信息

package 输入输出;

import java.io.File;

public class FileTest {
public static void main(String args[]){
    File file = new File("word.txt");  //创建文件对象
    if (file.exists()) {
        String name=file.getName();  //获取文件名
        long length=file.length();  //获取文件长度（字节数）
        boolean hidden=file.isHidden();  //文件是否被隐藏
        System.out.println("该文件名为："+name);
        System.out.println("该文件的长度为："+length);
        System.out.println("该文件是否为隐藏？"+hidden);
    }
    else {
        System.out.println("此文件不存在");
    }
}
}

文件输入输出流

//程序在运行时有时需要将数据永久保存在文件中，使用输入输出流。

FileInputStream与FileOutputStream类

//此类用于操作磁盘文件，构造方法如下：
FileInputStream(String name);
FileInputStream(File file);
//注意：操作文件时不能是已被其它应用程序打开的文件，而且这俩个类都提供了对字节和字节数组的读取方法。
使用FileOutputStream类向文件word.txt写入信息，然后通过FileInputStream类将文件中的数据读取到控制台上
package 输入输出;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class FileTest {
public static void main(String args[]){
    //创建文件对象
    File file=new File("word.txt");
    try {
        //创建FileOutputStream对象
        FileOutputStream out=new FileOutputStream(file);
        //创建byte类型数组
        byte buy[]="我有一只小毛驴，我从来都不骑。".getBytes();
        //将数组中的信息写入到文件中
        out.write(buy);
        //关闭数据流
        out.close();
        //catch语句处理异常信息
    } catch (Exception e) {
        //输入异常信息
        e.printStackTrace();
    }
    try {
        FileInputStream in=new FileInputStream(file);
        //创建byte类型数组
        byte bye[]=new byte[1024];
        //从文件中读取信息
        int len=in.read(bye);
        //将文件中的信息输出
        System.out.println("文件中的信息是："+new String(bye,0,len));
    } catch (Exception e) {
        e.printStackTrace();
    }
}
}
//虽然Java在程序运行结束后自动关闭所有流，但是显式关闭所有打开的流是一个好习惯，若没有将打开的流关闭，当另一个程序视图打开另一个流，可能得不到所需要的资源。

FileReader和FileWriter类

此类对于汉字的读取效率更高

带缓存的输入/输出流

BufferedInputStream与BufferedOutputStream类

构造方法如下：
BufferedInputStream(InputStream in);
BufferedInputStream(InputStream in.int size);
//第一种形式的构造方法创建了一个带有32个字节的缓存器，第二种形式的构造方法按指定的大小来创建缓存器。
//使用此类与InputStream输入信息完全一样，只是此类带有一个flush()方法用来将缓存区的数据强制输出。
//flush()方法就是用于即使当缓存区还没有满的时候，也将缓存区的内容强制写入到外设，当调用close()方法时，系统在关闭之前也会将缓存区的信息刷新到磁盘。

BufferedReader与BufferedWriter类

//这俩个类同样具有内部缓存机制，且可以以行为单位进行输入输出。
//当BufferedWriter类中Writer()方法时，数据并没有立即写入输出流，而是首先进入缓存区，若想立即写入则可以用flush()方法 
//向指定磁盘文件中写入数据，通过BufferedReader类将文件中的信息分行显示
package 输入输出;

import java.io.*;

public class Student {
public static void main(String args[]){
    //创建字符串数组
    String content[]={"好久不见","最近好吗","常联系好吗"};
    //创建文件对象
    File file=new File("word.txt");
    try {
        //创建FileWriter类对象
        FileWriter fw=new FileWriter(file);
        //创建BufferedFileWriter类对象
        BufferedWriter bufw=new BufferedWriter(fw);
        for (int i=0 ; i < content.length ; i++) {
            //将字符串数组中的元素写入到磁盘中
            bufw.write(content[i]);
            //将数组中的单个元素以单行的都形式写入文件
            bufw.newLine();
        }
        //关闭数据流
        bufw.close();
        fw.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
    try {
        FileReader fr=new FileReader(file);
        BufferedReader bufr=new BufferedReader(fr);
        String s = null;
        int i=0;
        //如果文件的文本行数不为null则进入循环
        while ((s = bufr.readLine()) != null) {
            i++;
            System.out.println("第"+i+"行"+s);
        }
        //关闭数据流
        bufr.close();;
        fr.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

}

数据输出输入流

//便捷之处在于当读取一个数据时，不必再关心这个数值是哪种字节
DataInputStream类与DataOutputStream类的构造方法
DataInputStream(InputStream in);
DataOutputStream(OutputStream out);
//DataOutputStream类中提供了三种写入字符串的方法
writeBytes(String s);
writeChars(String s);
writeUTF(String s);
//第一种只是将字符串中的每一个字符的低字节内容写到目标设备中，第二种是将字符串中的每个字符的俩个字节的内容都写入到目标设备中，第三种是暗中UTF编码后的字节长度写入目标设备中，然后才是每一个字节的UTF编码。
//分别通过三种方法写入，通过readUTF()方法将写入的数据输出到控制台上
package 输入输出;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Example_01 {
public static void main(String args[]){
    try {
        //创建FileOutputStream对象
        FileOutputStream fs = new FileOutputStream("word.txt");
        //创建DataFileOutputStream对象
        DataOutputStream ds = new DataOutputStream(fs);
        //写入磁盘文件数据
        ds.writeUTF("使用writeUTF()方法写入数据：");
        ds.writeChars("使用writeChars()方法写入数据：");
        ds.writeBytes("使用writeByte()方法写入数据：");
        ds.close();
        FileInputStream fis = new FileInputStream("word.txt");
        DataInputStream dis = new DataInputStream(fis);
        //将文件输出
        System.out.println(dis.readUTF());
        System.out.println(dis.readChar());
        System.out.println(dis.readByte());
    } catch (Exception e) {
        e.printStackTrace();
    }
}
}

ZIP压缩输入输出流

如果要从ZIP压缩管理文件内读取某个文件，首先找到对应文件的目录进入点，才能读取这个文件的内容，如果要将文件内容写入ZIP文件内，必须先写入对应于文件的目录进入点，并且把要写入文件内容的位置移入进入点所指的位置。
ZipInputStream类用来读取ZIP格式压缩文件，所支持的包括已压缩以及未压缩的进入点，ZipOutputStream类用来写出ZIP压缩格式的文件，而且所支持的包括已压缩的和未压缩的。

压缩文件

//压缩E盘d的hello文件夹，将压缩后的文件存入E盘根目录下
package 输入输出;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class MyZip {
private void zip(String zipFileName,File inputFile) throws Exception{
    //创建ZipOutputStream类对象
    ZipOutputStream out=new ZipOutputStream(new FileOutputStream(zipFileName));
    //调用方法
    zip(out,inputFile,"");
    System.out.println("压缩中");
    out.close();
}
//方法重载
private void zip(ZipOutputStream out, File f,String base) throws Exception{
    //测试此抽象路径名表示的文件是否为一个目录
    if (f.isDirectory()) {
        //获取路径数组
        File fl[]=f.listFiles();
        if (base.length()!=0) {
            //写入此目录entry
            out.putNextEntry(new ZipEntry(base+"/"));
        }
        //循环遍历数组中的文件
        for (int i=0;i<fl.length;i++){
            zip(out,fl[i],base+fl[i]);
        }
    } else {
        //创建新的进入点
        out.putNextEntry(new ZipEntry(base));
        FileInputStream in = new FileInputStream(f);
        int b;
        System.out.println(base);
        //如果没有达到流的尾部
        while ((b = in.read())!= -1) {
            //将字节写入当前ZIP条目
            out.write(b);
        }
        in.close();
    }
}
public static void main(String args[]){
    //创建本例对象
    MyZip book = new MyZip();
    try {
        //调用方法，参数为压缩后文件与要压缩的文件
        book.zip("E:/hello.zip",new File("E:/hello"));
        System.out.println("压缩完成");
    } catch (Exception ex){

    }
}
}

解压ZIP文件

package 输入输出;

import java.io.*;
import java.lang.reflect.Field;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;

public class Decompressing {
public static void main(String args[]){
    //当前压缩文件
    File file=new File("hello.zip");
    ZipInputStream zin;
    try {
        //创建压缩文件对象
        ZipFile zipFile = new ZipFile(file);
        //实例化对象，表明要进行解压的文件
        zin = new ZipInputStream(new FileInputStream(file));
        //跳过根目录，获取下一个ZipEntry
        ZipEntry entry = zin.getNextEntry();
        //如果entry不为空，并不在同一目录下
        while (((entry = zin.getNextEntry())!= null) && !entry.isDirectory()) {
            //解压出文件的路径
            File tmp = new File("E:\\" + entry.getName());
            //如果该文件不存在
            if (!tmp.exists()){
                //将文件目录中的文件放入输出流
                OutputStream os = new FileOutputStream(tmp);
                //用输入流，读取压缩文件中指定目录的文件
                InputStream in = zipFile.getInputStream(entry);
                int count = 0;
                //如有输出流可以读取到数值
                while ((count = in.read()) != -1) {
                    //输出流写入
                    os.write(count);
                }
                os.close();
                in.close();
            }
            //关闭当前entry
            zin.closeEntry();
            System.out.println(entry.getName() + "解压成功");
        }
        //关闭流
        zin.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}
}