文件的压缩与解压(java实现)

压缩与解压文件

题目要求

实现一个基于哈夫曼树的文件压缩程序和文件解压程序。

基本要求：

(1) 要求压缩程序读入源文件，分析每种字符的频度，然后建立相应的哈夫曼树，再求出相应哈夫曼编码，根据编码对源文件进行压缩，得到源文件对应的压缩文件。

(2) 解压程序读入压缩文件，根据相应的哈夫曼编码解压还原，得到对应的源文件。

(3) 求出压缩率；

需求分析

1) 创建一个文件输入流，并把它和指定目录下的文件建立联系。

2) 判断有多少个字节可以读取，并创建一个字节数组，再将每个字节的个数进行统计存入map集合，将其作为创建哈夫曼树的权重值。

3) 遍历map集合，用字节和个数逐个创建Node节点，并将Node节点存入一个list里面。

4) 遍历list集合创建哈夫曼树，返回哈夫曼树的根节点。

5) 利用根节点递归遍历获取每个字节的哈夫曼编码，再将哈夫曼编码转为十进制数存到一个字节数组之中。

6) 创建一个对象输出流（ObjectOutputStream）和文件输出流，用文件输出流与指定目录下的zip文件建立联系，再用对象输出流将上面求出来的字节数组和map集合输出到文件输出流方便之后用对象读入流来读取（重构）对象。

7) 利用对象读入流（ObjectInputStream）取出之前存入的对象，即：字节数组和map集合。

8) 利用byteToBitString函数将字节数组中的十进制数转为二进制即哈夫曼编码。

9) 将所有字节的哈夫曼编码拼接在一起存入一个字符串中，从第一位开始逐位读取，并判断map集合中是否有对应的字节，如果有将其存入一个list集合中。

10) 所有字节读取完毕之后，将list转存在一个字节数组中并返回。用文件输出流将其写入文件。

思路分析

题目的要求基于哈夫曼树的原理，那么首先要做的就是创建一个哈夫曼树，从而求出对应字节的哈夫曼编码。在此之前要统计出文件里面有多少个字节可以读取，相同字节的个数有多少，将其作为创建哈夫曼树时候的权重值，这样遍历哈夫曼树就可以得到整个文件的哈夫曼编码，然后每8个一位求出对应的10进制数将其存入一个字节数组之中。这时候我们得到一个map和一个字节数组zip。map之中存放的是键值对，键就是不同的字节，值便是字节对应的哈夫曼编码。字节数组中存放的是哈夫曼编码的10进制表示方式。将其存入对象字节流

ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。可以使用 ObjectInputStream 读取（重构）对象。通过在流中使用文件可以实现对象的持久存储。如果流是网络套接字流，则可以在另一台主机上或另一个进程中重构对象。

代码实现

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.nio.channels.FileChannel;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class HumanCodeTest
{

    public static void main(String[] args)
    {
        String srcFile="e://code//123.txt";//要压缩的文件
        String dstFile="e://code//123.zip";//压缩后的文件
        zipFile(srcFile, dstFile);//压缩文件
        unZipFile(dstFile,"e://code//unzip.txt");//对刚才的文件进行解压，解压后的文件名称叫做unzip.txt
    }

    public static void unZipFile(String zipFile,String dstFile)
    {
        InputStream inputStream=null;
        ObjectInputStream objectInputStream=null;
        OutputStream outputStream=null;
        try
        {
            inputStream=new FileInputStream(zipFile);  //将压缩文件读入
            objectInputStream=new ObjectInputStream(inputStream);  //对象操作流，讲一个对象读入
            byte [] array= (byte [])objectInputStream.readObject();   //把每个字节的哈夫曼编码的对应十进制数读入
            Map<Byte,String> map=(Map<Byte,String>)objectInputStream.readObject();// 把每个字节对应的哈夫曼编码读入
            byte[] decode = decode(map, array);
            outputStream=new FileOutputStream(dstFile);
            outputStream.write(decode);
            System.out.println("解压文件成功！");
        } catch (Exception e)
        {
            System.out.println(e);
        }finally
        {
            try {
                outputStream.close();
                objectInputStream.close();
                inputStream.close();

            } catch (Exception e2) {
                System.out.println(e2);
            }

        }


    }

    public static void zipFile(String srcFile,String dstFile)
    {
        FileInputStream inputStream=null;
        OutputStream outputStream=null;
        ObjectOutputStream objectOutputStream=null;
        FileInputStream zipfile = null;
        FileChannel fs=null;
        FileChannel zip=null;
        try
        {
            inputStream=new FileInputStream(srcFile);
            byte [] b=new byte[inputStream.available()];  //获取文件的所有字节，这个方法可以在读写操作前先得知数据流里有多少个字节可以读取
            fs = inputStream.getChannel();
            inputStream.read(b);
            byte[] huffmanZip = huffmanZip(b);
            outputStream=new FileOutputStream(dstFile);
            objectOutputStream=new ObjectOutputStream(outputStream);  //对象操作流：该流可以将一个对象写出，或者读取一个对象到程序中，也就是执行了序列化和反序列化操作。
            objectOutputStream.writeObject(huffmanZip);
            objectOutputStream.writeObject(map);

            zipfile = new FileInputStream(dstFile);
            zip = zipfile.getChannel();
            NumberFormat numberFormat = NumberFormat.getInstance();
            numberFormat.setMaximumFractionDigits(2);
            String result = numberFormat.format((float)zip.size()/(float)fs.size()*100);
            System.out.println("压缩率:"+result+"%");
            System.out.println("压缩成功！");
        } catch (Exception e)
        {
            System.out.println(e);
        }
        finally
        {
            if(inputStream!=null)
            {
                try
                {
                    objectOutputStream.close();
                    outputStream.close();
                    inputStream.close();//释放资源
                    zipfile.close();

                } catch (Exception e2)
                {
                    System.out.println(e2);
                }

            }
        }
    }

    private static byte[] decode(Map<Byte, String> map,byte [] array)
    {
        StringBuilder stringBuilder = new StringBuilder();
        for(int i=0;i<array.length;i++)
        {
            boolean flag=(i==array.length-1);
            stringBuilder.append(byteToBitString(!flag, array[i])); //文件内容的二进制编码
        }

        Map<String, Byte> map2=new HashMap<String, Byte>();//反向编码表
        Set<Byte> keySet = map.keySet();
        for(Byte b:keySet)
        {
            String value=map.get(b);
            map2.put(value, b);
        }


        List<Byte> list=new ArrayList<Byte>();
        for (int i = 0; i < stringBuilder.length();)
        {
            int count=1;
            boolean flag=true;
            Byte byte1=null;
            while (flag)
            {
                String substring = stringBuilder.substring(i, i+count);
                byte1 = map2.get(substring);
                if(byte1==null)
                {
                    count++;
                }
                else
                {
                    flag=false;
                }

            }
            list.add(byte1);
            i+=count;
        }

        byte [] by=new byte[list.size()];
        for(int i=0;i<by.length;i++)
        {
            by[i]=list.get(i);
        }
        return by;
    }

    private static String byteToBitString(boolean flag, byte b)
    {
        int temp=b;
        if(flag)
        {
            temp|=256;  //与256做位运算  256的二进制形式为 11111111
        }

        String binaryString = Integer.toBinaryString(temp);//他的作用是把一个10进制数转为32位的2进制数。同时对负数，会用补码表示。
        if(flag)
        {
            return binaryString.substring(binaryString.length()-8);
        }
        else
        {
            return binaryString;
        }

    }

    private static byte[] huffmanZip(byte [] array)   //整个文件的字节数组
    {
        List<Node> nodes = getNodes(array);  //获取节点，内容是字节及其对应的个数
        Node createHuffManTree = createHuffManTree(nodes); //利用获取的节点创建一个哈夫曼树
        Map<Byte, String> m=getCodes(createHuffManTree);  //把哈夫曼的根节点传入，获取存放每个字节（key）和它对应的哈夫曼编码（value）
        byte[] zip = zip(array, m);
        return zip;
    }

    //
    private static byte[] zip(byte [] array,Map<Byte,String> map) // 压缩，将每一个字符的哈夫曼编码变为十进制数
    {
        StringBuilder sBuilder=new StringBuilder();  //整个文件的哈夫曼编码
        for(byte item:array)  //遍历整个文件的字节数组，并且将其哈夫曼编码拼接成字符串
        {
            String value=map.get(item);
            sBuilder.append(value);
        }
        //System.out.println(sBuilder);
        int len;
        if(sBuilder.toString().length()%8==0)//如果可以整除，
        {
            len=sBuilder.toString().length()/8;
        }
        else //如果不能整除
        {
            len=sBuilder.toString().length()/8+1;
        }

        byte [] by=new byte[len];
        int index=0;
        for(int i=0;i<sBuilder.length();i+=8)//
        {
            String string;
            if((i+8)>sBuilder.length())
            {
                string=sBuilder.substring(i);
            }
            else
            {
                string=sBuilder.substring(i, i+8);
            }

            by[index]=(byte)Integer.parseInt(string,2); //输出2进制数string在十进制下的数.
            index++;
        }


        return by;

    }


    //重载
    private static Map<Byte, String> getCodes(Node root)
    {
        if(root==null)
        {
            return null;
        }
        getCodes(root.leftNode,"0",sBuilder);
        getCodes(root.rightNode,"1",sBuilder);
        return map;
    }



    //获取哈夫曼编码
    static Map<Byte, String> map=new HashMap<>();  //创建一个map集合，存放每个字节（key）和它对应的哈夫曼编码（value）
    static StringBuilder sBuilder=new StringBuilder();
    public static void getCodes(Node node,String code,StringBuilder stringBuilder)
    {
        StringBuilder stringBuilder2=new StringBuilder(stringBuilder);
        stringBuilder2.append(code);
        if(node!=null)
        {
            if(node.data==null)//非叶子结点
            {
                //向左递归
                getCodes(node.leftNode,"0",stringBuilder2);
                //向右递归
                getCodes(node.rightNode,"1",stringBuilder2);
            }
            else //如果是叶子结点
            {
                map.put(node.data,stringBuilder2.toString());
            }
        }
    }



    public static List<Node> getNodes(byte [] array)
    {
        List<Node> list=new ArrayList<Node>();
        Map<Byte, Integer> map=new HashMap<Byte, Integer>();
        for(Byte data:array)  //遍历字节数组，目的为了统计相同字节的个数
        {
            Integer count=map.get(data);//通过键获取值
            if(count==null)//说明此时map集合中还没有此字符
            {
                map.put(data, 1);
            }
            else
            {
                map.put(data,count+1);
            }
        }
        //遍历map集合
        Set<Byte> set=map.keySet();   //吧map中所有的key取出来，放到set集合中，方便一会儿构造节点
        for(Byte key:set)  //遍历set集合获取对应字节的个数，并创建一个node对象，并且把它放到list里面
        {
            int value=map.get(key);
            Node node=new Node(key, value);
            list.add(node);
        }
        return list;
    }

    private static Node createHuffManTree(List<Node> list)
    {
        while(list.size()>1)
        {
            Collections.sort(list);//先对集合进行排序，排序关键字是value即字节的个数
            Node leftNode=list.get(0);
            Node rightNode=list.get(1);

            Node parentNode=new Node(null, leftNode.weight+rightNode.weight);
            parentNode.leftNode=leftNode;
            parentNode.rightNode=rightNode;

            list.remove(leftNode);
            list.remove(rightNode);

            list.add(parentNode);
        }
        return list.get(0);  //返回哈夫曼树的根。

    }

}

class Node implements Comparable<Node>
{
    Byte data;//字符
    int weight;//字符出现的次数
    Node leftNode;
    Node rightNode;

    public Node(Byte data,int weight)//构造器
    {
        this.data=data;
        this.weight=weight;
    }

    @Override
    public int compareTo(Node o)
    {
        return this.weight-o.weight;
    }

    @Override
    public String toString()
    {
        return "Node [data=" + data + ", weight=" + weight + "]";
    }

    //前序遍历
    public void preOrder()
    {
        System.out.println(this);
        if(this.leftNode!=null)
        {
            this.leftNode.preOrder();
        }
        if(this.rightNode!=null)
        {
            this.rightNode.preOrder();
        }
    }


}