I have come up with this (below). Have tested it and it seems to work,
but i have two concerns:

1. Is there anything that i might have done wrongly? i.e. anything that
could break it in future?

2. What if one of the classes in the "jar bytes" refer to a properties
file that is jarred together? How should this be handled? Looking at
the API for ClassLoader, it seems that i should override findResource,
but that method returns a URL, so i'm not sure what to return if i do
override it.

import EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Map;
import java.util.jar.JarEntry;
import java.util.jar.JarInputStream;

public class JarBytesClassLoader extends ClassLoader
{
    private static JarBytesClassLoader jarBytesClassLoader = new
JarBytesClassLoader();

    private Map classesMap; // Fully Qualified Class Name (String) to Byte
Array (byte[])

    private JarBytesClassLoader()
    {
        this.classesMap = new ConcurrentReaderHashMap();
    }

    public static JarBytesClassLoader getInstance()
    {
        return jarBytesClassLoader;
    }

    public void addJarBytes(byte[] jarBytes)
    {
        ByteArrayInputStream byteArrayInputStream = null;
        JarInputStream jarInputStream = null;
        BufferedInputStream bufferedInputStream = null;
        try
        {
            byteArrayInputStream = new ByteArrayInputStream(jarBytes);
            jarInputStream = new JarInputStream(byteArrayInputStream);
            bufferedInputStream = new BufferedInputStream(jarInputStream);

            JarEntry jarEntry = null;
            while ((jarEntry = jarInputStream.getNextJarEntry()) != null)
            {
                if (!jarEntry.isDirectory())
                {
                    String name = jarEntry.getName();
                    if ((name.toLowerCase().endsWith(".class")))
                    {
                        String className = name.replaceAll("/", ".").substring(0,
(name.length() - 6));
                        // System.out.println(className);

                        ByteArrayOutputStream byteArrayOutputStream = null;
                        BufferedOutputStream bufferedOutputStream = null;
                        try
                        {
                            byteArrayOutputStream = new ByteArrayOutputStream();
                            bufferedOutputStream = new
BufferedOutputStream(byteArrayOutputStream);

                            int i = -1;
                            while ((i = bufferedInputStream.read()) != -1)
                            {
                                bufferedOutputStream.write(i);
                            }

                            bufferedOutputStream.flush();

                            byte[] bytes = byteArrayOutputStream.toByteArray();
                            this.classesMap.put(className, bytes);
                        }
                        finally
                        {
                            if (byteArrayOutputStream != null)
                            {
                                try
                                {
                                    byteArrayOutputStream.close();
                                }
                                catch (IOException ex)
                                {
                                    // Ignore IOException When Closing
                                }
                            }

                            if (bufferedOutputStream != null)
                            {
                                try
                                {
                                    bufferedOutputStream.close();
                                }
                                catch (IOException ex)
                                {
                                    // Ignore IOException When Closing
                                }
                            }
                        }
                    }
                }

                jarInputStream.closeEntry();
            }
        }
        catch (IOException ex)
        {
            // TODO
            ex.printStackTrace();
        }
        finally
        {
            if (byteArrayInputStream != null)
            {
                try
                {
                    byteArrayInputStream.close();
                }
                catch (IOException ex)
                {
                    // Ignore IOException When Closing
                }
            }

            if (jarInputStream != null)
            {
                try
                {
                    jarInputStream.close();
                }
                catch (IOException ex)
                {
                    // Ignore IOException When Closing
                }
            }

            if (bufferedInputStream != null)
            {
                try
                {
                    bufferedInputStream.close();
                }
                catch (IOException ex)
                {
                    // Ignore IOException When Closing
                }
            }
        }
    }

    public static void reset()
    {
        jarBytesClassLoader.classesMap.clear();
        jarBytesClassLoader = new JarBytesClassLoader();
    }

    protected Class findClass(String name)
    {
        byte[] bytes = loadClassData(name);
        return (defineClass(name, bytes, 0, bytes.length));
    }

    private byte[] loadClassData(String name)
    {
        return ((byte[]) this.classesMap.get(name));
    }
}

TIA and Regards,
Edwin