12：I/O流 | 易学教程

1.流是一组有序的数据序列，根据操作的类型，可分为输入流和输出流两种。流提供了一条通道程序，可以使用次通道吧源中的字节序列送到目的地。

2.输入流：程序从执行源的输入流中读取源中的数据，源可以是文件，网络，压缩包或其他数据源。

read()方法：从输入流中读取数据的下一个字节。返回0-255范围内的int字节值，如果到达流末尾而没有可用的字节，则返回值位-1。
read(byte[] b)：从输入流中读入一定长度的字节，并以证书的形式返回字节数。
mark(int realimit)方法：在输入流的当前位置放置一个标记，readlimit 参数告知此输入流在标记位置失效之前允许读取的字节数。
reset()方法：将输入指针返回到当前所做的标记处
skip(long n)方法：跳过输入流上的n个字节并返回实际跳过的字节数。
markSupported()方法：如果当前流支持mark()/reset()操作就返回true。
colse方法：关闭此输入流并释放与该流关联的所有系统资源。

3.输出流：输出流的执行是数据要达到的目的地，程序通过向输出流中写入数据吧信息传递到目的地。输出流的目标可以是文件，网络，压缩包或其他数据源。

write(int b)方法：将指定的字节写入此输出流。
write(byte[] b)方法：将b个字节从指定的byte数组写入此输出流。
write(byte[] b , int off , int len)方法：将制定byte数组中从偏移量off开始的len个字节写入此输出流。
flush()方法：彻底完成输出并清空缓存区。
close()方法：关闭输出流。

4.File 类

文件的创建与删除：
- File file = new File(" d:/1.txt ");
- File file = new File( String parent ,String child);　　// parent：父路径字符串，例如：D:/ 或 D:/doc；child：子路径字符串，例如：a.txt。
- File file = new File( File f ,String child);　　//f：父路径对象。例如，D:/doc/。child：子路径字符串，例如：b.txt。

File.createNewFile()方法创建一个word.txt的文件。File.delete() 方法将其删除。

package file;
import java.io.File;
public class FileCreateAndDetele {
    public static void main(String[] args) {
        File file = new File("D:\\zwh\\123.txt");
        if(file.exists()){
            file.delete();
            System.out.println("文件已删除!");
        }else{
            try{
                file.createNewFile();
                System.out.println("文件已创建!");
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

获取文件信息：

package file;
import java.io.File;

public class GetFileInfo {
    public static void main(String[] args) {
        File file = new File("D:\\zwh\\123.txt");
        if(file.exists()){
            String name = file.getName();                   //获取文件的名称
            System.out.println("获取文件的名称"+name);
            boolean canRead = file.canRead();               //判断文件是否为可读的
            System.out.println("判断文件是否为可读的"+canRead);
            boolean canWrite = file.canWrite();             //判断文件是否可被写入
            System.out.println("判断文件是否可被写入"+canWrite);
            boolean exist = file.exists();                  //判断文件是否存在
            System.out.println("判断文件是否存在"+exist);
            long length = file.length();                    //获取文件长度
            System.out.println("获取文件长度"+length);
            String absolutePath = file.getAbsolutePath();   //获取文件的绝对路径
            System.out.println("获取文件的绝对路径"+absolutePath);
            String parentPath = file.getParent();           //获取文件的父路径
            System.out.println("获取文件的父路径"+parentPath);
            boolean fileFile = file.isFile();               //判断文件是否存在
            System.out.println("判断文件是否存在"+fileFile);
            boolean directory = file.isDirectory();         //判断文件是否为一个目录
            System.out.println("判断文件是否为一个目录"+name);
            boolean hidden = file.isHidden();               //判断文件是否为隐藏文件
            System.out.println("判断文件是否为隐藏文件"+directory);
            long lastModified = file.lastModified();        //获取文件最后修改时间
            System.out.println("获取文件最后修改时间"+lastModified);
        }else{
            System.out.println("该文件不存在!");
        }
    }
}

输出结果：
获取文件的名称123.txt
判断文件是否为可读的true
判断文件是否可被写入true
判断文件是否存在true
获取文件长度0
获取文件的绝对路径D:\zwh\123.txt
获取文件的父路径D:\zwh
判断文件是否存在true
判断文件是否为一个目录123.txt
判断文件是否为隐藏文件false
获取文件最后修改时间1557284138567

文件输入/输出流（FileInputStream 类和FileOutputStream 类）：字节流

FileOutputStream 类：继承InputStream 类。提供了基本的文件读取能力。
FileOutputStream 类：继承OutputStream 类。提供了基本的文件写入能力。

FileInputStream 类常用的构造方法：FileInputStream(String name) 和 FileInputStream(File file)。

package file;

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

/**
 * 字节流
 */
public class FileInputOrOutputStream {                              //创建类
    public static void main(String[] args) {                        //主方法
        File file = new File("D:\\zwh\\123.txt");       //创建文件对象
        try{
            FileOutputStream  out = new FileOutputStream(file);     //创建FileOutputStream 对象
            byte buy[] = "我是一个程序员！".getBytes();            //创建byte型数组
            out.write(buy);                                         //将数组中的信息写入到文件中
            out.close();                                            //将流关闭
        }catch (Exception e){
            e.printStackTrace();
        }

        try{
            FileInputStream  in = new FileInputStream(file);                             //创建FileInputStream 类对象
            byte byt[] = new byte[1024];                                                 //创建byte数组
            int len = in.read(byt);                                                      //才能够文件中读取信息
            System.out.println("文件中的信息是："+ new String(byt,0,len));      //将文件中的信息输出
            in.close();                                                                  //将流关闭
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

FileReader 和 FileWriter 类：

FileReader 流顺序地读取文件，只要不关闭流，每次调用read()方法就顺序地读取源中其余的内容，知道源的末尾或流被关闭。优点：使用字符流避免中文乱码。

 1 package file;
 2 
 3 import java.io.*;
 4 
 5 /**
 6  * 字符流
 7  */
 8 public class FileReaderOrWriter {
 9     public static void main(String[] args) {
10         try{
11             File fileWrite = new File("D:\\zwh\\write.txt");   //创建文件对象
12             FileWriter out = new FileWriter(fileWrite);                   //创建文件写的对象FileWriter
13             String s = "北京合力中税科技发展有限公司!";                   //写入文件的内容
14             out.write(s);                                                 //写入内容
15             out.close();
16         }catch (Exception e){
17             e.printStackTrace();
18         }
19 
20         try {
21             File fileReader = new File("D:\\zwh\\read.txt");   //创建文件对象
22             FileReader in = new FileReader(fileReader);                   //创建文件读的对象FileReader
23             char byt[] = new char[1024];                                  //创建cahr数组
24             try {
25                 int len = in.read(byt);                                                     //
26                 System.out.println("文件中的信息是："+ new String(byt,0,len));
27                 in.close();
28             } catch (IOException e) {
29                 e.printStackTrace();
30             }
31         } catch (FileNotFoundException e) {
32             e.printStackTrace();
33         }
34     }
35 }

带缓存的输入输出流：
缓存：是 I/O 的一种性能优化。缓存流为 I/O 流增加了内存缓存区，有了缓存区，使得在流上执行skip()，mark()，和reset()方法都成为了可能。
BufferedInputStream 与 BufferedOutputStream 类：
- BufferedInputStream 类可以对所有 InputStream 类进行缓存区的包装，主要有2个构造方法：
  - BufferedInputStream(InputStream in) 创建一个带有32个字节的缓存流
  - BufferedInputStream(InputStream in , int size) 按指定大小来创建缓存区
- BufferedOutputStream 类输出信息和OutputStream 输出信息完全一样。不过BufferedOutputStream有一个flush()方法用来将缓存区的数据强制输出完。也有2个构造方法：
  - BufferedOutputStream（OutputStream in）创建一个带有32个字节的缓存流
  - BufferedOutputStream（OutputStream in , int size）按指定大小来创建缓存区
- 注：flush()方法就是用于即使在缓存区没有满的情况下，也将缓存区的内容强制写入到外设，习惯上称为刷新。fulsh()方法支队事业缓存区的OutputStream类的子类有效。当调用 close()方法时，系统在关闭流之前，也会将缓存区中的信息刷新到磁盘文件中。
BufferedReader 与 BufferedWriter 类：
- BufferedReader 类与 BufferedWriter 类分别继承Reader 类与Writer 类。这2个类太阳具有缓存机制，并可以以行为单位惊醒输入/输出。
BufferedReader 类常用的方法：
- read()方法：读取单个字符。
- readLine()方法：读取一个文本行，病将其返回为字符串。若无数据刻度，则返回null。

write(String s , int off , int len)方法：写入字符串的某一部分。
flush()方法：刷新该流的缓存。
newLine()方法：写入一个行分隔符。
使用BufferedWriter 类的Write()方法时，数据并没有立刻呗写入输出流，而是先进入缓存区中，如果想立刻将缓存区中的数据写入输出流，一定要调用flush()方法。

package file;

import java.io.*;

public class BufferedReaderAndWriter {
    public static void main(String[] args) {
        String context[] = {"你好","好久不见","最近好吗？","常联系"};             //定义字符串数组
        File file = new File("D:\\zwh\\brw.txt");
        try {
            FileWriter fileWriter = new FileWriter(file);                           //创建FileWriter 类对象
            BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);         //创建BufferedWriter 类对象
            for(int i=0;i<context.length;i++){                                      //循环遍历数组
                bufferedWriter.write(context[i]);                                   //将字符串数组中的元素写入到磁盘文件中
                bufferedWriter.newLine();                                           //将数组中的单个元素以单行的形式写入文件
            }
            bufferedWriter.close();
            fileWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            FileReader fileReader = new FileReader(file);
            BufferedReader bufferedReader = new BufferedReader(fileReader);
            String s = null;
            int i=0;
            while((s=bufferedReader.readLine()) != null){
                i++;
                System.out.println("第"+i+"行："+s);
            }
            bufferedReader.close();
            fileReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

数据输入/输出流（DataInputStream 类与 DateOutputStream 类），构造方法如下
- DataInputStream（InputStream in）:使用制定的基础InputStream创建一个DataInputStream。
- DateOutputStream（OutputStream out）：创建一个新的数据输出流，将数据写入制定基础输出流。
DateOutputStream 类提供三种写入字符串的方法：
- writeBytes(String s)。
- writeChars(String s)。
- writeUTF(String s)。

DataInputStream 类之提供了一个readUTF（）方法。

package file;

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

public class DataInputOrOutputStream {
    public static void main(String[] args) {
        try{
            FileOutputStream fs = new FileOutputStream("D:\\zwh\\dios.txt");            //创建FileOutputStream对象
            DataOutputStream ds = new DataOutputStream(fs);                                     //创建DataOutputStream对象
            ds.writeUTF("使用writeUTF（）方法写入数据；");                               //使用writeUTF（）方法写入磁盘文件数据
            ds.writeChars("使用writeChars（）方法写入数据");
            ds.writeBytes("使用writeBytes()方法写入数据");
            ds.close();
            fs.close();

            FileInputStream fileInputStream = new FileInputStream("D:\\zwh\\dios.txt"); //创建FileInputStream对象
            DataInputStream dataInputStream = new DataInputStream(fileInputStream);             //创建DataInputStream对象
            System.out.println(dataInputStream.readUTF());
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

Zip压缩，输入\输出流：
利用ZipOutputStream 类对象，可以将文件压缩为.zip文件。

ZipOutputStream 的构造方法为：ZipOutputStream （OutputStream out），常用方法如下：

putNextEntry(ZipEntry e)：开始写一个新的ZipEntry，并将流内的位置移至此entry所指数据的开头。
write(byte[] b , int off , int len )：将字节数组写入当前ZIP条目数据。
finish()：完成写入ZIP输出流的内容，无须关闭它所配合的OutputStream。
setComment(String comment)：可设置此ZIP文件的注释文字。

例如：给文件压缩称zip文件

package file;

import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class MyZip {
    public static void main(String[] args) {
        MyZip myZip = new MyZip();                              //创建MyZip对象
        String zipFileName = "D:\\zwh\\myZip.zip";              //创建需要压缩的文件的文件名
        File fileName = new File("D:\\zwh\\myZip");              //创建需要压缩的文件的文件名
        //myZip.zip("E:/hello.zip",new File("E:/hello"));
        myZip.zip(zipFileName,fileName);
    }


    private void zip(String zipFileName ,File inputFile){
        try {
            ZipOutputStream zipOutputStream = new ZipOutputStream(new FileOutputStream(zipFileName));
            zip(zipOutputStream,inputFile,"");
            System.out.println("压缩中。。。。。。。。。");
            try {
                zipOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    private void zip(ZipOutputStream outputStream,File file,String base){
        if(file.isDirectory()){
            File[] files = file.listFiles();
            if(base.length() !=0){
                try {
                    outputStream.putNextEntry(new ZipEntry(base+"/"));
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            for (int i=0;i<files.length;i++){
                zip(outputStream,files[i],base+files[i]);
            }
        }else{
            try {
                outputStream.putNextEntry(new ZipEntry(base));
                FileInputStream in = new FileInputStream(file);
                int b;
                System.out.println(base);
                while ((b=in.read()) != -1){
                    outputStream.write(b);
                }
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

例如：解压文件

package file;

import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;

/**
 * 解压
 */
public class MyJyZip {
    public static void main(String[] args) throws IOException {
        File fileName = new File("D:\\zwh\\my.zip");
        try {
            ZipFile zipFile = new ZipFile(fileName);
            ZipInputStream zipInputStream = new ZipInputStream(new FileInputStream(fileName));
            try {
                ZipEntry zipEntry = zipInputStream.getNextEntry();
                while ((zipEntry = zipInputStream.getNextEntry()) != null && !zipEntry.isDirectory()){
                    File tempFile = new File("E:\\" +zipEntry.getName());
                    if(!tempFile.exists()){
                        tempFile.getParentFile().mkdirs();
                        OutputStream outputStream = new FileOutputStream(tempFile);
                        InputStream inputStream = zipFile.getInputStream(zipEntry);
                        int count = 0;
                        while ((count = inputStream.read()) != -1){
                            outputStream.write(count);
                        }
                        outputStream.close();
                        inputStream.close();
                    }
                    zipInputStream.closeEntry();
                    System.out.println(zipEntry.getName()+"解压成功");
                }
                zipInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

来源：https://www.cnblogs.com/zwh820672664/p/10833529.html

标签

字节数组

对象数组

字节流

filereader

string

try