public static String addResourcePathToPackagePath(Class clazz,
    String resourceName) 
{
		Assert.notNull(resourceName, "Resource name must not be null");
		if (!resourceName.startsWith("/")) {
			return classPackageAsResourcePath(clazz) + "/" + resourceName;
		}
		return classPackageAsResourcePath(clazz) + resourceName;
}

Return a path suitable for use with ClassLoader.getResource (also suitable for use with Class.getResource by prepending a slash ('/') to the return value. Built by taking the package of the specified class file, converting all dots ('.') to slashes ('/'), adding a trailing slash if necesssary, and concatenating the specified resource name to this.
As such, this function may be used to build a path suitable for loading a resource file that is in the same package as a class file, although org.springframework.core.io.ClassPathResource is usually even more convenient.

 public static String classNamesToString(Class[] classes) 
{
		return classNamesToString(Arrays.asList(classes));
}

Build a String that consists of the names of the classes/interfaces in the given array.

Basically like AbstractCollection.toString(), but stripping the "class "/"interface " prefix before every class name.

 public static String classNamesToString(Collection classes) 
{
		if (CollectionUtils.isEmpty(classes)) {
			return "[]";
		}
		StringBuffer sb = new StringBuffer("[");
		for (Iterator it = classes.iterator(); it.hasNext(); ) {
			Class clazz = (Class) it.next();
			sb.append(clazz.getName());
			if (it.hasNext()) {
				sb.append(", ");
			}
		}
		sb.append("]");
		return sb.toString();
}

Build a String that consists of the names of the classes/interfaces in the given collection.

Basically like AbstractCollection.toString(), but stripping the "class "/"interface " prefix before every class name.

 public static String classPackageAsResourcePath(Class clazz) 
{
		if (clazz == null) {
			return "";
		}
		String className = clazz.getName();
		int packageEndIndex = className.lastIndexOf('.");
		if (packageEndIndex == -1) {
			return "";
		}
		String packageName = className.substring(0, packageEndIndex);
		return packageName.replace('.", '/");
}

Given an input class object, return a string which consists of the class's package name as a pathname, i.e., all dots ('.') are replaced by slashes ('/'). Neither a leading nor trailing slash is added. The result could be concatenated with a slash and the name of a resource, and fed directly to ClassLoader.getResource(). For it to be fed to Class.getResource instead, a leading slash would also have to be prepended to the returned value.

 public static String convertClassNameToResourcePath(String className) 
{
		return className.replace('.", '/");
}

Convert a "."-based fully qualified class name to a "/"-based resource path.

 public static String convertResourcePathToClassName(String resourcePath) 
{
		return resourcePath.replace('/", '.");
}

Convert a "/"-based resource path to a "."-based fully qualified class name.

 public static Class createCompositeInterface(Class[] interfaces,
    ClassLoader classLoader) 
{
		Assert.notEmpty(interfaces, "Interfaces must not be empty");
		Assert.notNull(classLoader, "ClassLoader must not be null");
		return Proxy.getProxyClass(classLoader, interfaces);
}

Create a composite interface Class for the given interfaces, implementing the given interfaces in one single Class.

This implementation builds a JDK proxy class for the given interfaces.

 public static Class forName(String name) throws ClassNotFoundException, LinkageError 
{
		return forName(name, getDefaultClassLoader());
}

Replacement for Class.forName() that also returns Class instances for primitives (like "int") and array class names (like "String[]").

Always uses the default class loader: that is, preferably the thread context class loader, or the ClassLoader that loaded the ClassUtils class as fallback.

 public static Class forName(String name,
    ClassLoader classLoader) throws ClassNotFoundException, LinkageError 
{
		Assert.notNull(name, "Name must not be null");
		Class clazz = resolvePrimitiveClassName(name);
		if (clazz != null) {
			return clazz;
		}
		// "java.lang.String[]" style arrays
		if (name.endsWith(ARRAY_SUFFIX)) {
			String elementClassName = name.substring(0, name.length() - ARRAY_SUFFIX.length());
			Class elementClass = forName(elementClassName, classLoader);
			return Array.newInstance(elementClass, 0).getClass();
		}
		// "[Ljava.lang.String;" style arrays
		int internalArrayMarker = name.indexOf(INTERNAL_ARRAY_PREFIX);
		if (internalArrayMarker != -1 && name.endsWith(";")) {
			String elementClassName = null;
			if (internalArrayMarker == 0) {
				elementClassName = name.substring(INTERNAL_ARRAY_PREFIX.length(), name.length() - 1);
			}
			else if (name.startsWith("[")) {
				elementClassName = name.substring(1);
			}
			Class elementClass = forName(elementClassName, classLoader);
			return Array.newInstance(elementClass, 0).getClass();
		}
		ClassLoader classLoaderToUse = classLoader;
		if (classLoaderToUse == null) {
			classLoaderToUse = getDefaultClassLoader();
		}
		return classLoaderToUse.loadClass(name);
}

Replacement for Class.forName() that also returns Class instances for primitives (like "int") and array class names (like "String[]").

 public static Class[] getAllInterfaces(Object instance) 
{
		Assert.notNull(instance, "Instance must not be null");
		return getAllInterfacesForClass(instance.getClass());
}

Return all interfaces that the given instance implements as array, including ones implemented by superclasses.

 public static Set getAllInterfacesAsSet(Object instance) 
{
		Assert.notNull(instance, "Instance must not be null");
		return getAllInterfacesForClassAsSet(instance.getClass());
}

Return all interfaces that the given instance implements as Set, including ones implemented by superclasses.

 public static Class[] getAllInterfacesForClass(Class clazz) 
{
		return getAllInterfacesForClass(clazz, null);
}

Return all interfaces that the given class implements as array, including ones implemented by superclasses.

If the class itself is an interface, it gets returned as sole interface.

 public static Class[] getAllInterfacesForClass(Class clazz,
    ClassLoader classLoader) 
{
		Assert.notNull(clazz, "Class must not be null");
		if (clazz.isInterface()) {
			return new Class[] {clazz};
		}
		List interfaces = new ArrayList();
		while (clazz != null) {
			for (int i = 0; i <  clazz.getInterfaces().length; i++) {
				Class ifc = clazz.getInterfaces()[i];
				if (!interfaces.contains(ifc) &&
						(classLoader == null || isVisible(ifc, classLoader))) {
					interfaces.add(ifc);
				}
			}
			clazz = clazz.getSuperclass();
		}
		return (Class[]) interfaces.toArray(new Class[interfaces.size()]);
}

Return all interfaces that the given class implements as array, including ones implemented by superclasses.

If the class itself is an interface, it gets returned as sole interface.

 public static Set getAllInterfacesForClassAsSet(Class clazz) 
{
		return getAllInterfacesForClassAsSet(clazz, null);
}

Return all interfaces that the given class implements as Set, including ones implemented by superclasses.

If the class itself is an interface, it gets returned as sole interface.

 public static Set getAllInterfacesForClassAsSet(Class clazz,
    ClassLoader classLoader) 
{
		Assert.notNull(clazz, "Class must not be null");
		if (clazz.isInterface()) {
			return Collections.singleton(clazz);
		}
		Set interfaces = new LinkedHashSet();
		while (clazz != null) {
			for (int i = 0; i <  clazz.getInterfaces().length; i++) {
				Class ifc = clazz.getInterfaces()[i];
				if (classLoader == null || isVisible(ifc, classLoader)) {
					interfaces.add(ifc);
				}
			}
			clazz = clazz.getSuperclass();
		}
		return interfaces;
}

Return all interfaces that the given class implements as Set, including ones implemented by superclasses.

If the class itself is an interface, it gets returned as sole interface.

 public static String getClassFileName(Class clazz) 
{
		Assert.notNull(clazz, "Class must not be null");
		String className = clazz.getName();
		int lastDotIndex = className.lastIndexOf(PACKAGE_SEPARATOR);
		return className.substring(lastDotIndex + 1) + CLASS_FILE_SUFFIX;
}

Determine the name of the class file, relative to the containing package: e.g. "String.class"

 public static Constructor getConstructorIfAvailable(Class clazz,
    Class[] paramTypes) 
{
		Assert.notNull(clazz, "Class must not be null");
		try {
			return clazz.getConstructor(paramTypes);
		}
		catch (NoSuchMethodException ex) {
			return null;
		}
}

Determine whether the given class has a constructor with the given signature, and return it if available (else return null).

Essentially translates NoSuchMethodException to null.

 public static ClassLoader getDefaultClassLoader() 
{
	 
		primitiveWrapperTypeMap.put(Boolean.class, boolean.class);
		primitiveWrapperTypeMap.put(Byte.class, byte.class);
		primitiveWrapperTypeMap.put(Character.class, char.class);
		primitiveWrapperTypeMap.put(Double.class, double.class);
		primitiveWrapperTypeMap.put(Float.class, float.class);
		primitiveWrapperTypeMap.put(Integer.class, int.class);
		primitiveWrapperTypeMap.put(Long.class, long.class);
		primitiveWrapperTypeMap.put(Short.class, short.class);
		Set primitiveTypeNames = new HashSet(16);
		primitiveTypeNames.addAll(primitiveWrapperTypeMap.values());
		primitiveTypeNames.addAll(Arrays.asList(new Class[] {
				boolean[].class, byte[].class, char[].class, double[].class,
				float[].class, int[].class, long[].class, short[].class}));
		for (Iterator it = primitiveTypeNames.iterator(); it.hasNext();) {
			Class primitiveClass = (Class) it.next();
			primitiveTypeNameMap.put(primitiveClass.getName(), primitiveClass);
		}
		ClassLoader cl = null;
		try {
			cl = Thread.currentThread().getContextClassLoader();
		}
		catch (Throwable ex) {
			// Cannot access thread context ClassLoader - falling back to system class loader...
		}
		if (cl == null) {
			// No thread context class loader - > use class loader of this class.
			cl = ClassUtils.class.getClassLoader();
		}
		return cl;
}

Return the default ClassLoader to use: typically the thread context ClassLoader, if available; the ClassLoader that loaded the ClassUtils class will be used as fallback.

Call this method if you intend to use the thread context ClassLoader in a scenario where you absolutely need a non-null ClassLoader reference: for example, for class path resource loading (but not necessarily for Class.forName, which accepts a null ClassLoader reference as well).

 public static String getDescriptiveType(Object value) 
{
		if (value == null) {
			return null;
		}
		Class clazz = value.getClass();
		if (Proxy.isProxyClass(clazz)) {
			StringBuffer buf = new StringBuffer(clazz.getName());
			buf.append(" implementing ");
			Class[] ifcs = clazz.getInterfaces();
			for (int i = 0; i <  ifcs.length; i++) {
				buf.append(ifcs[i].getName());
				if (i <  ifcs.length - 1) {
					buf.append(',");
				}
			}
			return buf.toString();
		}
		else if (clazz.isArray()) {
			return getQualifiedNameForArray(clazz);
		}
		else {
			return clazz.getName();
		}
}

Return a descriptive name for the given object's type: usually simply the class name, but component type class name + "[]" for arrays, and an appended list of implemented interfaces for JDK proxies.

 public static int getMethodCountForName(Class clazz,
    String methodName) 
{
		Assert.notNull(clazz, "Class must not be null");
		Assert.notNull(methodName, "Method name must not be null");
		int count = 0;
		Method[] declaredMethods = clazz.getDeclaredMethods();
		for (int i = 0; i <  declaredMethods.length; i++) {
			Method method = declaredMethods[i];
			if (methodName.equals(method.getName())) {
				count++;
			}
		}
		Class[] ifcs = clazz.getInterfaces();
		for (int i = 0; i <  ifcs.length; i++) {
			count += getMethodCountForName(ifcs[i], methodName);
		}
		if (clazz.getSuperclass() != null) {
			count += getMethodCountForName(clazz.getSuperclass(), methodName);
		}
		return count;
}

Return the number of methods with a given name (with any argument types), for the given class and/or its superclasses. Includes non-public methods.

 public static Method getMethodIfAvailable(Class clazz,
    String methodName,
    Class[] paramTypes) 
{
		Assert.notNull(clazz, "Class must not be null");
		Assert.notNull(methodName, "Method name must not be null");
		try {
			return clazz.getMethod(methodName, paramTypes);
		}
		catch (NoSuchMethodException ex) {
			return null;
		}
}

Determine whether the given class has a method with the given signature, and return it if available (else return null).

Essentially translates NoSuchMethodException to null.

 public static Method getMostSpecificMethod(Method method,
    Class targetClass) 
{
		if (method != null && targetClass != null && !targetClass.equals(method.getDeclaringClass())) {
			try {
				method = targetClass.getMethod(method.getName(), method.getParameterTypes());
			}
			catch (NoSuchMethodException ex) {
				// Perhaps the target class doesn't implement this method:
				// that's fine, just use the original method.
			}
		}
		return method;
}

Given a method, which may come from an interface, and a target class used in the current reflective invocation, find the corresponding target method if there is one. E.g. the method may be IFoo.bar() and the target class may be DefaultFoo. In this case, the method may be DefaultFoo.bar(). This enables attributes on that method to be found.

NOTE: In contrast to org.springframework.aop.support.AopUtils#getMostSpecificMethod , this method does not resolve Java 5 bridge methods automatically. Call org.springframework.core.BridgeMethodResolver#findBridgedMethod if bridge method resolution is desirable (e.g. for obtaining metadata from the original method definition).

 public static String getPackageName(Class clazz) 
{
		Assert.notNull(clazz, "Class must not be null");
		String className = clazz.getName();
		int lastDotIndex = className.lastIndexOf(PACKAGE_SEPARATOR);
		return (lastDotIndex != -1 ? className.substring(0, lastDotIndex) : "");
}

Determine the name of the package of the given class: e.g. "java.lang" for the java.lang.String class.

 public static String getQualifiedMethodName(Method method) 
{
		Assert.notNull(method, "Method must not be null");
		return method.getDeclaringClass().getName() + "." + method.getName();
}

Return the qualified name of the given method, consisting of fully qualified interface/class name + "." + method name.

 public static String getQualifiedName(Class clazz) 
{
		Assert.notNull(clazz, "Class must not be null");
		if (clazz.isArray()) {
			return getQualifiedNameForArray(clazz);
		}
		else {
			return clazz.getName();
		}
}

Return the qualified name of the given class: usually simply the class name, but component type class name + "[]" for arrays.

 public static String getShortName(String className) 
{
		Assert.hasLength(className, "Class name must not be empty");
		int lastDotIndex = className.lastIndexOf(PACKAGE_SEPARATOR);
		int nameEndIndex = className.indexOf(CGLIB_CLASS_SEPARATOR);
		if (nameEndIndex == -1) {
			nameEndIndex = className.length();
		}
		String shortName = className.substring(lastDotIndex + 1, nameEndIndex);
		shortName = shortName.replace(INNER_CLASS_SEPARATOR, PACKAGE_SEPARATOR);
		return shortName;
}

Get the class name without the qualified package name.

 public static String getShortName(Class clazz) 
{
		return getShortName(getQualifiedName(clazz));
}

Get the class name without the qualified package name.

 public static String getShortNameAsProperty(Class clazz) 
{
		String shortName = ClassUtils.getShortName(clazz);
		int dotIndex = shortName.lastIndexOf('.");
		shortName = (dotIndex != -1 ? shortName.substring(dotIndex + 1) : shortName);
		return Introspector.decapitalize(shortName);
}

Return the short string name of a Java class in decapitalized JavaBeans property format. Strips the outer class name in case of an inner class.

 public static Method getStaticMethod(Class clazz,
    String methodName,
    Class[] args) 
{
		Assert.notNull(clazz, "Class must not be null");
		Assert.notNull(methodName, "Method name must not be null");
		try {
			Method method = clazz.getDeclaredMethod(methodName, args);
			if ((method.getModifiers() & Modifier.STATIC) != 0) {
				return method;
			}
		}
		catch (NoSuchMethodException ex) {
		}
		return null;
}

Return a static method of a class.

 public static Class getUserClass(Object instance) 
{
		Assert.notNull(instance, "Instance must not be null");
		return getUserClass(instance.getClass());
}

Return the user-defined class for the given instance: usually simply the class of the given instance, but the original class in case of a CGLIB-generated subclass.

 public static Class getUserClass(Class clazz) 
{
		return (clazz != null && clazz.getName().indexOf(CGLIB_CLASS_SEPARATOR) != -1 ?
				clazz.getSuperclass() : clazz);
}

Return the user-defined class for the given class: usually simply the given class, but the original class in case of a CGLIB-generated subclass.

 public static boolean hasAtLeastOneMethodWithName(Class clazz,
    String methodName) 
{
		Assert.notNull(clazz, "Class must not be null");
		Assert.notNull(methodName, "Method name must not be null");
		Method[] declaredMethods = clazz.getDeclaredMethods();
		for (int i = 0; i <  declaredMethods.length; i++) {
			Method method = declaredMethods[i];
			if (method.getName().equals(methodName)) {
				return true;
			}
		}
		Class[] ifcs = clazz.getInterfaces();
		for (int i = 0; i <  ifcs.length; i++) {
			if (hasAtLeastOneMethodWithName(ifcs[i], methodName)) {
				return true;
			}
		}
		return (clazz.getSuperclass() != null && hasAtLeastOneMethodWithName(clazz.getSuperclass(), methodName));
}

Does the given class and/or its superclasses at least have one or more methods (with any argument types)? Includes non-public methods.

 public static boolean hasConstructor(Class clazz,
    Class[] paramTypes) 
{
		return (getConstructorIfAvailable(clazz, paramTypes) != null);
}

Determine whether the given class has a constructor with the given signature.

Essentially translates NoSuchMethodException to "false".

 public static boolean hasMethod(Class clazz,
    String methodName,
    Class[] paramTypes) 
{
		return (getMethodIfAvailable(clazz, methodName, paramTypes) != null);
}

Determine whether the given class has a method with the given signature.

Essentially translates NoSuchMethodException to "false".

 public static boolean isAssignable(Class lhsType,
    Class rhsType) 
{
		Assert.notNull(lhsType, "Left-hand side type must not be null");
		Assert.notNull(rhsType, "Right-hand side type must not be null");
		return (lhsType.isAssignableFrom(rhsType) ||
				lhsType.equals(primitiveWrapperTypeMap.get(rhsType)));
}

Check if the right-hand side type may be assigned to the left-hand side type, assuming setting by reflection. Considers primitive wrapper classes as assignable to the corresponding primitive types.

 public static boolean isAssignableValue(Class type,
    Object value) 
{
		Assert.notNull(type, "Type must not be null");
		return (value != null ? isAssignable(type, value.getClass()) : !type.isPrimitive());
}

Determine if the given type is assignable from the given value, assuming setting by reflection. Considers primitive wrapper classes as assignable to the corresponding primitive types.

 public static boolean isCacheSafe(Class clazz,
    ClassLoader classLoader) 
{
		Assert.notNull(clazz, "Class must not be null");
		ClassLoader target = clazz.getClassLoader();
		if (target == null) {
			return false;
		}
		ClassLoader cur = classLoader;
		if (cur == target) {
			return true;
		}
		while (cur != null) {
			cur = cur.getParent();
			if (cur == target) {
				return true;
			}
		}
		return false;
}

Check whether the given class is cache-safe in the given context, i.e. whether it is loaded by the given ClassLoader or a parent of it.

 public static boolean isPresent(String className) 
{
		return isPresent(className, getDefaultClassLoader());
}

Determine whether the Class identified by the supplied name is present and can be loaded. Will return false if either the class or one of its dependencies is not present or cannot be loaded.

 public static boolean isPresent(String className,
    ClassLoader classLoader) 
{
		try {
			forName(className, classLoader);
			return true;
		}
		catch (Throwable ex) {
			// Class or one of its dependencies is not present...
			return false;
		}
}

Determine whether the Class identified by the supplied name is present and can be loaded. Will return false if either the class or one of its dependencies is not present or cannot be loaded.

 public static boolean isPrimitiveArray(Class clazz) 
{
		Assert.notNull(clazz, "Class must not be null");
		return (clazz.isArray() && clazz.getComponentType().isPrimitive());
}

Check if the given class represents an array of primitives, i.e. boolean, byte, char, short, int, long, float, or double.

 public static boolean isPrimitiveOrWrapper(Class clazz) 
{
		Assert.notNull(clazz, "Class must not be null");
		return (clazz.isPrimitive() || isPrimitiveWrapper(clazz));
}

Check if the given class represents a primitive (i.e. boolean, byte, char, short, int, long, float, or double) or a primitive wrapper (i.e. Boolean, Byte, Character, Short, Integer, Long, Float, or Double).

 public static boolean isPrimitiveWrapper(Class clazz) 
{
		Assert.notNull(clazz, "Class must not be null");
		return primitiveWrapperTypeMap.containsKey(clazz);
}

Check if the given class represents a primitive wrapper, i.e. Boolean, Byte, Character, Short, Integer, Long, Float, or Double.

 public static boolean isPrimitiveWrapperArray(Class clazz) 
{
		Assert.notNull(clazz, "Class must not be null");
		return (clazz.isArray() && isPrimitiveWrapper(clazz.getComponentType()));
}

Check if the given class represents an array of primitive wrappers, i.e. Boolean, Byte, Character, Short, Integer, Long, Float, or Double.

 public static boolean isVisible(Class clazz,
    ClassLoader classLoader) 
{
		if (classLoader == null) {
			return true;
		}
		try {
			Class actualClass = classLoader.loadClass(clazz.getName());
			return (clazz == actualClass);
			// Else: different interface class found...
		}
		catch (ClassNotFoundException ex) {
			// No interface class found...
			return false;
		}
}

Check whether the given class is visible in the given ClassLoader.

 public static ClassLoader overrideThreadContextClassLoader(ClassLoader classLoaderToUse) 
{
		Thread currentThread = Thread.currentThread();
		ClassLoader threadContextClassLoader = currentThread.getContextClassLoader();
		if (classLoaderToUse != null && !classLoaderToUse.equals(threadContextClassLoader)) {
			currentThread.setContextClassLoader(classLoaderToUse);
			return threadContextClassLoader;
		}
		else {
			return null;
		}
}

Override the thread context ClassLoader with the environment's bean ClassLoader if necessary, i.e. if the bean ClassLoader is not equivalent to the thread context ClassLoader already.

 public static Class resolveClassName(String className,
    ClassLoader classLoader) throws IllegalArgumentException 
{
		try {
			return forName(className, classLoader);
		}
		catch (ClassNotFoundException ex) {
			IllegalArgumentException iae = new IllegalArgumentException("Cannot find class [" + className + "]");
			iae.initCause(ex);
			throw iae;
		}
		catch (LinkageError ex) {
			IllegalArgumentException iae = new IllegalArgumentException(
					"Error loading class [" + className + "]: problem with class file or dependent class.");
			iae.initCause(ex);
			throw iae;
		}
}

Resolve the given class name into a Class instance. Supports primitives (like "int") and array class names (like "String[]").

This is effectively equivalent to the forName method with the same arguments, with the only difference being the exceptions thrown in case of class loading failure.

 public static Class resolvePrimitiveClassName(String name) 
{
		Class result = null;
		// Most class names will be quite long, considering that they
		// SHOULD sit in a package, so a length check is worthwhile.
		if (name != null && name.length() < = 8) {
			// Could be a primitive - likely.
			result = (Class) primitiveTypeNameMap.get(name);
		}
		return result;
}

Resolve the given class name as primitive class, if appropriate, according to the JVM's naming rules for primitive classes.

Also supports the JVM's internal class names for primitive arrays. Does not support the "[]" suffix notation for primitive arrays; this is only supported by #forName .