Java 基础知识三

Java 文件类File

java.io.File是文件和目录的重要类(IDK6及以前是唯目录也使用File类进行表示
File类与OS无关，但会受到OS的权限限制
常用方法
createNewFile,delete,exists, getAbsolutePath, getName,getParent,getPath, isDirectory, isFile, length, listFiles, mkdir, mkdirs

import java.io.*;

public class FileAttributeTest {
    public static void main(String[] args) {//创建目录
        File d = new File("c:/temp");
        if (!d.exists()) {
            d.mkdirs();//mkdir 创建单级目录 mkdirs 连续创建多级目录
        }
        System.out.println("Is d directory?" + d.isDirectory());
        //创建文件
        File f = new File("c:/temp/abc.txt");
        if (!f.exists()) {
            try {
                f.createNewFile();//创建abc.txt
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        System.out.println("Is file?"+f.isFile());
        System.out.println("Name:"+f.getName());
        System.out.println("Parent:"+f.getParent());
        System.out.println("Path:"+f.getPath());
        System.out.println("size:"+f.length()+" bytes");
        System.out.println("Last modified time: "+f.lastModified()+"ms");

        //遍历d目录下所有的文件信息
        System.out.println("list files in d directory");
        File[]fs = d.listFiles(); //列出d目录下所有的子文件，不包括子目录下的文件for(File f1:fs)
        for (File f1:fs){
            System.out.println(f1.getPath());
        }
        //f.delete();//删除此文件
        // d.delete();//删除日录

    }
}

JAVA   NIO

Java7提出的NIO包，提出新的文件系统类
Path, Files, DirectoryStream, FileVisitor,FileSystem
是java.io.File的有益补充

import java.io.File;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class PathTest{
    public static void main(String[] args) {// Path和java.io.File 基本类似
        //获得path方法一,c:/temp/abc.txt
        Path path = FileSystems.getDefault().getPath("c:/temp","abc.txt");
        System.out.println(path.getNameCount());
        System.out.println("path1:"+ path);
        // 获得path方法二，用File的toPath()方法获得Path对象
        File file = new File("c:/temp/abc.txt");
        Path pathOther = file.toPath();
        System.out.println("path2:"+ pathOther);
         //0,说明这两个path是相等的
        System.out.println(path.compareTo(pathOther));
        //获得path方法三
        Path path3 = Paths.get("c:/temp", "abc.txt");
        System.out.println("path3:"+ path3.toString());

        Path path4 = Paths.get("c:/temp");
        System.out.println("path4:"+ path4.resolve("abc.txt"));
        if(Files.isReadable(path)){
            System.err.println("it is readable");
        }else {
            System.err.println("it is not readable");
        }
    }
}

Java读写文件，只能以(数据)流的形式进行读写java.io包中
-节点类:直接对文件进行读写包装类
·转化类:字节/字符/数据类型的转化类
·装饰类:装饰节点类

节点类: 直接操作文件类
-InputStream,OutputStream(字节)

FileInputStream,FileOutputStream

-Reader,Writer(字符)

FileReader, FileWriter

转换类:字符到字节之间的转化

-InputStreamReader:文件读取时字节，转化为ava能理解的字符

OutputStreamWriter:Java将字符转化为字节输入到文件中
装饰类:装饰节点类
DataInputStream,DataOutputStream:封装数据流

-BufferedInputStream,BufferOutputStream:缓存字节流

BufferedReader,BufferedWriter:缓存字符流

文本文件读写

文件类型
-一般文本文件(若千行字符构成的文件)，如txt等

-一般二进制文件，如数据文件dat

带特殊格式的文本文件，如xml等

带特殊格式二进制文件，如doc,ppt等，

文件是数据的一个容器(口袋)·

文件可以存放大量的数据。

文件很大，注定Java只能以流形式依次处理

写文件

先创建文件，写入数据，关闭文件
FileOutputStream, OutputStreamWriter, BufferedWriter
BufferWriter

• wrilte
• newline

-try-resource 语句，自动关闭资源

-关闭最外层的数据流，将会把其上所有的数据流关闭

File0utputStream 节点类，负责写字节;0utputStreamWriter 转化类，负责字符到字节转化;BufferedWriter 装饰类，负责写字符到缓存区。
三者构建关系: BufferedWriter(OutputStreamWriter(File0utputStream)))

public class TxtFileWrite {
    public static void main(String[] args) {
        writeFilel();
        System.out.println("===================");
        writeFile2();// JDK 7及以上才可以使用
    }
    
    public static void writeFilel() {
        FileOutputStream fos = null;
        OutputStreamWriter osw = null;
        BufferedWriter bw = null;
        try {
            fos = new FileOutputStream("c:/temp/abc.txt");//节点类
            osw = new OutputStreamWriter(fos, "UTF-8");//转化类//
            //osw =new outputstreamWriter(fos);//转化类
            bw = new BufferedWriter(osw);//装饰类//
            // br = new BufferedWriter(new OutputStreamWriter(new// File0utputstream("c:/temp/abc.txt")))
            bw.write("我们是");
            bw.newLine();
            bw.write("dddddd");
            bw.newLine();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                bw.close();
            } catch (Exception ex) {
                ex.printStackTrace();

            }
        }
    }

    public static void writeFile2() {
        //try-resource 语句，自动关闭资源
        try (BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("c:/temp/abc.txt")))) {
            bw.write("我们是");
            bw.newLine();
            bw.write("Ecnuers.^^");
            bw.newLine();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

读文件

-先打开文件，逐行读入数据，关闭文件

-FileInputStream, InputStreamWriter, BufferedReader

-BufferReader
   readline
try-resource语句，自动关闭资源

关闭最外层的数据流，将会把其上所有的数据流关闭

mport java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;

public class TxtFileRead {
    public static void main(String[] args) {
        readFile1();
        System.out.println("===================");
        readFile2();//JDK 7及以上才可以使用
    }

    public static void readFile1() {
        FileInputStream fis = null;
        InputStreamReader isr = null;
        BufferedReader br = null;
        try {
            fis = new FileInputStream("c:/temp/abc.txt");//节点类
            isr = new InputStreamReader(fis, "UTF-8");//转化类//
            //isr = new InputstreamReader(fis);
            br = new BufferedReader(isr);//装饰类
            // br = new BufferedReader(new InputStreamReader(new FileInputstream("c:/temp/abc.txt")))
            String line;
            while ((line = br.readLine()) != null)// 每次读取一行
            {
                System.out.println(line);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            try {
                br.close();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }

    }

    public static void readFile2() {
        String line;

        try (BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream("c:/temp/abc.txt")))) {
            while ((line = in.readLine()) != null) {
                System.out.println(line);
            }
        } catch (Exception ex) {
            ex.printStackTrace();

        }
    }
}

二进制文件读写

，二进制文件
-狭义上说，采用字节编码，非字符编码的文件

-广义上说，一切文件都是二进制文件
用记事本等无法打开/阅读

-二进制文件读写
输出数据到文件中
从文件中读取数据

写文件

-先创建文件，写入数据，关闭文件
-FileOutputStream, BufferedOutputStream, DataOutputStream

-DataOutputStream
flush
write/writeBoolean/writeByte/writeChars/writeDouble/writeInt/WriteU'TF/...

try-resource语句，自动关闭资源

关闭最外层的数据流，将会把其上所有的数据流关闭

import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;

public class BinFileWrite {
    public static void main(String[] args) throws Exception {
        writeFile();
        System.out.println("done.");
    }

    public static void writeFile() {
        FileOutputStream fos = null;
        DataOutputStream dos = null;
        BufferedOutputStream bos = null;
        try {
            fos = new FileOutputStream("c:/temp/def.dat");//节点类
            bos = new BufferedOutputStream(fos);//装饰类
            dos = new DataOutputStream(bos);//装饰类

            dos.writeUTF("a");
            dos.writeInt(20);
            dos.writeInt(180);
            dos.writeUTF("b");
        } catch (Exception ex) {
            ex.printStackTrace();
        }finally {
            try{
                dos.close();
            }catch (Exception ex){
                ex.printStackTrace();
            }
        }
    }
}

File0utputStream 节点类，负责写字节:

Buffered0utputStream 装饰类,负责写字节数据到缓冲区;

Data0utputStreamWriter 转化类负责数据类型到字节转化。

三者构建关系:Data0utputStreamWriter(BufferedOutputStream(File0utputStream))

读文件

-先打开文件，读入数据，关闭文件
-FileInputStream, BufferedInputStream, DatalnputStream

DataInputStream
read/readBoolean/readChar/readDouble/readFloat/readInt/readUTF/...

try-resource语句，自动关闭资源

关闭最外层的数据流，将会把其上所有的数据流关闭

FilelnputStream 节点类，负责读字节;

BufferedlnputStream 装饰类,负责读字节数据到缓冲区;

DatalnputStreamWriter 转化类:负责字节到数据类型转化。

三者构建关系:DatalnputStreamWriter(BufferedInputStream(FilelnputStream))

import java.io.*;

public class BinFileRead {
    public static void main(String[] args) {
        try {
            readFile();
        } catch (Exception ex) {
            ex.printStackTrace(); // 打印异常堆栈跟踪，便于调试
        }
    }

    public static void readFile() throws IOException {
        // try-resource 自动关闭资源
        try (DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream("c:/temp/def.dat")))) {
            String a, b;
            int c, d;
            a = dis.readUTF();
            c = dis.readInt();
            d = dis.readInt();
            b = dis.readUTF();
            System.out.println("a: " + a);
            System.out.println("c: " + c);
            System.out.println("d: " + d);
            System.out.println("b: " + b);
        } catch (EOFException e) {
            // 处理文件结束异常，可能在尝试读取不存在的UTF字符串时抛出
            System.err.println("Reached end of file before reading all data.");
        } catch (IOException e) {
            // 处理其他IO异常
            System.err.println("IO Exception occurred: " + e.getMessage());
        }
    }
}

zip文件读写

压缩包:zip,rar,gz
·Javazip 包支持Zip和Gzip包的压缩和解压·

zip文件操作类: java.util.zip包中
-java.io.InputStream,java.io.OutputStream的子类

-ZipInputStream,ZipOutputSream 压缩文件输入/输出流

-ZipEntry 压缩项

压缩

单个/多个压缩
-打开输出zip文件
-添加一个ZipEntry
-打开一个输入文件，读数据，向ZipEntry写数据，关闭输入文件

-重复以上两个步骤，写入多个文件到zip文件中
关闭zip文件

package org.example;

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

public class SingleFileZip {
    public static void main(String[] args) throws Exception {
        File file = new File("c:/temp/abc.txt"); // 定义要压缩的文件
        File zipFile = new File("c:/temp/single2.zip"); // 定义压缩文件名称

        InputStream input = new FileInputStream(file);// 定义文件的输入流
        ZipOutputStream zipOut = null;//声明压缩流对象
        zipOut = new ZipOutputStream(new FileOutputStream(zipFile));
        zipOut.putNextEntry(new ZipEntry(file.getName()));//设置ZipEntry对象
        zipOut.setComment("single file zip");//设置注释

        //压缩过程
        int temp = 0;
        while ((temp = input.read()) != -1) {//读取内容
            zipOut.write(temp);
        }
        input.close();
        zipOut.close();
        System.out.println("single file zip out!");
    }
}

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

public class MultipleFileZip {
    public static void main(String args[]) throws Exception {//所有异常抛出
        File file = new File("c:/temp/multiple"); // 定义要压缩的文件夹
        File zipFile = new File("c:/temp/multiple2.zip"); //定义压缩文件名称
        InputStream input = null;//定义文件输入流
        ZipOutputStream zipOut = null;//声明压缩流对象
        zipOut = new ZipOutputStream(new FileOutputStream(zipFile));
        zipOut.setComment("multiple file zip");//设置注释
        //开始压缩
        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对象
                System.out.println("正在压缩" + lists[i].getName());
                while ((temp = input.read()) != -1) {//读取内容
                    zipOut.write(temp);//关闭输出流
                }
                input.close();
            }
        }
        zipOut.close();
        System.out.println("multiple file zip done");
    }
}

解压

单个/多个解压
打开输入的zip文件
获取下一个ZipEntry
新建一个目标文件，从ZipEntry读取数据，向目标文件写入数

关闭目标文件
重复以上两个步骤，从zip包中读取数据到多个目标文件

关闭zip文件

package org.example;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

import static java.lang.System.out;

public class SingleFileUnzip {

    public static void main(String args[]) throws Exception {
        //待解压文件，需要从zip文件打开输入流，读取数据到java中
        File zipFile = new File("c:/temp/single.zip"); // 定义压缩文件名称
        ZipInputStream input = null;//定义压缩输入流
        input = new ZipInputStream(new FileInputStream(zipFile)); //实例化 ZipInputStream
        ZipEntry entry = input.getNextEntry();//得到一个压缩实体
        System.out.println("压缩实体名称:" + entry.getName()); //获取压缩包中文件名字
        //新建目标文件，需要从目标文件        打开输出流，数据从java流入
        File outFile = new File("c:/temp/" + entry.getName());
        OutputStream out = new FileOutputStream(outFile); //实例化文件输出流
        int temp = 0;
        while ((temp = input.read()) != -1) {
            out.write(temp);
        }
        input.close();// 关闭输入流
        out.close();//关闭输出流
        System.out.println("unzip done.");
    }
}

package org.example;

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

public class MultipleFileUnzip {
    public static void main(String args[]) throws Exception {
        //待解压的zip文件，需要在zip文件上构建输入流，读取数据到Java中
        File file = new File("c:/temp/multiple.zip"); // 定义压缩文件名称//输出文件的时候要有文件夹的操作
        File outFile = null;
        ZipFile zipFile = new ZipFile(file);//实例化zipFile对象
        ZipInputStream zipInput = null;//定义压缩输入流

        //定义解压的文件名/定义输出流，用于输出每一个实体内容O
        OutputStream out = null;
        //定义输入流，读取每一实体内容  ZipEntry
        InputStream input = null;
        ZipEntry entry = null;// 每一个压缩实体
        zipInput = new ZipInputStream(new FileInputStream(file));//实例化ZIpInputstream
        //遍历压缩包中的文件
        while ((entry = zipInput.getNextEntry()) != null) {// 得到一个压缩实体
            System.out.println("解压缩" + entry.getName() + "文件");//定义输出的文件路径
            outFile = new File("c:/temp/" + entry.getName());
            if (!outFile.getParentFile().exists()) { // 如果输出文件夹不存在
                outFile.getParentFile().mkdirs();
                // 创建文件夹,如果这里的有多级文件夹不存在,请使用mkdirs()
                //如果只是单纯的一级文件夹 使用mkdir() 就好了
            }
            if (!outFile.exists()) {//判断输出文件是否存在
                if (entry.isDirectory()) {
                    outFile.mkdirs();
                    System.out.println("create directory...");
                } else {
                    outFile.createNewFile();//创建文件
                    System.out.println("create file...");
                }
                if (!entry.isDirectory()) {
                    input = zipFile.getInputStream(entry);//得到每一个实体的输入流
                    out = new FileOutputStream(outFile);//实例化文件输出流
                    int temp = 0;
                    while ((temp = input.read()) != -1) {
                        out.write(temp);
                    }
                    //关闭输入流
                    input.close();
                    out.close();
                }
            }
            input.close();
        }
    }
}