자바 하프 만 파일 압축 풀기

본 논문 의 사례 는 자바 가 하 프 만 파일 의 압축 을 푸 는 구체 적 인 코드 를 공유 하여 여러분 께 참고 하 시기 바 랍 니 다.구체 적 인 내용 은 다음 과 같 습 니 다.
1.하 프 만 압축 은 이미 압축 처 리 된 파일 에 대한 압축 률 이 비교적 낮다.예 를 들 어 ppt 와 영상 이다.
2.이 프로그램 은 주로 집합,나무,IO 관련 지식 과 관련된다.
문자 의 통 계 는 맵 집합 으로 통계 할 수 있다.
하프 만 나무의 구축 과정 도 복잡 하지 않다.
① 나무의 집합 을 뿌리 노드 크기 에 따라 정렬
② 뿌리 노드 수치 가 가장 작은 두 그루 의 나 무 를 꺼 내 두 구조 로 새로운 나 무 를 만든다.
③ 집합 에서 이전 두 노드 의 가장 작은 수 를 삭제 합 니 다.
④ 새로 생 성 된 나 무 를 집합 에 넣는다
집합 크기 가 1 이 될 때 까지 위의 과정 을 반복 합 니 다.
파일 을 쓰 고 읽 을 때 대상 흐름 Object 흐름 을 사용 하 십시오.
3.프로그램 은 문 자 를 압축 할 수도 있 고 파일 을 압축 할 수도 있 습 니 다.코드 의 주 함수 에 서 는 파일 압축 을 푸 는 방법 만 호출 되 었 을 뿐 문자 압축 을 풀 려 면 해당 하 는 방법 을 호출 할 수 있 습 니 다.
4.코드 는 다음 과 같 습 니 다.

package huffmancode;

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.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class HuffManCode 
{

 public static void main(String[] args) 
 {
  String srcFile="d://mydata.txt";//      
  String dstFile="d://mydata.zip";//      
  zipFile(srcFile, dstFile);//    
  System.out.println("    ！");
  
  unZipFile(dstFile,"d://unzip.txt");//          ，          unzip.txt
  System.out.println("      ！");  
 }
 
 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);
  } 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;
  
  try 
  {
   inputStream=new FileInputStream(srcFile);
   byte [] b=new byte[inputStream.available()];
   inputStream.read(b);
   byte[] huffmanZip = huffmanZip(b);
   outputStream=new FileOutputStream(dstFile);
   objectOutputStream=new ObjectOutputStream(outputStream);
   objectOutputStream.writeObject(huffmanZip);
   objectOutputStream.writeObject(map);
  } catch (Exception e)
  {
   System.out.println(e);
  }
  finally 
  {
   if(inputStream!=null)
   {
    try 
    {
     objectOutputStream.close();
     outputStream.close();
     inputStream.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;
  }
  
  String binaryString = Integer.toBinaryString(temp);
  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);
  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);
   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<>();
  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();
  for(Byte key:set)
  {
   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);//        
   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();
  }
 }
 
 
}

이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.