Help with my compression code

Question

Lengthy code... appreciate some help though.
My compressed files are much larger than the originals are, by several times. The classes not shown in the code are from Shaffer's Data Structures and Algorithms for Java, and they are known to work. The problem comes when I print out the codeTable to the beginning of the encoded file (it's HUGE!) and the "compressed" files are even larger without the codeTable output to it. The problem comes since the bit representations of the Huffman tree are printed as bytes. So far only the compression portion is implemented, not decompressing.
I would appreciate if someone had a few minutes to kill and could help me out here. I believe the code is fairly well strcutured and easy to follow.
Thanks.
import java.io.*;
import java.util.*;
public class HuffZip {
     private static String[] codeTable = new String[256]; // The code lookup table
     private static int[] freqTable = new int[256]; // The frequencies of bytes
     private static int total = 0;  // Total number of bits needed by the Huffman code of a file
     private static List hufflist = null; // Initial List of HuffTree nodes
        private static HuffTree tree = null; // The HuffTree
        private static String inf; // The name of the input file
        private static String ouf; // The name of the output file
        private static File inF; // Input File
        private static File ouF; // Output File
        private static BufferedInputStream ins;
        private static BufferedOutputStream ous;
     static void usage() { // Called when args not proper length or format
          System.out.println("\"Usage: java HuffZip <zip|unzip> <inputFile> <outputFile>\"");
           System.exit(0);
     } // method Usage
     static void HZip(BufferedInputStream ins, BufferedOutputStream ous, List hufflist) throws IOException {
          int c;
          String tempString;
          int tempInt;
          int i;
          int freq;
          byte letter; // byte letter;
          HuffTree temptree;
          while ((c = ins.read()) != -1) {     
                tempString = String.valueOf(c);
              tempInt = Integer.parseInt(tempString);
              freqTable[tempInt] += 1;
        } // while  
        for (i = 0; i < freqTable.length; i++)
             char temp = (char)i;
             System.out.println(temp);
                letter = ((byte)temp);
               if((int)letter < 0)
                    letter += 256;
          //     if ( (0xff & letter) < 0) // Something to do with this
          //          letter += 256;
               freq = freqTable;
     //     System.out.println(letter + ", " + freq); // Need to fix the negative bytes // Testing
     temptree = new HuffTree(new LettFreq(freq, letter));
     for (hufflist.setFirst(); hufflist.isInList(); hufflist.next())
          if (temptree.weight() <= ((HuffTree)hufflist.currValue()).weight())
               hufflist.insert(temptree);
               break;
          } // if
     if (!hufflist.isInList())
          hufflist.append(temptree);
} // for
// hufflist.print(); // Testing
} // method HZip
     static void HUnzip(BufferedInputStream ins, BufferedOutputStream ous) throws IOException {
     } // method HUnzip
     static HuffTree buildTree(List hufflist) {
          HuffTree temp1, temp2, temp3;
          LettFreq tempnode;
          for (hufflist.setPos(1); hufflist.isInList(); hufflist.setPos(1)) {
               // While at least 2 items left
               hufflist.setFirst();
               temp1 = (HuffTree)hufflist.remove();
               temp2 = (HuffTree)hufflist.remove();
               tempnode = new LettFreq(temp1.weight() + temp2.weight());
               temp3 = new HuffTree(tempnode, temp1, temp2);
               // Return the list in sorted order
               for (hufflist.setFirst(); hufflist.isInList(); hufflist.next())
                    if (temp3.weight() <= ((HuffTree)(hufflist.currValue())).weight())
                         hufflist.insert(temp3);
                         break;
                    } // Put in list
                    if (!hufflist.isInList()) // It is the heaviest value
                         hufflist.append(temp3);
          } // for loop
          hufflist.setFirst(); // Tree now only element on list
          return (HuffTree)hufflist.remove(); // Return the tree
     } // method buildTree
     static void outputTree(BinNode node, String prefix) {
          Assert.notNull(node, "Bad Input Tree");
          // This is a full binary tree so must not be null subtrees
          if (node.isLeaf()) {
          //     System.out.println(((LettFreq)node.element()).letter() + "\t" + prefix); // Testing
               int byteCheck = (int)((LettFreq)node.element()).letter();
               if (byteCheck < 0)
                    byteCheck = byteCheck + 256;
               codeTable[byteCheck] = prefix;
          total += prefix.length() * ((LettFreq)node.element()).weight();
          //     System.out.println(total); // Testing
          //     System.out.println(codeTable[byteCheck] + " " + prefix); // Testing
          else {
               outputTree(node.left(), prefix + "0");
               outputTree(node.right(), prefix + "1");
     static void encode(BufferedInputStream ins, BufferedOutputStream ous, HuffTree tree) throws IOException {
          BinNode temp;
          String line;
          int i;
          int c;
          String tempString;
          String s;
          int tempInt;
          for(i = 0; i < 256; i++)
               ous.write(codeTable[i].getBytes());
          while ((c = ins.read()) != -1) {     
               tempString = String.valueOf(c);
               tempInt = Integer.parseInt(tempString);
               s = codeTable[tempInt];
               //System.out.println(s); // Testing
               ous.write(s.getBytes());
          } // while
     } //method encode
     public static void main(String args[]) throws FileNotFoundException, IOException {
          String ext;
          hufflist = new LList();
          if (args.length != 3)
               usage();
          inF = new File(args[1]);
          ouF = new File(args[2]);
          ins = new BufferedInputStream(new FileInputStream(inF));
          ous = new BufferedOutputStream(new FileOutputStream(ouF));
          inf = args[1];
          ouf = args[2];
          HZip(ins, ous, hufflist);
     HuffTree tree = buildTree(hufflist);
     outputTree(tree.root(), "");
     System.out.println("Average code length is: " + (double)total/(double)tree.weight()); // Testing
     ins = new BufferedInputStream(new FileInputStream(inF)); // Reset input file
     encode(ins, ous, tree);
     // Close streams prior to program ending           
          ins.close();
ous.close();                     
     } // method Main
} // class HuffZip

Answer 1

Downloading eclipse right now, thanks. I useJCreator
now, which is pretty lightweight and the onlyoutput
it provides is the compiler's textual messages.
I see where the problem is lying, however. 2places:
My huffman tree contains codes that seem to be upto
a few hundred bytes in length, hardly a savingsover
the single byte that represents a character!That's because your storing your bits as char's in
your strings. You should be storing your bits as
bits in a byte array. This will require some
knowledge of bit fiddling.Would you happen to know a place I could find a tutorial? I'd look myself, but not certain as to what I would be searching for (by name).
kudos.