public class ClassUtils extends Object
Operates on classes without using reflection.
This class handles invalid null inputs as best it can.
 Each method documents its behaviour in more detail.
The notion of a canonical name includes the human
 readable name for the type, for example int[]. The
 non-canonical method variants work with the JVM names, such as
 [I. 
| Modifier and Type | Class and Description | 
|---|---|
| static class  | ClassUtils.InterfacesInclusivity literals for  hierarchy(Class, Interfaces). | 
| Modifier and Type | Field and Description | 
|---|---|
| static String | INNER_CLASS_SEPARATORThe inner class separator String:  "$". | 
| static char | INNER_CLASS_SEPARATOR_CHARThe inner class separator character:  '$' == 36. | 
| static String | PACKAGE_SEPARATORThe package separator String:  ".". | 
| static char | PACKAGE_SEPARATOR_CHARThe package separator character:  '.' == 46. | 
| Constructor and Description | 
|---|
| ClassUtils()ClassUtils instances should NOT be constructed in standard programming. | 
| Modifier and Type | Method and Description | 
|---|---|
| static List<String> | convertClassesToClassNames(List<Class<?>> classes)Given a  ListofClassobjects, this method converts
 them into class names. | 
| static List<Class<?>> | convertClassNamesToClasses(List<String> classNames)Given a  Listof class names, this method converts them into classes. | 
| static String | getAbbreviatedName(Class<?> cls,
                  int len)Gets the abbreviated name of a  Class. | 
| static String | getAbbreviatedName(String className,
                  int len)Gets the abbreviated class name from a  String. | 
| static List<Class<?>> | getAllInterfaces(Class<?> cls)Gets a  Listof all interfaces implemented by the given
 class and its superclasses. | 
| static List<Class<?>> | getAllSuperclasses(Class<?> cls)Gets a  Listof superclasses for the given class. | 
| static Class<?> | getClass(ClassLoader classLoader,
        String className)Returns the (initialized) class represented by  classNameusing theclassLoader. | 
| static Class<?> | getClass(ClassLoader classLoader,
        String className,
        boolean initialize)Returns the class represented by  classNameusing theclassLoader. | 
| static Class<?> | getClass(String className)Returns the (initialized) class represented by  classNameusing the current thread's context class loader. | 
| static Class<?> | getClass(String className,
        boolean initialize)Returns the class represented by  classNameusing the
 current thread's context class loader. | 
| static String | getPackageCanonicalName(Class<?> cls)Gets the package name from the canonical name of a  Class. | 
| static String | getPackageCanonicalName(Object object,
                       String valueIfNull)Gets the package name from the canonical name of an  Object. | 
| static String | getPackageCanonicalName(String canonicalName)Gets the package name from the canonical name. | 
| static String | getPackageName(Class<?> cls)Gets the package name of a  Class. | 
| static String | getPackageName(Object object,
              String valueIfNull)Gets the package name of an  Object. | 
| static String | getPackageName(String className)Gets the package name from a  String. | 
| static Method | getPublicMethod(Class<?> cls,
               String methodName,
               Class<?>... parameterTypes)Returns the desired Method much like  Class.getMethod, however
 it ensures that the returned Method is from a public class or interface and not
 from an anonymous inner class. | 
| static String | getShortCanonicalName(Class<?> cls)Gets the canonical name minus the package name from a  Class. | 
| static String | getShortCanonicalName(Object object,
                     String valueIfNull)Gets the canonical name minus the package name for an  Object. | 
| static String | getShortCanonicalName(String canonicalName)Gets the canonical name minus the package name from a String. | 
| static String | getShortClassName(Class<?> cls)Gets the class name minus the package name from a  Class. | 
| static String | getShortClassName(Object object,
                 String valueIfNull)Gets the class name minus the package name for an  Object. | 
| static String | getShortClassName(String className)Gets the class name minus the package name from a String. | 
| static String | getSimpleName(Class<?> cls)Null-safe version of  aClass.getSimpleName() | 
| static String | getSimpleName(Object object,
             String valueIfNull)Null-safe version of  aClass.getSimpleName() | 
| static Iterable<Class<?>> | hierarchy(Class<?> type)Get an  Iterablethat can iterate over a class hierarchy in ascending (subclass to superclass) order,
 excluding interfaces. | 
| static Iterable<Class<?>> | hierarchy(Class<?> type,
         ClassUtils.Interfaces interfacesBehavior)Get an  Iterablethat can iterate over a class hierarchy in ascending (subclass to superclass) order. | 
| static boolean | isAssignable(Class<?>[] classArray,
            Class<?>... toClassArray)Checks if an array of Classes can be assigned to another array of Classes. | 
| static boolean | isAssignable(Class<?>[] classArray,
            Class<?>[] toClassArray,
            boolean autoboxing)Checks if an array of Classes can be assigned to another array of Classes. | 
| static boolean | isAssignable(Class<?> cls,
            Class<?> toClass)Checks if one  Classcan be assigned to a variable of
 anotherClass. | 
| static boolean | isAssignable(Class<?> cls,
            Class<?> toClass,
            boolean autoboxing)Checks if one  Classcan be assigned to a variable of
 anotherClass. | 
| static boolean | isInnerClass(Class<?> cls)Is the specified class an inner class or static nested class. | 
| static boolean | isPrimitiveOrWrapper(Class<?> type) | 
| static boolean | isPrimitiveWrapper(Class<?> type) | 
| static Class<?>[] | primitivesToWrappers(Class<?>... classes)Converts the specified array of primitive Class objects to an array of
 its corresponding wrapper Class objects. | 
| static Class<?> | primitiveToWrapper(Class<?> cls)Converts the specified primitive Class object to its corresponding
 wrapper Class object. | 
| static Class<?>[] | toClass(Object... array)Converts an array of  Objectin to an array ofClassobjects. | 
| static Class<?>[] | wrappersToPrimitives(Class<?>... classes)Converts the specified array of wrapper Class objects to an array of
 its corresponding primitive Class objects. | 
| static Class<?> | wrapperToPrimitive(Class<?> cls)Converts the specified wrapper class to its corresponding primitive
 class. | 
public static final char PACKAGE_SEPARATOR_CHAR
'.' == 46.public static final String PACKAGE_SEPARATOR
".".public static final char INNER_CLASS_SEPARATOR_CHAR
'$' == 36.public static final String INNER_CLASS_SEPARATOR
"$".public ClassUtils()
ClassUtils instances should NOT be constructed in standard programming.
 Instead, the class should be used as
 ClassUtils.getShortClassName(cls).
This constructor is public to permit tools that require a JavaBean instance to operate.
public static String getShortClassName(Object object, String valueIfNull)
Gets the class name minus the package name for an Object.
object - the class to get the short name for, may be nullvalueIfNull - the value to return if nullpublic static String getShortClassName(Class<?> cls)
Gets the class name minus the package name from a Class.
Consider using the Java 5 API Class.getSimpleName() instead.
 The one known difference is that this code will return "Map.Entry" while
 the java.lang.Class variant will simply return "Entry". 
cls - the class to get the short name for.public static String getShortClassName(String className)
Gets the class name minus the package name from a String.
The string passed in is assumed to be a class name - it is not checked.
Note that this method differs from Class.getSimpleName() in that this will
 return "Map.Entry" whilst the java.lang.Class variant will simply
 return "Entry". 
className - the className to get the short name forpublic static String getSimpleName(Class<?> cls)
Null-safe version of aClass.getSimpleName()
cls - the class for which to get the simple name.Class.getSimpleName()public static String getSimpleName(Object object, String valueIfNull)
Null-safe version of aClass.getSimpleName()
object - the object for which to get the simple class name.valueIfNull - the value to return if object is nullClass.getSimpleName()public static String getPackageName(Object object, String valueIfNull)
Gets the package name of an Object.
object - the class to get the package name for, may be nullvalueIfNull - the value to return if nullpublic static String getPackageName(Class<?> cls)
Gets the package name of a Class.
cls - the class to get the package name for, may be null.public static String getPackageName(String className)
Gets the package name from a String.
The string passed in is assumed to be a class name - it is not checked.
If the class is unpackaged, return an empty string.
className - the className to get the package name for, may be nullpublic static String getAbbreviatedName(Class<?> cls, int len)
Gets the abbreviated name of a Class.
cls - the class to get the abbreviated name for, may be nulllen - the desired length of the abbreviated nameIllegalArgumentException - if len <= 0getAbbreviatedName(String, int)public static String getAbbreviatedName(String className, int len)
Gets the abbreviated class name from a String.
The string passed in is assumed to be a class name - it is not checked.
The abbreviation algorithm will shorten the class name, usually without significant loss of meaning.
The abbreviated class name will always include the complete package hierarchy. If enough space is available, rightmost sub-packages will be displayed in full length.
The following table illustrates the algorithm:
| className | len | return | 
| null | 1 | "" | 
| "java.lang.String" | 5 | "j.l.String" | 
| "java.lang.String" | 15 | "j.lang.String" | 
| "java.lang.String" | 30 | "java.lang.String" | 
className - the className to get the abbreviated name for, may be nulllen - the desired length of the abbreviated nameIllegalArgumentException - if len <= 0public static List<Class<?>> getAllSuperclasses(Class<?> cls)
Gets a List of superclasses for the given class.
cls - the class to look up, may be nullList of superclasses in order going up from this one
  null if null inputpublic static List<Class<?>> getAllInterfaces(Class<?> cls)
Gets a List of all interfaces implemented by the given
 class and its superclasses.
The order is determined by looking through each interface in turn as declared in the source file and following its hierarchy up. Then each superclass is considered in the same way. Later duplicates are ignored, so the order is maintained.
cls - the class to look up, may be nullList of interfaces in order,
  null if null inputpublic static List<Class<?>> convertClassNamesToClasses(List<String> classNames)
Given a List of class names, this method converts them into classes.
A new List is returned. If the class name cannot be found, null
 is stored in the List. If the class name in the List is
 null, null is stored in the output List.
classNames - the classNames to changeList of Class objects corresponding to the class names,
  null if null inputClassCastException - if classNames contains a non String entrypublic static List<String> convertClassesToClassNames(List<Class<?>> classes)
Given a List of Class objects, this method converts
 them into class names.
A new List is returned. null objects will be copied into
 the returned list as null.
classes - the classes to changeList of class names corresponding to the Class objects,
  null if null inputClassCastException - if classes contains a non-Class entrypublic static boolean isAssignable(Class<?>[] classArray, Class<?>... toClassArray)
Checks if an array of Classes can be assigned to another array of Classes.
This method calls isAssignable for each
 Class pair in the input arrays. It can be used to check if a set of arguments
 (the first parameter) are suitably compatible with a set of method parameter types
 (the second parameter).
Unlike the Class.isAssignableFrom(java.lang.Class) method, this
 method takes into account widenings of primitive classes and
 nulls.
Primitive widenings allow an int to be assigned to a long,
 float or double. This method returns the correct
 result for these cases.
Null may be assigned to any reference type. This method will
 return true if null is passed in and the toClass is
 non-primitive.
Specifically, this method tests whether the type represented by the
 specified Class parameter can be converted to the type
 represented by this Class object via an identity conversion
 widening primitive or widening reference conversion. See
 The Java Language Specification,
 sections 5.1.1, 5.1.2 and 5.1.4 for details.
Since Lang 3.0, this method will default behavior for calculating assignability between primitive and wrapper types corresponding to the running Java version; i.e. autoboxing will be the default behavior in VMs running Java versions > 1.5.
classArray - the array of Classes to check, may be nulltoClassArray - the array of Classes to try to assign into, may be nulltrue if assignment possiblepublic static boolean isAssignable(Class<?>[] classArray, Class<?>[] toClassArray, boolean autoboxing)
Checks if an array of Classes can be assigned to another array of Classes.
This method calls isAssignable for each
 Class pair in the input arrays. It can be used to check if a set of arguments
 (the first parameter) are suitably compatible with a set of method parameter types
 (the second parameter).
Unlike the Class.isAssignableFrom(java.lang.Class) method, this
 method takes into account widenings of primitive classes and
 nulls.
Primitive widenings allow an int to be assigned to a long,
 float or double. This method returns the correct
 result for these cases.
Null may be assigned to any reference type. This method will
 return true if null is passed in and the toClass is
 non-primitive.
Specifically, this method tests whether the type represented by the
 specified Class parameter can be converted to the type
 represented by this Class object via an identity conversion
 widening primitive or widening reference conversion. See
 The Java Language Specification,
 sections 5.1.1, 5.1.2 and 5.1.4 for details.
classArray - the array of Classes to check, may be nulltoClassArray - the array of Classes to try to assign into, may be nullautoboxing - whether to use implicit autoboxing/unboxing between primitives and wrapperstrue if assignment possiblepublic static boolean isPrimitiveOrWrapper(Class<?> type)
public static boolean isPrimitiveWrapper(Class<?> type)
public static boolean isAssignable(Class<?> cls, Class<?> toClass)
Checks if one Class can be assigned to a variable of
 another Class.
Unlike the Class.isAssignableFrom(java.lang.Class) method,
 this method takes into account widenings of primitive classes and
 nulls.
Primitive widenings allow an int to be assigned to a long, float or double. This method returns the correct result for these cases.
Null may be assigned to any reference type. This method
 will return true if null is passed in and the
 toClass is non-primitive.
Specifically, this method tests whether the type represented by the
 specified Class parameter can be converted to the type
 represented by this Class object via an identity conversion
 widening primitive or widening reference conversion. See
 The Java Language Specification,
 sections 5.1.1, 5.1.2 and 5.1.4 for details.
Since Lang 3.0, this method will default behavior for calculating assignability between primitive and wrapper types corresponding to the running Java version; i.e. autoboxing will be the default behavior in VMs running Java versions > 1.5.
cls - the Class to check, may be nulltoClass - the Class to try to assign into, returns false if nulltrue if assignment possiblepublic static boolean isAssignable(Class<?> cls, Class<?> toClass, boolean autoboxing)
Checks if one Class can be assigned to a variable of
 another Class.
Unlike the Class.isAssignableFrom(java.lang.Class) method,
 this method takes into account widenings of primitive classes and
 nulls.
Primitive widenings allow an int to be assigned to a long, float or double. This method returns the correct result for these cases.
Null may be assigned to any reference type. This method
 will return true if null is passed in and the
 toClass is non-primitive.
Specifically, this method tests whether the type represented by the
 specified Class parameter can be converted to the type
 represented by this Class object via an identity conversion
 widening primitive or widening reference conversion. See
 The Java Language Specification,
 sections 5.1.1, 5.1.2 and 5.1.4 for details.
cls - the Class to check, may be nulltoClass - the Class to try to assign into, returns false if nullautoboxing - whether to use implicit autoboxing/unboxing between primitives and wrapperstrue if assignment possiblepublic static Class<?> primitiveToWrapper(Class<?> cls)
Converts the specified primitive Class object to its corresponding wrapper Class object.
NOTE: From v2.2, this method handles Void.TYPE,
 returning Void.TYPE.
cls - the class to convert, may be nullcls or cls if
 cls is not a primitive. null if null input.public static Class<?>[] primitivesToWrappers(Class<?>... classes)
Converts the specified array of primitive Class objects to an array of its corresponding wrapper Class objects.
classes - the class array to convert, may be null or emptynull if null input.
 Empty array if an empty array passed in.public static Class<?> wrapperToPrimitive(Class<?> cls)
Converts the specified wrapper class to its corresponding primitive class.
This method is the counter part of primitiveToWrapper().
 If the passed in class is a wrapper class for a primitive type, this
 primitive type will be returned (e.g. Integer.TYPE for
 Integer.class). For other classes, or if the parameter is
 null, the return value is null.
cls - the class to convert, may be nullcls is a
 wrapper class, null otherwiseprimitiveToWrapper(Class)public static Class<?>[] wrappersToPrimitives(Class<?>... classes)
Converts the specified array of wrapper Class objects to an array of its corresponding primitive Class objects.
This method invokes wrapperToPrimitive() for each element
 of the passed in array.
classes - the class array to convert, may be null or emptynull if null input.
 Empty array if an empty array passed in.wrapperToPrimitive(Class)public static boolean isInnerClass(Class<?> cls)
Is the specified class an inner class or static nested class.
cls - the class to check, may be nulltrue if the class is an inner or static nested class,
  false if not or nullpublic static Class<?> getClass(ClassLoader classLoader, String className, boolean initialize) throws ClassNotFoundException
className using the
 classLoader.  This implementation supports the syntaxes
 "java.util.Map.Entry[]", "java.util.Map$Entry[]",
 "[Ljava.util.Map.Entry;", and "[Ljava.util.Map$Entry;".classLoader - the class loader to use to load the classclassName - the class nameinitialize - whether the class must be initializedclassName using the classLoaderClassNotFoundException - if the class is not foundpublic static Class<?> getClass(ClassLoader classLoader, String className) throws ClassNotFoundException
className
 using the classLoader.  This implementation supports
 the syntaxes "java.util.Map.Entry[]",
 "java.util.Map$Entry[]", "[Ljava.util.Map.Entry;",
 and "[Ljava.util.Map$Entry;".classLoader - the class loader to use to load the classclassName - the class nameclassName using the classLoaderClassNotFoundException - if the class is not foundpublic static Class<?> getClass(String className) throws ClassNotFoundException
className
 using the current thread's context class loader. This implementation
 supports the syntaxes "java.util.Map.Entry[]",
 "java.util.Map$Entry[]", "[Ljava.util.Map.Entry;",
 and "[Ljava.util.Map$Entry;".className - the class nameclassName using the current thread's context class loaderClassNotFoundException - if the class is not foundpublic static Class<?> getClass(String className, boolean initialize) throws ClassNotFoundException
className using the
 current thread's context class loader. This implementation supports the
 syntaxes "java.util.Map.Entry[]", "java.util.Map$Entry[]",
 "[Ljava.util.Map.Entry;", and "[Ljava.util.Map$Entry;".className - the class nameinitialize - whether the class must be initializedclassName using the current thread's context class loaderClassNotFoundException - if the class is not foundpublic static Method getPublicMethod(Class<?> cls, String methodName, Class<?>... parameterTypes) throws SecurityException, NoSuchMethodException
Returns the desired Method much like Class.getMethod, however
 it ensures that the returned Method is from a public class or interface and not
 from an anonymous inner class. This means that the Method is invokable and
 doesn't fall foul of Java bug
 4071957).
  Set set = Collections.unmodifiableSet(...);
  Method method = ClassUtils.getPublicMethod(set.getClass(), "isEmpty",  new Class[0]);
  Object result = method.invoke(set, new Object[]);
  cls - the class to check, not nullmethodName - the name of the methodparameterTypes - the list of parametersNullPointerException - if the class is nullSecurityException - if a security violation occurredNoSuchMethodException - if the method is not found in the given class
  or if the method doesn't conform with the requirementspublic static Class<?>[] toClass(Object... array)
Converts an array of Object in to an array of Class objects.
 If any of these objects is null, a null element will be inserted into the array.
This method returns null for a null input array.
array - an Object arrayClass array, null if null array inputpublic static String getShortCanonicalName(Object object, String valueIfNull)
Gets the canonical name minus the package name for an Object.
object - the class to get the short name for, may be nullvalueIfNull - the value to return if nullpublic static String getShortCanonicalName(Class<?> cls)
Gets the canonical name minus the package name from a Class.
cls - the class to get the short name for.public static String getShortCanonicalName(String canonicalName)
Gets the canonical name minus the package name from a String.
The string passed in is assumed to be a canonical name - it is not checked.
canonicalName - the class name to get the short name forpublic static String getPackageCanonicalName(Object object, String valueIfNull)
Gets the package name from the canonical name of an Object.
object - the class to get the package name for, may be nullvalueIfNull - the value to return if nullpublic static String getPackageCanonicalName(Class<?> cls)
Gets the package name from the canonical name of a Class.
cls - the class to get the package name for, may be null.public static String getPackageCanonicalName(String canonicalName)
Gets the package name from the canonical name.
The string passed in is assumed to be a canonical name - it is not checked.
If the class is unpackaged, return an empty string.
canonicalName - the canonical name to get the package name for, may be nullpublic static Iterable<Class<?>> hierarchy(Class<?> type)
Iterable that can iterate over a class hierarchy in ascending (subclass to superclass) order,
 excluding interfaces.type - the type to get the class hierarchy frompublic static Iterable<Class<?>> hierarchy(Class<?> type, ClassUtils.Interfaces interfacesBehavior)
Iterable that can iterate over a class hierarchy in ascending (subclass to superclass) order.type - the type to get the class hierarchy frominterfacesBehavior - switch indicating whether to include or exclude interfacesCopyright © 2001–2016 The Apache Software Foundation. All rights reserved.