java.util; 
java.util.zip; 
java.io;

java.util.zip namespace contains the classes and methods to implement the
compress and uncompress functionalities within our code. The main classes used
from the above namespaces are

• ZipFile
  
• ZipEntry
  
• ZipOutputSteam
  
• Enumeration

Programmatically, a ZipFile object can be considered equivalent to a physical Zip file. A ZipFile can contain multiple ZipEntry objects apart from the actual content of the zipped files. In fact each ZipEntry object is the metadata about a zip file. The ZipOutputStream class represents a writable stream pointing to a ZIP file. This stream can be used to write ZipEntry objects and content to the ZIP file. Enumeration enables iteration through each element in a collection.

Using the code

Below is a code sample to create a zip file.

private void Zip(string zipFileName, string[] sourceFile)
{
	FileOutputStream filOpStrm = new FileOutputStream(zipFileName);
	ZipOutputStream zipOpStrm = new ZipOutputStream(filOpStrm);
	FileInputStream filIpStrm = null;
	foreach(string strFilName  in sourceFile)
	{ 
		filIpStrm = new FileInputStream(strFilName);
		ZipEntry ze = new  ZipEntry(Path.GetFileName(strFilName)); zipOpStrm.putNextEntry(ze);
		sbyte[] buffer =  new
		sbyte[1024];
		int len =  0;
		while ((len = 

		 filIpStrm.read(buffer))  > = 0)
		{
			zipOpStrm.write(buffer, 0, len);
		}
	}
	zipOpStrm.closeEntry();
	filIpStrm.close();
	zipOpStrm.close();
	filOpStrm.close();
}

1. zipFileName - Zip file name including the path and
   
2. sourceFile - string array of file names that are to be zipped.

The FileOutputStream class is capable of writing content to a file. Its
constructor accepts the path of the file to which we wish to write.
FileOutputStream object is then supplied to an instance of ZipOutputStream class as parameter. The ZipOutputStream class represents a writable stream to a ZIP file.

The foreach loops through each file to be zipped, creates corresponding
zip entries and adds it to the final zip file. Taking a deeper look into the
code, a FileInputStream object is created for each file to be zipped.
FileInputStream object is capable of reading from a file as a stream. Then a
ZipEntry object is created for each file to be zipped. The constructor of
ZipEntry class accepts name of the file. Path.GetFileName() returns the file
name and extension of the specified path string.

The newly created ZipEntry object is added to the ZipOutputStream object using its putNextEntry() method. In fact, a ZipEntry merely represents metadata of file entry. You still need to add actual contents into the Zip file. Therefore you need to transfer data from source FileInputStream to destination FileOutputStream. This is exactly what the while loop does in the above piece of code. It reads content from the source file and writes it into the output zip file. Finally, closeEntry() method of ZipOutputStream class is called and this caused the physical creation of the Zip file. All the other streams created are also closed.

private void Extract(string zipFileName, string destinationPath)
{
ZipFile zipfile = new ZipFile(zipFileName);
List<ZipEntry> zipFiles = GetZippedFiles(zipfile);

foreach (ZipEntry zipFile in zipFiles)
{
	if (!zipFile.isDirectory())
	{
		InputStream s = zipfile.getInputStream(zipFile); 
		try 
		{
			Directory.CreateDirectory(destinationPath + "\\"  + Path.GetDirectoryName(zipFile.getName()));
			FileOutputStream dest = new FileOutputStream(Path.Combine(destinationPath + "\\" +
				Path.GetDirectoryName(zipFile.getName()), Path.GetFileName(zipFile.getName()))); 
			try
			{
				int len = 0;
				sbyte[] buffer = new  sbyte[7168];
				while ((len = s.read(buffer))  > = 0)
				{
					dest.write(buffer, 0, len);
				}
			}
			finally
			{
				dest.close();
			}
		}
		finally
		{
			s.close();
		}
	}
}
}

The ExtractZipFile() method accepts two parameters; ZIP file name(including path) to be extracted and destination path where the files are to be extracted. It then creates a ZipFile object and retrieves entries in the ZIP file using GetZipFiles() method. This method will be discussed afterwards in this article. The foreach loop iterates through all the entries in the zip file and in each iteration the entry is extracted to the specified folder. The code in the foreach loop executes only if the entry is not a folder. This condition is verified using isDirectory() method of ZipEntry object. Each entry is read into an InputStream using getInputStream() method of ZipFile object. This InputStream acts as the source stream. The destination stream is a FileOutputStream object which is created based on the specified destination
folder. Here we use the getName() method of ZipEntry object to get the file
name(including path) of the entry. During the extraction, the original folder
structure is maintained.In the while loop that follows, content from the source
InputStream is written to the destination FileOutputStream. The source stream is read to a buffer using read() method. It reads 7Kb in a sequence into a
temporary buffer and write() method of destination FileOutputStream writes the
content to the stream from the buffer, using the write method. It is in the
finally block that follows, the destination FileOutputStream is closed and the
content is physically written to disk.

private List<ZipEntry> GetZipFiles(ZipFile zipfil)
{
	List<ZipEntry> lstZip = new List<ZipEntry>();
	Enumeration zipEnum = zipfil.entries();
	while(zipEnum.hasMoreElements())
	{
		ZipEntry zip = (ZipEntry)zipEnum.nextElement();
		lstZip.Add(zip);
	}
	return lstZip;
}

The GetZipFiles() method returns a generic List of ZipEntry objects taking a ZipFile object as argument. The method creates a generic collection of ZipEntry type. Now comes the use of an interesting feature in Java language, the use of Enumeration. Note that its not the enum type that we have in C#. An object that implements the Enumeration interface generates a series of elements, one at a time. Successive calls to the nextElement() method return successive elements of the series. The hasMoreElements() method returns a boolean value indicating if the Enumerator contains more elements. Here, entries() method of ZipFile class returns an Enumeration of ZipEntry objects. The code then iterates through the Enumeration and populates the List. Finally, the populated List is returned.

Apart from the above listed code, the downloadable source code for the sample application, contains some extra code to handle the UI part of the application, ie., entries made to the ListBox and handling the progress bar. I haven't included them in this article because I didn't want to loose focus from the main objective of the article. The code is comprehensive, but the UI
controls can be handled in better ways, keeping performance and usability in
mind. One good option might be to keep our zip functionality separate from the
UI thread, so that interactivity is well maintained.

Points of Interest

One interesting fact we note while using Java library is the difference in naming conventions, especially the naming of methods. For C# coders, methods give the feel of variable names. Also the way the classes are named is also a distinguishable factor.

Even though we can't use the features of java beyond an extend because runtime decides the main advantages of a platform; we take advantage of using the java libraries. The gives an upper hand over java for C#. Wish Microsoft continue support of J#.