带有界面的霍夫曼编码压缩文件的java程序

package com.example.huffman;

import java.io.File;

public class huffmanInterface {

private JFrame frame;

/**
* Launch the application.
*/
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
huffmanInterface window = new huffmanInterface();
window.frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* Create the application.
*
* @throws IOException
*/
public huffmanInterface() throws IOException {
initialize();
}

/**
* Initialize the contents of the frame.
*
* @throws IOException
*/
private void initialize() throws IOException {

frame = new JFrame();
frame.setBounds(100, 100, 665, 588);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.getContentPane().setLayout(null);
final JTextArea jt = new JTextArea();
jt.setBounds(103, 44, 321, 24);
frame.getContentPane().add(jt);
JButton btnNewButton = new JButton("open file");
btnNewButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
JFileChooser jChooser = new JFileChooser();
// 设置打开文件类型,此处设置成只能选择文件夹，不能选择文件
jChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);// 只能打开文件夹
// 打开一个对话框
int index = jChooser.showDialog(null, "打开文件");
if (index == JFileChooser.APPROVE_OPTION) {
// 把获取到的文件的绝对路径显示在文本编辑框中
jt.setText(jChooser.getSelectedFile().getAbsolutePath());
}

}
});
btnNewButton.setBounds(103, 11, 93, 23);
frame.getContentPane().add(btnNewButton);
JLabel lblFileLocation = new JLabel("file location");
lblFileLocation.setBounds(10, 48, 83, 15);
frame.getContentPane().add(lblFileLocation);

JLabel lblNewLabel = new JLabel("rate");
lblNewLabel.setBounds(10, 193, 66, 15);
frame.getContentPane().add(lblNewLabel);

final JTextArea textArea_1 = new JTextArea();
textArea_1.setBounds(103, 189, 321, 24);
frame.getContentPane().add(textArea_1);

final JTextArea textArea = new JTextArea();
textArea.setBounds(42, 289, 560, 251);
frame.getContentPane().add(textArea);
textArea.setLineWrap(true);

JButton btnCompress = new JButton("Compress");
btnCompress.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
Huffman h = new Huffman();
try {
h.huffmanCompress(h, jt.getText(), "");
textArea_1.setText(String.valueOf(h.rate));
textArea.setText(h.encodeSheet.toString());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
btnCompress.setBounds(103, 121, 93, 23);
frame.getContentPane().add(btnCompress);

JLabel label = new JLabel("huffman \nencode sheet");
label.setBounds(10, 231, 140, 48);
frame.getContentPane().add(label);

}
}

/**
* 本类是将输入的文本文件生成霍夫曼编码，并将根据此编码的压缩的文件存放成源文件+。compress,然后根据此文件和霍夫曼编码将压缩的文件解压缩，
* 并存储为源文件+。copy
*
* @author zhuwei
*
*/
class Huffman {
// 存储霍夫曼编码
Map<String, String> encodeSheet = new HashMap<String, String>();
// 存储压缩率
float rate = -1;

// 读文件，并返回文件内容
String textInput(String filename, int[] size) {
try {
FileInputStream fis = new FileInputStream(new File(filename));
byte[] buff = new byte[fis.available()];
// 存储两次读文件的该文件的大小
if (size[0] == -1) {
size[0] = fis.available();
} else if (size[1] == -1) {
size[1] = fis.available();
}
fis.read(buff);
fis.close();
System.out.println(new String(buff));
return new String(buff);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}

// 分析文件，并返回每个字符的频率
ArrayList<Node> analyzeString(String str) {
// 保存每个字符频率的列表
ArrayList<Node> list = new ArrayList<Node>();
// 暂存字符频率的map
Map<Character, Integer> map = new HashMap<Character, Integer>();
for (int i = 0; i < str.length(); i++) {
if (!map.containsKey(str.charAt(i))) {
map.put(str.charAt(i), 1);
} else {
map.put(str.charAt(i), map.get(str.charAt(i)) + 1);
}
}
Set<Entry<Character, Integer>> entryset = map.entrySet();
Iterator<Entry<Character, Integer>> iter = entryset.iterator();
// 由map转化成list<Node>
while (iter.hasNext()) {
Entry<Character, Integer> entry = iter.next();
Node node = new Node(null, null, String.valueOf(entry.getKey()),
entry.getValue());
list.add(node);
}
return list;

}

// 将输入的文本根据encodesheet编码，并存放至文件中,文件名为源文件+。compress
void encode(String text, String storefile) throws IOException {
char[] chars = text.toCharArray();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < chars.length; i++) {
Character tempChar = chars[i];
sb.append(encodeSheet.get(tempChar.toString()));
}
String str = sb.toString();
sb = new StringBuilder();
String sub;
int len = 0;
for (int i = 0; i < str.length(); i = i + 7) {
sub = new String();
// 最后一组比特位，要保存它的长度，在最末尾
if ((i + 7) >= str.length()) {
len = str.length() - i;
sub = str.substring(i, str.length());
} else {
sub = str.substring(i, i + 7);
}
sb.append((char) (int) Integer.valueOf(sub, 2));

}
FileOutputStream fos = new FileOutputStream(new File(storefile));
fos.write(sb.toString().getBytes());
// 将最后一组比特位长度存在文件末尾
fos.write(len + 48);
fos.close();
}

// 将读取的文件内容解析成二进制串
String decode(String str) {
char[] tempchars = str.toCharArray();
StringBuilder sb = new StringBuilder();
int len = tempchars[tempchars.length - 1] - 48;
System.out.println(len);
for (int i = 0; i < tempchars.length - 1; i++) {
String temp = Integer.toBinaryString(tempchars[i]);
if (i == tempchars.length - 2) {
while (temp.length() < len) {
temp = "0" + temp;
}
sb.append(temp);
} else {
while (temp.length() < 7) {
temp = "0" + temp;
}
sb.append(temp);
}
}

return sb.toString();
}

// 根据encodesheet将解码后的二进制串解码成原文件,文件名为源文件名+。copy
void decodeErgodic(String str, Node node, String filename)
throws IOException {
Node root = node;
Node temp = node;
StringBuilder sb = new StringBuilder();
char[] tempchars2 = str.toCharArray();
int i = 0;
for (; i < tempchars2.length; i++) {
char c = tempchars2[i];
if (c == '1') {
temp = temp.r;
} else if (c == '0') {
temp = temp.l;
}
if (temp.l == null && temp.r == null) {
sb.append(temp.keyOrType);
temp = root;
}

}
File file = new File(filename + ".copy");
FileOutputStream fos = new FileOutputStream(file);
fos.write(sb.toString().getBytes());
fos.close();
}

// 利用贪心算法的霍夫曼编码程序
ArrayList<Node> huffmanCode(List<Node> nodes) {
ArrayList<Node> temp = new ArrayList<Node>(nodes);
PriorityQueue<Node> queue = new PriorityQueue<Node>(nodes);
for (int i = 0; i < nodes.size() - 1; i++) {
Node l = queue.poll();
Node r = queue.poll();
Node tempNode = new Node(l, r, "@special", l.freq + r.freq);
temp.add(tempNode);
queue.add(tempNode);
}
return temp;
}

// 将每个字符的编码存至encod
4000
esheet中
void ergodic(Node node, String str) {
if (node.l != null)
ergodic(node.l, str + "0");
if (node.r != null)
ergodic(node.r, str + "1");
if (node.l == null && node.r == null) {
encodeSheet.put(node.keyOrType, str);
}
}

void huffmanCompress(Huffman h, String filename, String storefile)
throws IOException {
int[] sizes = { -1, -1 };
String str = h.textInput(filename, sizes);
ArrayList<Node> list = h.analyzeString(str);
list = h.huffmanCode(list);
Node node = list.get(list.size() - 1);
h.ergodic(node, "");
h.encode(str, filename + ".compress");
String encodeString = h.textInput(filename + ".compress", sizes);
System.out.println(sizes[1] + " " + sizes[0] + " "
+ ((float) sizes[1] / (float) sizes[0]));
rate = ((float) sizes[1] / (float) sizes[0]);
String decodeString = h.decode(encodeString);
h.decodeErgodic(decodeString, node, filename);
}

}

class Node implements Comparable<Object> {
Node l;
Node r;
String keyOrType;
int freq;

public Node(Node l, Node r, String keyOrType, int freq) {
this.l = l;
this.r = r;
this.keyOrType = keyOrType;
this.freq = freq;
}

public Node() {
}

@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((keyOrType == null) ? 0 : keyOrType.hashCode());
return result;
}

// 重写equal方法，只用keyOrType
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Node other = (Node) obj;
if (keyOrType == null) {
if (other.keyOrType != null)
return false;
} else if (!keyOrType.equals(other.keyOrType))
return false;
return true;
}

@Override
public int compareTo(Object o) {
Node node = (Node) o;
return this.freq - node.freq;
}

@Override
public String toString() {
return "Node [ keyOrType=" + keyOrType + " freq " + freq + "]";
}
}