Deflater/Inflater Anomaly

Question

Wrote a small class to provide deflate and inflate functionality to other classes, ran a few files through it and found that the uncompressed file was one byte longer than the input file. That byte showed up as a "?" at the end of the utf-8 file. Why is this?
Code:
package com.sra.pipeline.compression;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.util.zip.Deflater;
import java.util.zip.DeflaterInputStream;
import java.util.zip.Inflater;
import java.util.zip.InflaterInputStream;
public class Compressor {
     private String input = "input/aabqirL4Ob.html";
     private String output = "output/aabqirL4Ob.html";
     private String input1 = "input/aabpKgL4Ob.html";
     private String output1 = "output/aabpKgL4Ob.html";
     public Compressor() {
          byte[] bytes = readFile();
          System.out.println("File len " + bytes.length);
          byte[] cbytes = compress(bytes);
          System.out.println("Compressed len " + cbytes.length);
          byte[] fbytes = inflate(cbytes);
          System.out.println("UNCompressed len " + fbytes.length);
          writeFile(fbytes);
     public byte[] readFile() {
          byte[] bytes = null;
          try {
               File file = new File(input1);
               bytes = new byte[(int)file.length()];
               FileInputStream fis = new FileInputStream(file);
               fis.read(bytes);
          } catch (FileNotFoundException e) {
               e.printStackTrace();
          } catch (IOException e) {
               e.printStackTrace();
          return(bytes);
     public byte[] compress(byte[] bytes) {
          ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
          DeflaterInputStream dis = new DeflaterInputStream(bais);
          ByteArrayOutputStream baos = new ByteArrayOutputStream();
          try {
               while(dis.available() == 1) {
                    baos.write(dis.read());
          } catch (IOException e) {
               e.printStackTrace();
          return(baos.toByteArray());
     public byte[] inflate(byte[] cbytes) {
          ByteArrayInputStream bais = new ByteArrayInputStream(cbytes);
          InflaterInputStream iis = new InflaterInputStream(bais);
          ByteArrayOutputStream baos = new ByteArrayOutputStream();
          try {
               while(iis.available() == 1) {
                    baos.write(iis.read());
          } catch (IOException e) {
               e.printStackTrace();
          return(baos.toByteArray());
     public void writeFile(byte[] out) {
          try {
               FileWriter fw = new FileWriter(new File(output1));
               fw.write(new String(out, "utf-8"));
               fw.close();
          } catch (IOException e) {
               e.printStackTrace();
     public static void main(String[] args) {
          new Compressor();
}Thanks for any ideas,
Jim

Answer 1

     public Compressor() {
          byte[] bytes = readFile();Here you are reading the entire file into memory which is already a bad idea.
          byte[] cbytes = compress(bytes);At this point you have both the plaintext and the compressed data in memory at the same time which is now twice as bad.
               bytes = new byte[(int)file.length()];Here you are assuming the file size fits into an int.
               fis.read(bytes);Here you are ignoring the result of the read() method.
          } catch (FileNotFoundException e) {
               e.printStackTrace();
          } catch (IOException e) {
               e.printStackTrace();
          }Here you are essentially ignoring these exceptions and returning a byte array full of nothing to the caller. It would make more sense just to let the exceptions be thrown out of the method and let the caller see and deal with them.
          ByteArrayInputStream bais = new ByteArrayInputStream(bytes);Here you are constructing an InputStream around the bytes you read from a FileInputStream. Why not just read directly from the FileInputStream here?
          DeflaterInputStream dis = new DeflaterInputStream(bais);
          ByteArrayOutputStream baos = new ByteArrayOutputStream();And here you are writing to a ByteArrayOutputStream from which you are going to extract a byte array and write it to a FileOutputStream. Why not write directly to the FileOutputStream?
          try {
               while(dis.available() == 1) {Here you are misusing the available() function. It is never guaranteed to return 1 and it is not intended to tell you when you've reached the end of the input. read() returns a sentinel value for that purpose. Use it. There are few if any correct uses of available() and this is certainly not one of them.
                    baos.write(dis.read());Here you are ignoring the possibility that the return value is the sentinel, so you're writing junk to the file.
          } catch (IOException e) {
               e.printStackTrace();
          }See above re exception handling.
All these remarks also apply to your inflate method.
               FileWriter fw = new FileWriter(new File(output1));
               fw.write(new String(out, "utf-8"));And here you are committing the worst error of all: you are using a Writer to write binary data.
But the bottom line is that you haven't added any value to what the inflater/deflater input and output streams already provide. So throw this all away and use those. All this stuff can be reduced to new InflaterInputStream(new FileInputStream(...)) and new DeflaterOutputStream(new FileOutputStream(...)) and a couple of copy loops, which should look like this:
int count;
byte[] buffer = new byte[8192];
while ((count = in.read(buffer)) > 0)
  out.write(buffer, 0, count);
out.close();
in.close();