ZipInputStream: getting file size of -1 when reading

Problem in a nutshell:
Created Zip file with java.util.Zip
When reading the file using a ZipInputStream, ZipEntry objects are returned with their size = -1.

Scenario: We have an import process that takes a zip file. I was thinking to automate the production of this zip file with a simple java app.
Simple enough using the java.util.zip package, or so I thought.
File generated successfully, openable in jZip in the format I wanted. Excellent.
Unfortunately the process fails because the size of the first file in the archive gets returned as -1, which causes a NegativeArraySizeException (it tries to create a byte array the size of the file. Don't ask me why)
Whats even crazier is if I unzip the contents, and then zip with jZip, the resulting file completes processing successfully!

Obviously something is funny about the way I'm constructing the zip file - but what?
Here is the relevant code snippet:

I'm running java 1.6.0_22 in Eclipse.

The following test file demonstrates this.
It creates a zip file, and then tries to read it in three different ways. Two of them work, unfortunately the third (the same method used by the library) does not.
For each method it prints out the Zip Entry, and the 'size' of the Zip entry according to the object.
I've also attached a zip file which 'works' with all three methods.

The results I get from running this:

When I read my generated file using the ZipFile object it works, but not with ZipInputStream.
Reading the zip file generated with jZip works with all methods.

What I want is to be able to produce a zip file that can read the size back on the ZipInputStream.

Can anyone shed some light on this?

package test;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

public class TestZipFileReadWrite {

public static final String FILE_NAME = "temp.xml";

private static final String testString = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n" +
			"<testXml>\r\n" +
			"	<foo id=\"12345\"/>\r\n" +
			"	<bar id=\"67890\"/>\r\n" +
			"</testXml>";

public TestZipFileReadWrite() {
		try {
			// zip file to construct
			final File zipFile = new File("temp.zip");
			// content file to zip
			final File contentFile = new File(FILE_NAME);

createTestFileToZip(contentFile, testString);
			createZipFile(zipFile, contentFile);

System.out.println("test reading the newly generated zip file.");
			testReadingZipFile(zipFile);

System.out.println();

// test with a file I prepared earlier. Exactly same contents, except zipped with jZip.
			System.out.println("test reading a jzip zip file");
			final File secondZipFile = new File("works.zip");
			testReadingZipFile(secondZipFile);

} catch (final IOException e) {
			e.printStackTrace();
		}
	}

public void testReadingZipFile(final File zipFile) throws ZipException, IOException {
		final ZipEntry ze1 = testReadFileWithZipFileClass(zipFile);
		System.out.println("testReadFileWithZipFileClass:\t\t " + ze1 + ":" + ze1.getSize());

final ZipEntry ze2 = testReadFileWithZipFileClass2(zipFile, FILE_NAME);
		System.out.println("testReadFileWithZipFileClass2:\t\t " + ze2 + ":" + ze2.getSize());

final ZipEntry ze3 = testReadFileWithZipFileInputStream(zipFile);
		System.out.println("testReadFileWithZipFileInputStream:\t " + ze3 + ":" + ze3.getSize());
	}

private void createTestFileToZip(final File tempFile, final String contents) throws IOException {
		final FileOutputStream fileOut = new FileOutputStream(tempFile);
		final InputStream in = new ByteArrayInputStream(contents.getBytes());
		writeToStream(in, fileOut);
		fileOut.flush();
		fileOut.close();

}

private void createZipFile(final File zipFile, final File... filesToZip) throws IOException {

final FileOutputStream fileOut = new FileOutputStream(zipFile);
		final ZipOutputStream out = new ZipOutputStream(fileOut);

for (final File fileToZip : filesToZip) {
			writeFileToZip(out, fileToZip);
		}

out.flush();
		out.close();
	}

private void writeFileToZip(final ZipOutputStream out, final File fileToAdd) throws IOException,
			FileNotFoundException {
		final ZipEntry zipEntry = new ZipEntry(fileToAdd.getName());
		zipEntry.setSize(fileToAdd.length());
		out.putNextEntry(zipEntry);
		final FileInputStream in = new FileInputStream(fileToAdd);
		writeToStream(in, out);
		out.closeEntry();
	}

private void writeToStream(final InputStream in, final OutputStream out) throws IOException {
		final byte[] b = new byte[1000];
		int read = 0;
		while ((read = in.read(b)) > 0) {
			out.write(b, 0, read);
		}
	}

public ZipEntry testReadFileWithZipFileClass(final File zipFile) throws ZipException, IOException {
		final ZipFile zip = new ZipFile(zipFile);
		try {
			final Enumeration<? extends ZipEntry> entries = zip.entries();
			if (entries.hasMoreElements()) {
				final ZipEntry nextElement = entries.nextElement();
				return nextElement;
			}
			return null;
		} finally {
			zip.close();
		}
	}

public ZipEntry testReadFileWithZipFileClass2(final File zipFile, final String entryName) throws ZipException, IOException {
		final ZipFile zip = new ZipFile(zipFile);
		try {
			return zip.getEntry(entryName);
		} finally {
			zip.close();
		}
	}

public ZipEntry testReadFileWithZipFileInputStream(final File zipFile) throws IOException {

final InputStream zipFileInputStream = new FileInputStream(zipFile);
		final ZipInputStream zipIS = new ZipInputStream(zipFileInputStream);
		try {
			final ZipEntry nextDoc = zipIS.getNextEntry();
			return nextDoc;
		} finally {
			zipIS.close();
		}

}

public static void main(final String[] argv) {
		new TestZipFileReadWrite();
	}
}

all i can tell you is that a return value of -1 is the same as saying "i cant find it" or null or false

True. From the Javadocs of ZipEntry.getSize():

Returns:
the uncompressed size of the entry data, or -1 if not known

You'll need to take other measures if that's the case (like using a ByteArrayOutputStream).