Collections Data Structure Java

//     package com.croftsoft.core.util.filemap;
import java.io.BufferedOutputStream;
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.util.AbstractMap;
import java.util.AbstractSet;
import java.util.Iterator;
import java.util.Set;
/*********************************************************************
 * A Map that stores the values in files within a directory.
 * 
 * Uses filenames as the keys and InputStreams as the values.
 * 
 * @see FilenameKeyGenerator
 * @see java.util.AbstractMap
 * 
 * @version 1999-04-03
 * @author David Wallace Croft
 *********************************************************************/
public class FileMap extends AbstractMap
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
{
  private File rootDirectory;
  // ////////////////////////////////////////////////////////////////////
  // ////////////////////////////////////////////////////////////////////
  public static void main(String[] args)
  // ////////////////////////////////////////////////////////////////////
  {
    System.out.println(test());
  }
  public static boolean test()
  // ////////////////////////////////////////////////////////////////////
  {
    try {
      String filename = "com.orbs.util.filemap.FileMap_test.tmp";
      FileMap fileMap = new FileMap(new File("."));
      fileMap.put(filename, new ByteArrayInputStream("Hello".getBytes()));
      InputStream in = (InputStream) fileMap.get(filename);
      int i;
      while ((i = in.read()) > -1)
        System.out.write(i);
      in.close();
      System.out.println("");
      fileMap.remove(filename);
    } catch (Exception ex) {
      ex.printStackTrace();
      return false;
    }
    return true;
  }
  // ////////////////////////////////////////////////////////////////////
  // ////////////////////////////////////////////////////////////////////
  public FileMap(File rootDirectory)
  // ////////////////////////////////////////////////////////////////////
  {
    this.rootDirectory = rootDirectory;
  }
  // ////////////////////////////////////////////////////////////////////
  // ////////////////////////////////////////////////////////////////////
  public Set entrySet()
  // ////////////////////////////////////////////////////////////////////
  {
    return new FileMapEntrySet(rootDirectory);
  }
  // synchronize?
  public synchronized Object put(Object key, Object value)
  // ////////////////////////////////////////////////////////////////////
  {
    File file = null;
    BufferedOutputStream out = null;
    InputStream in = null;
    try {
      String filename = (String) key;
      file = new File(rootDirectory, filename);
      out = new BufferedOutputStream(new FileOutputStream(file));
      in = (InputStream) value;
      int i;
      while ((i = in.read()) > -1)
        out.write(i);
    } catch (IOException ioex) {
      try {
        out.close();
      } catch (Exception ex) {
      }
      try {
        file.delete();
      } catch (Exception ex) {
      }
      throw new RuntimeException(ioex.getMessage());
    } finally {
      try {
        in.close();
      } catch (Exception ex) {
      }
      try {
        out.close();
      } catch (Exception ex) {
      }
    }
    return null;
  }
  public synchronized Object remove(Object key)
  // ////////////////////////////////////////////////////////////////////
  {
    String filename = (String) key;
    File file = new File(rootDirectory, filename);
    file.delete();
    return null;
  }
  // ////////////////////////////////////////////////////////////////////
  // ////////////////////////////////////////////////////////////////////
}
/*********************************************************************
 * This Set is required for the AbstractMap implementation of FileMap.
 * 
 * @see FileMap
 * @see java.util.AbstractSet
 * 
 * @version 1999-04-03
 * @author David Wallace Croft
 *********************************************************************/
class FileMapEntrySet extends AbstractSet
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
{
  private File rootDirectory;
  // ////////////////////////////////////////////////////////////////////
  // ////////////////////////////////////////////////////////////////////
  public FileMapEntrySet(File rootDirectory)
  // ////////////////////////////////////////////////////////////////////
  {
    this.rootDirectory = rootDirectory;
  }
  // ////////////////////////////////////////////////////////////////////
  // ////////////////////////////////////////////////////////////////////
  public Iterator iterator()
  // ////////////////////////////////////////////////////////////////////
  {
    return new FileMapEntryIterator(rootDirectory);
  }
  public int size()
  // ////////////////////////////////////////////////////////////////////
  {
    String[] files = rootDirectory.list();
    if (files == null)
      return 0;
    return files.length;
  }
  // ////////////////////////////////////////////////////////////////////
  // ////////////////////////////////////////////////////////////////////
}
/*********************************************************************
 * This Iterator is required for the AbstractMap implementation of FileMap.
 * 
 * @see FileMap
 * @see java.util.AbstractSet
 * 
 * @version 1999-04-03
 * @author David Wallace Croft
 *********************************************************************/
class FileMapEntryIterator implements Iterator
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
{
  private File rootDirectory;
  private String[] files;
  private int index = 0;
  // ////////////////////////////////////////////////////////////////////
  // ////////////////////////////////////////////////////////////////////
  public FileMapEntryIterator(File rootDirectory)
  // ////////////////////////////////////////////////////////////////////
  {
    this.rootDirectory = rootDirectory;
  }
  // ////////////////////////////////////////////////////////////////////
  // ////////////////////////////////////////////////////////////////////
  public synchronized boolean hasNext()
  // ////////////////////////////////////////////////////////////////////
  {
    if (files == null)
      files = rootDirectory.list();
    if (files == null)
      return false;
    return (index < files.length);
  }
  public synchronized Object next()
  // ////////////////////////////////////////////////////////////////////
  {
    if (files == null)
      files = rootDirectory.list();
    if (files == null)
      return null;
    if (index >= files.length)
      return null;
    return new FileMapEntry(rootDirectory, files[index++]);
  }
  public synchronized void remove()
  // ////////////////////////////////////////////////////////////////////
  {
    if (files == null)
      files = rootDirectory.list();
    if (files == null)
      return;
    if (index >= files.length)
      return;
    new File(files[index]).delete();
  }
  // ////////////////////////////////////////////////////////////////////
  // ////////////////////////////////////////////////////////////////////
}
/*********************************************************************
 * This Map.Entry is required for the AbstractMap implementation of FileMap.
 * 
 * @see FileMapEntryIterator
 * @see FileMapEntrySet
 * @see java.util.Map.Entry
 * 
 * @version 1999-04-03
 * @author David Wallace Croft
 *********************************************************************/
class FileMapEntry implements Map.Entry
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
{
  private File rootDirectory;
  private String filename;
  // ////////////////////////////////////////////////////////////////////
  // ////////////////////////////////////////////////////////////////////
  public FileMapEntry(File rootDirectory, String filename)
  // ////////////////////////////////////////////////////////////////////
  {
    this.rootDirectory = rootDirectory;
    this.filename = filename;
  }
  // ////////////////////////////////////////////////////////////////////
  // ////////////////////////////////////////////////////////////////////
  public boolean equals(Object o)
  // ////////////////////////////////////////////////////////////////////
  {
    if (o == null)
      return false;
    if (!o.getClass().equals(this.getClass()))
      return false;
    FileMapEntry other = (FileMapEntry) o;
    if (!filename.equals(other.filename))
      return false;
    if (!rootDirectory.equals(other.rootDirectory))
      return false;
    if (hashCode() != other.hashCode())
      return false;
    return true;
  }
  public Object getKey()
  // ////////////////////////////////////////////////////////////////////
  {
    return filename;
  }
  public Object getValue()
  // ////////////////////////////////////////////////////////////////////
  {
    try {
      return new FileInputStream(new File(rootDirectory, filename));
    } catch (FileNotFoundException ex) {
      return null;
    }
  }
  public int hashCode()
  // ////////////////////////////////////////////////////////////////////
  {
    return filename.hashCode();
  }
  public Object setValue(Object value)
  // ////////////////////////////////////////////////////////////////////
  {
    throw new UnsupportedOperationException();
  }
  // ////////////////////////////////////////////////////////////////////
  // ////////////////////////////////////////////////////////////////////
}