Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.apache.commons.lang
Class ClassUtils

    java.lang.Object
      org.apache.commons.lang.ClassUtils

    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`.

Since:
  2.0
Version:
  $Id: ClassUtils.java 907121 2010-02-05 22:53:21Z mbenson $
Author:
  Apache Software Foundation, Gary Gregory, Norm Deane, Alban Peignier, Tomasz Blachowicz

Field Summary
`static String` | `INNER_CLASS_SEPARATOR` The inner class separator String: `"$"`.
`static char` | `INNER_CLASS_SEPARATOR_CHAR` The inner class separator character: `'$' == 36`.
`static String` | `PACKAGE_SEPARATOR` The package separator String: `"."`.
`static char` | `PACKAGE_SEPARATOR_CHAR` The package separator character: `'.' == 46`.

Constructor Summary
`ClassUtils()` ClassUtils instances should NOT be constructed in standard programming.

Method Summary
`static List` | `convertClassesToClassNames(List classes)` Given a `List` of `Class` objects, this method converts them into class names.
`static List` | `convertClassNamesToClasses(List classNames)` Given a `List` of class names, this method converts them into classes.
`static List` | `getAllInterfaces(Class cls)` Gets a `List` of all interfaces implemented by the given class and its superclasses.
`static List` | `getAllSuperclasses(Class cls)` Gets a `List` of superclasses for the given class.
`static Class` | `getClass(ClassLoader classLoader, String className)` Returns the (initialized) class represented by `className` using the `classLoader`.
`static Class` | `getClass(ClassLoader classLoader, String className, boolean initialize)` Returns the class represented by `className` using the `classLoader`.
`static Class` | `getClass(String className)` Returns the (initialized) class represented by `className` using the current thread's context class loader.
`static Class` | `getClass(String className, boolean initialize)` Returns the class represented by `className` using 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 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 `Class` can be assigned to a variable of another `Class`.
`static boolean` | `isAssignable(Class cls, Class toClass, boolean autoboxing)` Checks if one `Class` can be assigned to a variable of another `Class`.
`static boolean` | `isInnerClass(Class cls)` Is the specified class an inner class or static nested class.
`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 `Object` in to an array of `Class` objects.
`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.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### PACKAGE_SEPARATOR_CHAR

    public static final char PACKAGE_SEPARATOR_CHAR

  The package separator character: `'.' == 46`.

  See Also:
    Constant Field Values

### PACKAGE_SEPARATOR

    public static final String PACKAGE_SEPARATOR

  The package separator String: `"."`.

### INNER_CLASS_SEPARATOR_CHAR

    public static final char INNER_CLASS_SEPARATOR_CHAR

  The inner class separator character: `'$' == 36`.

  See Also:
    Constant Field Values

### INNER_CLASS_SEPARATOR

    public static final String INNER_CLASS_SEPARATOR

  The inner class separator String: `"$"`.

Constructor Detail

### ClassUtils

    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.

Method Detail

### getShortClassName

    public static String getShortClassName(Object object,
                                           String valueIfNull)

  Gets the class name minus the package name for an `Object`.

  Parameters:
    `object` - the class to get the short name for, may be null
    `valueIfNull` - the value to return if null
  Returns:
    the class name of the object without the package name, or the null value

### getShortClassName

    public static String getShortClassName(Class cls)

  Gets the class name minus the package name from a `Class`.

  Parameters:
    `cls` - the class to get the short name for.
  Returns:
    the class name without the package name or an empty string

### getShortClassName

    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.

  Parameters:
    `className` - the className to get the short name for
  Returns:
    the class name of the class without the package name or an empty string

### getPackageName

    public static String getPackageName(Object object,
                                        String valueIfNull)

  Gets the package name of an `Object`.

  Parameters:
    `object` - the class to get the package name for, may be null
    `valueIfNull` - the value to return if null
  Returns:
    the package name of the object, or the null value

### getPackageName

    public static String getPackageName(Class cls)

  Gets the package name of a `Class`.

  Parameters:
    `cls` - the class to get the package name for, may be `null`.
  Returns:
    the package name or an empty string

### getPackageName

    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.

  Parameters:
    `className` - the className to get the package name for, may be `null`
  Returns:
    the package name or an empty string

### getAllSuperclasses

    public static List getAllSuperclasses(Class cls)

  Gets a `List` of superclasses for the given class.

  Parameters:
    `cls` - the class to look up, may be `null`
  Returns:
    the `List` of superclasses in order going up from this one `null` if null input

### getAllInterfaces

    public static List 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.

  Parameters:
    `cls` - the class to look up, may be `null`
  Returns:
    the `List` of interfaces in order, `null` if null input

### convertClassNamesToClasses

    public static List convertClassNamesToClasses(List 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`.

  Parameters:
    `classNames` - the classNames to change
  Returns:
    a `List` of Class objects corresponding to the class names, `null` if null input
  Throws:
    `ClassCastException` - if classNames contains a non String entry

### convertClassesToClassNames

    public static List convertClassesToClassNames(List 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`.

  Parameters:
    `classes` - the classes to change
  Returns:
    a `List` of class names corresponding to the Class objects, `null` if null input
  Throws:
    `ClassCastException` - if `classes` contains a non-`Class` entry

### isAssignable

    public 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 `null`s.

  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.

  Parameters:
    `classArray` - the array of Classes to check, may be `null`
    `toClassArray` - the array of Classes to try to assign into, may be `null`
  Returns:
    `true` if assignment possible

### isAssignable

    public 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 `null`s.

  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.

  Parameters:
    `classArray` - the array of Classes to check, may be `null`
    `toClassArray` - the array of Classes to try to assign into, may be `null`
    `autoboxing` - whether to use implicit autoboxing/unboxing between primitives and wrappers
  Returns:
    `true` if assignment possible
  Since:
    2.5

### isAssignable

    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 `null`s.

  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.

  Parameters:
    `cls` - the Class to check, may be null
    `toClass` - the Class to try to assign into, returns false if null
  Returns:
    `true` if assignment possible

### isAssignable

    public 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 `null`s.

  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.

  Parameters:
    `cls` - the Class to check, may be null
    `toClass` - the Class to try to assign into, returns false if null
    `autoboxing` - whether to use implicit autoboxing/unboxing between primitives and wrappers
  Returns:
    `true` if assignment possible
  Since:
    2.5

### primitiveToWrapper

    public 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`.

  Parameters:
    `cls` - the class to convert, may be null
  Returns:
    the wrapper class for `cls` or `cls` if `cls` is not a primitive. `null` if null input.
  Since:
    2.1

### primitivesToWrappers

    public static Class[] primitivesToWrappers(Class[] classes)

  Converts the specified array of primitive Class objects to an array of its corresponding wrapper Class objects.

  Parameters:
    `classes` - the class array to convert, may be null or empty
  Returns:
    an array which contains for each given class, the wrapper class or the original class if class is not a primitive. `null` if null input. Empty array if an empty array passed in.
  Since:
    2.1

### wrapperToPrimitive

    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.

  Parameters:
    `cls` - the class to convert, may be null
  Returns:
    the corresponding primitive type if `cls` is a wrapper class, null otherwise
  Since:
    2.4
  See Also:
    `primitiveToWrapper(Class)`

### wrappersToPrimitives

    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.

  Parameters:
    `classes` - the class array to convert, may be null or empty
  Returns:
    an array which contains for each given class, the primitive class or null if the original class is not a wrapper class. `null` if null input. Empty array if an empty array passed in.
  Since:
    2.4
  See Also:
    `wrapperToPrimitive(Class)`

### isInnerClass

    public static boolean isInnerClass(Class cls)

  Is the specified class an inner class or static nested class.

  Parameters:
    `cls` - the class to check, may be null
  Returns:
    `true` if the class is an inner or static nested class, false if not or `null`

### getClass

    public static Class getClass(ClassLoader classLoader,
                                 String className,
                                 boolean initialize)
                          throws ClassNotFoundException

  Returns the class represented by `className` using the `classLoader`. This implementation supports names like "`java.lang.String[]`" as well as "`[Ljava.lang.String;`".

  Parameters:
    `classLoader` - the class loader to use to load the class
    `className` - the class name
    `initialize` - whether the class must be initialized
  Returns:
    the class represented by `className` using the `classLoader`
  Throws:
    `ClassNotFoundException` - if the class is not found

### getClass

    public static Class getClass(ClassLoader classLoader,
                                 String className)
                          throws ClassNotFoundException

  Returns the (initialized) class represented by `className` using the `classLoader`. This implementation supports names like "`java.lang.String[]`" as well as "`[Ljava.lang.String;`".

  Parameters:
    `classLoader` - the class loader to use to load the class
    `className` - the class name
  Returns:
    the class represented by `className` using the `classLoader`
  Throws:
    `ClassNotFoundException` - if the class is not found

### getClass

    public static Class getClass(String className)
                          throws ClassNotFoundException

  Returns the (initialized) class represented by `className` using the current thread's context class loader. This implementation supports names like "`java.lang.String[]`" as well as "`[Ljava.lang.String;`".

  Parameters:
    `className` - the class name
  Returns:
    the class represented by `className` using the current thread's context class loader
  Throws:
    `ClassNotFoundException` - if the class is not found

### getClass

    public static Class getClass(String className,
                                 boolean initialize)
                          throws ClassNotFoundException

  Returns the class represented by `className` using the current thread's context class loader. This implementation supports names like "`java.lang.String[]`" as well as "`[Ljava.lang.String;`".

  Parameters:
    `className` - the class name
    `initialize` - whether the class must be initialized
  Returns:
    the class represented by `className` using the current thread's context class loader
  Throws:
    `ClassNotFoundException` - if the class is not found

### getPublicMethod

    public 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[]);

  Parameters:
    `cls` - the class to check, not null
    `methodName` - the name of the method
    `parameterTypes` - the list of parameters
  Returns:
    the method
  Throws:
    `NullPointerException` - if the class is null
    `SecurityException` - if a a security violation occured
    `NoSuchMethodException` - if the method is not found in the given class or if the metothod doen't conform with the requirements

### toClass

    public 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.

  Parameters:
    `array` - an `Object` array
  Returns:
    a `Class` array, `null` if null array input
  Since:
    2.4

### getShortCanonicalName

    public static String getShortCanonicalName(Object object,
                                               String valueIfNull)

  Gets the canonical name minus the package name for an `Object`.

  Parameters:
    `object` - the class to get the short name for, may be null
    `valueIfNull` - the value to return if null
  Returns:
    the canonical name of the object without the package name, or the null value
  Since:
    2.4

### getShortCanonicalName

    public static String getShortCanonicalName(Class cls)

  Gets the canonical name minus the package name from a `Class`.

  Parameters:
    `cls` - the class to get the short name for.
  Returns:
    the canonical name without the package name or an empty string
  Since:
    2.4

### getShortCanonicalName

    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.

  Parameters:
    `canonicalName` - the class name to get the short name for
  Returns:
    the canonical name of the class without the package name or an empty string
  Since:
    2.4

### getPackageCanonicalName

    public static String getPackageCanonicalName(Object object,
                                                 String valueIfNull)

  Gets the package name from the canonical name of an `Object`.

  Parameters:
    `object` - the class to get the package name for, may be null
    `valueIfNull` - the value to return if null
  Returns:
    the package name of the object, or the null value
  Since:
    2.4

### getPackageCanonicalName

    public static String getPackageCanonicalName(Class cls)

  Gets the package name from the canonical name of a `Class`.

  Parameters:
    `cls` - the class to get the package name for, may be `null`.
  Returns:
    the package name or an empty string
  Since:
    2.4

### getPackageCanonicalName

    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.

  Parameters:
    `canonicalName` - the canonical name to get the package name for, may be `null`
  Returns:
    the package name or an empty string
  Since:
    2.4

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2001-2010 The Apache Software Foundation. All Rights Reserved.