输入与输出（I/O流）

流是一组有序的数据序列，根据操作的类型，可分为输入流和输出流

File类

基本内容： File类是java.io包中唯一代表磁盘文件本身的对象，可通过调用File类中的方法实现对文件的一系列操作。

创建文件对象方法：

（1）File(String pathname)
（2）File(String parent,String child)
（3）File(File f,String child)

createNewFile(): 若文件存在，则返回false;若不存在，则返回true并新建该文件。

import java.io.File;

public class WenJian {
    public static void main(String[] args) {
        File F=new File("Word.txt");
        if(F.exists())
        {
            F.delete();
            System.out.println("文件已删除");
        }
        else
        {
            try{
                F.createNewFile();
                System.out.println("文件已创建");
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

FileInputStream类与FileOutputStream类

基本内容： InputStream类和OutputStream类为字节流，提供了基本的文件写入能力。

import java.io.*;

public class XieWenJian {
    public static void main(String[] args) throws IOException {
        File F = new File("Word.txt");
        F.createNewFile();
        FileOutputStream out = new FileOutputStream(F);
        byte buy[] = "Hello,TS!".getBytes();
        out.write(buy);
        out.close();
        FileInputStream in = new FileInputStream(F);
        byte sell[] = new byte[1024];
        int len = in.read(sell);
        System.out.println("文件中的信息是:" + new String(sell, 0, len));
        in.close();
    }
}

FileReader类与FileWriter类

基本内容： Reader类和Writer类为字符流，FileInputStream类与FileOutputStream类只提供了对字节或字节数组的读取方法。由于汉字在文件中占用两个字节，使用字节流可能会出现乱码情况，采用字符流可避免此乱码现象。

import java.io.*;

public class ZuoWenJian {
    public static void main(String[] args) throws IOException {
        File F=new File("HONOR.txt");
        F.createNewFile();
        FileReader in=new FileReader(F);
        FileWriter out=new FileWriter(F);
        String A="Hello,TS!";
        out.write(A);
        out.close();
        char[] C=new char[1024];
        in.read(C);
        in.close();
        System.out.println(new String(C));
    }
}

缓存输入/输出流

基本内容：　缓存是I/O流的一种性能优化，为I/O流增加了缓存区，提高了读取效率。

BufferedInputStream类与BufferedOutputStream类：

import java.io.*;

public class GaoWenJian {
    public static void main(String[] args) throws IOException {
        File F = new File("Word.txt");
        F.createNewFile();
        FileOutputStream out = new FileOutputStream(F);
        BufferedOutputStream OUT=new BufferedOutputStream(out);
        byte buy[] = "Hello,TS!".getBytes();
        OUT.write(buy);
        OUT.close();
        FileInputStream in = new FileInputStream(F);
        BufferedInputStream IN=new BufferedInputStream(in);
        byte sell[] = new byte[1024];
        int len = IN.read(sell);
        System.out.println(new String(sell, 0, len));
        in.close();
    }
}

BufferedReader类与BufferedWriter类：

import java.io.*;

public class NongWenJian {
    public static void main(String[] args) throws IOException {
        File F=new File("HONOR.txt");
        F.createNewFile();
        FileReader in=new FileReader(F);
        FileWriter out=new FileWriter(F);
        BufferedWriter OUT=new BufferedWriter(out);
        BufferedReader IN=new BufferedReader(in);
        String A="Hello,TS!";
        OUT.write(A);
        OUT.close();
        char[] C=new char[1024];
        IN.read(C);
        IN.close();
        System.out.println(new String(C));
    }
}

数据输入/输出流

基本内容：数据输入输出流是基本输入输出字节流的子类， DataInputStream类和DataOutputStream类允许应用程序以与机器无关的方式从底层输入流中读取基本Java类型。（也就是说，当读取一个数据时不必再关心这个数值是哪种字节）

DataOutputStream类提供了三种写入字符串的方法：

Java中的字符是Unicode编码，为双字节

(1)writeBytes(String s):　将字符串中的每一个字符的低字节内容写入目标设备中

(2)writeChars(String s):　将字符串中的每一个字符的两个字节的内容都写到目标设备中

(3)writeUTF(String s):　将字符串按照UTF编码后的字节长度写入设备，然后才是每一个字节的UTF编码

import java.io.*;

public class ShuWenJian {
    public static void main(String[] args) throws IOException {
        File F=new File("HONOR.txt");
        F.createNewFile();
        FileOutputStream FO=new FileOutputStream(F);
        DataOutputStream DO=new DataOutputStream(FO);
        FileInputStream FI=new FileInputStream(F);
        DataInputStream DI=new DataInputStream(FI);
        DO.writeUTF("writeUTF()方法写入数据");
        DO.writeChars("writeChars()方法写入数据");
        DO.writeBytes("writeBytes()方法写入数据");
        System.out.println(DI.readUTF());
        DO.close();
    }
}

ZIP压缩输入/输出流

ZIP压缩管理文件（ZIP　ａｒｃｈｉｖｅ）是一种十分典型的文件压缩形式，使用它可以节省存储空间。ZIP压缩的I／Ｏ实现，在Java的内置类中提供了实用的相关类。

压缩文件：

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

public class MyZip {
    private void zip(String zipFileName, File inputFile)throws Exception{
        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 IOException {
        if(f.isDirectory())
        {
            File[] fl=f.listFiles();
            if(base.length()!=0)
            {
                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)
            {
                out.write(b);
            }
            in.close();
        }
    }
    public static void main(String[] temp) throws Exception {
        MyZip book=new MyZip();
        book.zip("D:/Hello,TS!.zip",new File("D:/Hello,TS!"));
        System.out.println("压缩完成");
    }
}

解压缩ZIP文件

import jdk.internal.util.xml.impl.Input;

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

public class Decompressing {
    public static void main(String[] temp) throws IOException {
        File file=new File("D:/Hello,TS!.zip");
        ZipInputStream zin;
        ZipFile zipFile=new ZipFile(file);
        zin=new ZipInputStream(new FileInputStream(file));
        ZipEntry entry=zin.getNextEntry();
        while(((entry=zin.getNextEntry())!=null)&&!entry.isDirectory()){
            File tmp=new File(entry.getName());
            if(!tmp.exists())
            {
                tmp.getParentFile().mkdirs();
                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();
            }
            zin.closeEntry();
            System.out.println(entry.getName()+"解压成功");
        }
        zin.close();
    }
}

Jａｖａ实现了I／Ｏ数据流与网络数据流的单一接口。