Using null key or an uninitialized key

Title: Using null key or an uninitialized key when put a object into map.
Today, I encountered the problem shown as below when running a module.

Caused by: java.lang.IllegalArgumentException: No name specified
at org.apache.commons.beanutils.PropertyUtilsBean.isWriteable(PropertyUtilsBean.java:1226)
at org.apache.commons.beanutils.BeanUtilsBean.copyProperties(BeanUtilsBean.java:243)
at org.apache.commons.beanutils.BeanUtils.copyProperties(BeanUtils.java:114)
...

BeanUtilsBean.java

 /**
 * <p>Copy property values from the origin bean to the destination bean
 * for all cases where the property names are the same.</p>
 *
 * <p>For more details see <code>BeanUtilsBean</code>.</p>
 *
 * @see BeanUtilsBean#copyProperties
 */
public static void copyProperties(Object dest, Object orig)
    throws IllegalAccessException, InvocationTargetException {
    
    BeanUtilsBean.getInstance().copyProperties(dest, orig);
}

BeanUtilsBean.java

 /**
 * <p>Copy property values from the origin bean to the destination bean
 * for all cases where the property names are the same.  For each
 * property, a conversion is attempted as necessary.  All combinations of
 * standard JavaBeans and DynaBeans as origin and destination are
 * supported.  Properties that exist in the origin bean, but do not exist
 * in the destination bean (or are read-only in the destination bean) are
 * silently ignored.</p>
 *
 * <p>If the origin "bean" is actually a <code>Map</code>, it is assumed
 * to contain String-valued <strong>simple</strong> property names as the keys, pointing at
 * the corresponding property values that will be converted (if necessary)
 * and set in the destination bean. <strong>Note</strong> that this method
 * is intended to perform a "shallow copy" of the properties and so complex
 * properties (for example, nested ones) will not be copied.</p>
 *
 * <p>This method differs from <code>populate()</code>, which
 * was primarily designed for populating JavaBeans from the map of request
 * parameters retrieved on an HTTP request, is that no scalar->indexed
 * or indexed->scalar manipulations are performed.  If the origin property
 * is indexed, the destination property must be also.</p>
 *
 * <p>If you know that no type conversions are required, the
 * <code>copyProperties()</code> method in {@link PropertyUtils} will
 * execute faster than this method.</p>
 *
 * <p><strong>FIXME</strong> - Indexed and mapped properties that do not
 * have getter and setter methods for the underlying array or Map are not
 * copied by this method.</p>
 *
 * @param dest Destination bean whose properties are modified
 * @param orig Origin bean whose properties are retrieved
 *
 * @exception IllegalAccessException if the caller does not have
 *  access to the property accessor method
 * @exception IllegalArgumentException if the <code>dest</code> or
 *  <code>orig</code> argument is null
 * @exception InvocationTargetException if the property accessor method
 *  throws an exception
 */
public void copyProperties(Object dest, Object orig)
    throws IllegalAccessException, InvocationTargetException {

    // Validate existence of the specified beans
    if (dest == null) {
        throw new IllegalArgumentException
                ("No destination bean specified");
    }
    if (orig == null) {
        throw new IllegalArgumentException("No origin bean specified");
    }
    if (log.isDebugEnabled()) {
        log.debug("BeanUtils.copyProperties(" + dest + ", " +
                  orig + ")");
    }

    // Copy the properties, converting as necessary
    if (orig instanceof DynaBean) {
        DynaProperty origDescriptors[] =
            ((DynaBean) orig).getDynaClass().getDynaProperties();
        for (int i = 0; i < origDescriptors.length; i++) {
            String name = origDescriptors[i].getName();
            if (getPropertyUtils().isWriteable(dest, name)) {
                Object value = ((DynaBean) orig).get(name);
                copyProperty(dest, name, value);
            }
        }
    } else if (orig instanceof Map) {
        Iterator names = ((Map) orig).keySet().iterator();
        while (names.hasNext()) {
            String name = (String) names.next();
            if (getPropertyUtils().isWriteable(dest, name)) {
                Object value = ((Map) orig).get(name);
                copyProperty(dest, name, value);
            }
        }
    } else /* if (orig is a standard JavaBean) */ {
        PropertyDescriptor origDescriptors[] =
            getPropertyUtils().getPropertyDescriptors(orig);
        for (int i = 0; i < origDescriptors.length; i++) {
            String name = origDescriptors[i].getName();
            if ("class".equals(name)) {
                continue; // No point in trying to set an object's class
            }
            if (getPropertyUtils().isReadable(orig, name) &&
                getPropertyUtils().isWriteable(dest, name)) {
                try {
                    Object value =
                        getPropertyUtils().getSimpleProperty(orig, name);
                    copyProperty(dest, name, value);
                } catch (NoSuchMethodException e) {
                    ; // Should not happen
                }
            }
        }
    }

}

PropertyUtilsBean.java

/**
 * <p>Return <code>true</code> if the specified property name identifies
 * a writeable property on the specified bean; otherwise, return
 * <code>false</code>.
 *
 * @param bean Bean to be examined (may be a {@link DynaBean}
 * @param name Property name to be evaluated
 *
 * @exception IllegalPointerException if <code>bean</code>
 *  or <code>name</code> is <code>null</code>
 *
 * @since BeanUtils 1.6
 */
public boolean isWriteable(Object bean, String name) {

    // Validate method parameters
    if (bean == null) {
        throw new IllegalArgumentException("No bean specified");
    }
    if (name == null) {
        throw new IllegalArgumentException("No name specified");
    }

    // Return the requested result
    if (bean instanceof DynaBean) {
        // All DynaBean properties are writeable
        return (((DynaBean) bean).getDynaClass().getDynaProperty(name) != null);
    } else {
        try {
            PropertyDescriptor desc =
                getPropertyDescriptor(bean, name);
            if (desc != null) {
                Method writeMethod = desc.getWriteMethod();
                if ((writeMethod == null) &&
                    (desc instanceof IndexedPropertyDescriptor)) {
                    writeMethod = ((IndexedPropertyDescriptor) desc).getIndexedWriteMethod();
                }
                return (writeMethod != null);
            } else {
                return (false);
            }
        } catch (IllegalAccessException e) {
            return (false);
        } catch (InvocationTargetException e) {
            return (false);
        } catch (NoSuchMethodException e) {
            return (false);
        }
    }

}

I thought null cannot be used as a key. Having getten "java.lang.IllegalArgumentException: No name specified" exception, I can't understand but this is a fact.
I found a object was put into a map using an uninitialized key at last.


Below code is a test for a null key and an uninitialized key.

public class Test {

	String uninitializedKey;
	/*
	 * The result is : 
	 * Test null as a key. 
	 * Test null as a key. 
	 * Test not initialized key. 
	 * Test not initialized key.
	 */
	public void test() {
		Map<String, String> map1 = new HashMap<String, String>();
		map1.put(null, "Test null as a key.");
		System.out.println(map1.get(null));
		System.out.println(map1.get(uninitializedKey));

		Map<String, String> map2 = new HashMap<String, String>();
		map2.put(uninitializedKey, "Test an uninitialized key.");
		System.out.println(map2.get(null));
		System.out.println(map2.get(uninitializedKey));
		
	}

	public static void main(String[] args) {
		new Test().test();
	}
}