JAVA核心技术I---JAVA基础知识（二进制文件读写和zip文件读写）

一：二进制文件读写

（一）写文件

–先创建文件，写入数据，关闭文件
–FileOutputStream, BufferedOutputStream，DataOutputStream
–DataOutputStream
　　• flush
　　• write/writeBoolean/writeByte/writeChars/writeDouble/writeInt/WriteUTF/…
–try-resource 语句，自动关闭资源
–关闭最外层的数据流，将会把其上所有的数据流关闭

    private static void WriteBinFile() {
        // TODO Auto-generated method stub
        FileOutputStream fos = null;
        BufferedOutputStream bos = null;
        DataOutputStream dos = null;

        try {
            // 节点类
            fos = new FileOutputStream("D:\\MyJava\\Code\\JH16\\test\\aa\\bb\\F.bat");
            bos = new BufferedOutputStream(fos);    //装饰类
            dos = new DataOutputStream(bos);    //装饰类

            dos.writeInt();
            dos.writeUTF("af");
            dos.writeInt();
            dos.writeInt();
            dos.writeUTF("你");
        }catch(Exception e) {
            System.err.println(e.getMessage());
        }finally {
            try {
                dos.close();     // 关闭最后一个类，会将所有的底层流都关闭
            }catch(Exception e){
                System.err.println(e.getMessage());
            }
        }
    }

（二）：读文件

–先打开文件，读入数据，关闭文件
–FileInputStream, BufferedInputStream，DataInputStream
–DataInputStream
　　• read/readBoolean/readChar/readDouble/readFloat/readInt/readUTF/…
–try-resource 语句，自动关闭资源
–关闭最外层的数据流，将会把其上所有的数据流关闭

    private static void ReadBinFile() {
        // TODO Auto-generated method stub

        try(DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream("D:\\MyJava\\Code\\JH16\\test\\aa\\bb\\F.bat")))){
            int a = dis.readInt();
            String s1 = dis.readUTF();
            int b = dis.readInt();
            int c = dis.readInt();
            String s2 = dis.readUTF();
            System.out.printf("%d %s %d %d %s",a, s1,b,c,s2);
        }catch(Exception e) {
            System.err.println(e.getMessage());
        }

    }

二：ZIP文件读写

压缩包：zip, rar, gz, ……
Java zip 包支持Zip和Gzip包的压缩和解压
zip文件操作类: java.util.zip包中
–java.io.InputStream, java.io.OutputStream的子类
–ZipInputStream, ZipOutputSream 压缩文件输入/输出流
–ZipEntry 压缩项

（一）单个/多个压缩

–打开输出zip文件
–添加一个ZipEntry
–打开一个输入文件，读数据，向ZipEntry写数据，关闭输入文件
–重复以上两个步骤，写入多个文件到zip文件中
–关闭zip文件

    public static void SingleZip() 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 =  ;
        while((temp=input.read())!=-){ // 读取内容
            zipOut.write(temp) ;    // 压缩输出
        }
        input.close() ; // 关闭输入流
        zipOut.close() ;    // 关闭输出流  

        System.out.println("single file zip done.");
    }  

    public static void MultipleFileZip(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 =  ;
        if(file.isDirectory()){    // 判断是否是文件夹
            File lists[] = file.listFiles() ;    // 列出全部子文件
            for(int i=;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())!=-){    // 读取内容
                    zipOut.write(temp) ;    // 压缩输出
                }
                input.close() ;    // 关闭输入流
            }
        }
        zipOut.close() ;    // 关闭输出流
        System.out.println("multiple file zip done.");
    }

（二）单个/多个文件解压

–打开输入的zip文件
–获取下一个ZipEntry
–新建一个目标文件，从ZipEntry读取数据，向目标文件写入数据，
关闭目标文件
–重复以上两个步骤，从zip包中读取数据到多个目标文件
–关闭zip文件

    public static void SingleFileUnzip(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 =  ;
        while((temp=input.read())!=-){
            out.write(temp) ;
        }
        input.close() ;     // 关闭输入流
        out.close() ;   // 关闭输出流
        System.out.println("unzip done.") ;
    }  

    public static void MultipleFileUnzip(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 ;    // 定义压缩输入流  

        //定义解压的文件名
        OutputStream out = null ;   // 定义输出流，用于输出每一个实体内容
        InputStream input = null ;  // 定义输入流，读取每一个ZipEntry
        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 =  ;
                while((temp=input.read())!=-){
                    out.write(temp) ;
                }
                input.close() ;     // 关闭输入流
                out.close() ;   // 关闭输出流
            }

        }
        input.close() ;
    }  

三：练习

读取以下的a.txt，统计相同单词的次数，最后按照次数的大小降序排列，输出到b.txt中。

a.txt (===算分隔符，不算单词，不考虑单词大小写)

==============

hello world

hello

java world   hello

==============

b.txt

============

hello,

world,

java,

============

提示：需要用到的内容有文本文件读和写操作。还要加上数据结构，有ArrayList, HashMap,Comparable等。

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

class MyComparator implements Comparator<Map.Entry<String,Integer>>{
    public int compare(HashMap.Entry<String,Integer> he1,HashMap.Entry<String,Integer> he2) {
        return he2.getValue()-he1.getValue();
    }
}

public class homework {
    static final int MAX = ;

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        HashMap<String, Integer> hm = new HashMap<String,Integer>();

        //文件读取
        try(BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("D:\\MyJava\\Code\\JH17\\a.txt")))){
            String line;
            while((line = br.readLine())!=null) {
                Pattern p = Pattern.compile("\\s+");　　//正则匹配空格
                String words[]= p.split(line);　　//获取的字符串进行分割单词

                for(String item : words) {　　
                    if(item.length()!=) {
                        if(hm.get(item)==null)
                            hm.put(item, );　　//将数据放入map中
                        else
                            hm.put(item, hm.get(item)+);
                    }
                }
            }
        }catch(Exception e) {
            System.err.println(e.getMessage());
        }

        //HashMap转换为list，进行排序
        List<Map.Entry<String,Integer>> list = new ArrayList<Map.Entry<String,Integer>>(hm.entrySet());
        Collections.sort(list,new MyComparator());

        //将数据写入文件
        try(BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\MyJava\\Code\\JH17\\b.txt")))){
            for(Map.Entry<String, Integer> item: list) {
                bw.write(item.getKey()+","+item.getValue());
                bw.newLine();
            }
        }catch(Exception e) {
            System.err.println(e.getMessage());
        }

    }

}