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

## com.google.common.reflect
Class TypeToken<T>

    java.lang.Object
      com.google.common.reflect.TypeToken<T>

All Implemented Interfaces:
  Serializable

    @Beta
    public abstract class TypeToken<T>

extends Object
implements Serializable

A `Type` with generics.

Operations that are otherwise only available in `Class` are implemented to support `Type`, for example `isAssignableFrom(com.google.common.reflect.TypeToken)`, `isArray()` and `getComponentType()`. It also provides additional utilities such as `getTypes()` and `resolveType(java.lang.reflect.Type)` etc.

There are three ways to get a `TypeToken` instance:

- Wrap a `Type` obtained via reflection. For example: `TypeToken.of(method.getGenericReturnType())`.
- Capture a generic type with a (usually anonymous) subclass. For example:

         new TypeToken<List<String>>() {}

  Note that it's critical that the actual type argument is carried by a subclass. The following code is wrong because it only captures the `<T>` type variable of the `listType()` method signature; while `<String>` is lost in erasure:

         class Util {
           static <T> TypeToken<List<T>> listType() {
             return new TypeToken<List<T>>() {};
           }
         }

         TypeToken<List<String>> stringListType = Util.<String>listType();

- Capture a generic type with a (usually anonymous) subclass and resolve it against a context class that knows what the type parameters are. For example:

         abstract class IKnowMyType<T> {
           TypeToken<T> type = new TypeToken<T>(getClass()) {};
         }
         new IKnowMyType<String>() {}.type => String

`TypeToken` is serializable when no type variable is contained in the type.

Note to Guice users: `` TypeToken is similar to Guice's `TypeLiteral` class, but with one important difference: it supports non-reified types such as `T`, `List<T>` or even `List<? extends Number>`; while TypeLiteral does not. TypeToken is also serializable and offers numerous additional utility methods.

Since:
  12.0
Author:
  Bob Lee, Sven Mawson, Ben Yu
See Also:
  Serialized Form

Nested Class Summary
`class` | `TypeToken.TypeSet` The set of interfaces and classes that `T` is or is a subtype of.

Constructor Summary
`protected` | `TypeToken()` Constructs a new type token of `T`.
`protected` | `TypeToken(Class<?> declaringClass)` Constructs a new type token of `T` while resolving free type variables in the context of `declaringClass`.

Method Summary
`boolean` | `equals(Object o)` Returns true if `o` is another `TypeToken` that represents the same `Type`.
`TypeToken<?>` | `getComponentType()` Returns the array component type if this type represents an array (`int[]`, `T[]`, `<? extends Map<String, Integer>[]>` etc.), or else `null` is returned.
`Class<? super T>` | `getRawType()` Returns the raw type of `T`.
`TypeToken<? extends T>` | `getSubtype(Class<?> subclass)` Returns subtype of `this` with `subclass` as the raw class.
`TypeToken<? super T>` | `getSupertype(Class<? super T> superclass)` Returns the generic form of `superclass`.
`Type` | `getType()` Returns the represented type.
`TypeToken.TypeSet` | `getTypes()` Returns the set of interfaces and classes that this type is or is a subtype of.
`int` | `hashCode()`
`boolean` | `isArray()` Returns true if this type is known to be an array type, such as `int[]`, `T[]`, `<? extends Map<String, Integer>[]>` etc.
`boolean` | `isAssignableFrom(Type type)` Check if this type is assignable from the given `type`.
`boolean` | `isAssignableFrom(TypeToken<?> type)` Returns true if this type is assignable from the given `type`.
`static
`<T> TypeToken<T>`
` | `of(Class<T> type)` Returns an instance of type token that wraps `type`.
`static TypeToken<?>` | `of(Type type)` Returns an instance of type token that wraps `type`.
`TypeToken<?>` | `resolveType(Type type)` Resolves the given `type` against the type context represented by this type.
`String` | `toString()`
`
`<X> TypeToken<T>`
` | `where(TypeParameter<X> typeParam, Class<X> typeArg)` Returns a new `TypeToken` where type variables represented by `typeParam` are substituted by `typeArg`.
`
`<X> TypeToken<T>`
` | `where(TypeParameter<X> typeParam, TypeToken<X> typeArg)` Returns a new `TypeToken` where type variables represented by `typeParam` are substituted by `typeArg`.
`protected Object` | `writeReplace()` Implemented to support serialization of subclasses.

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

Constructor Detail

### TypeToken

    protected TypeToken()

  Constructs a new type token of `T`.

  Clients create an empty anonymous subclass. Doing so embeds the type parameter in the anonymous class's type hierarchy so we can reconstitute it at runtime despite erasure.

  For example:

         TypeToken<List<String>> t = new TypeToken<List<String>>() {};

### TypeToken

    protected TypeToken(Class<?> declaringClass)

  Constructs a new type token of `T` while resolving free type variables in the context of `declaringClass`.

  Clients create an empty anonymous subclass. Doing so embeds the type parameter in the anonymous class's type hierarchy so we can reconstitute it at runtime despite erasure.

  For example:

         abstract class IKnowMyType<T> {
           TypeToken<T> getMyType() {
             return new TypeToken<T>(getClass()) {};
           }
         }

         new IKnowMyType<String>() {}.getMyType() => String

Method Detail

### of

    public static <T> TypeToken<T> of(Class<T> type)

  Returns an instance of type token that wraps `type`.

### of

    public static TypeToken<?> of(Type type)

  Returns an instance of type token that wraps `type`.

### getRawType

    public final Class<? super T> getRawType()

  Returns the raw type of `T`. Formally speaking, if `T` is returned by `Method.getGenericReturnType()`, the raw type is what's returned by `Method.getReturnType()` of the same method object. Specifically:
  - If `T` is a `Class` itself, `T` itself is returned.
  - If `T` is a `ParameterizedType`, the raw type of the parameterized type is returned.
  - If `T` is a `GenericArrayType`, the returned type is the corresponding array class. For example: `List<Integer>[] => List[]`.
  - If `T` is a type variable or a wildcard type, the raw type of the first upper bound is returned. For example: `<X extends Foo> => Foo`.

### getType

    public final Type getType()

  Returns the represented type.

### where

    public final <X> TypeToken<T> where(TypeParameter<X> typeParam,
                                        TypeToken<X> typeArg)

  Returns a new `TypeToken` where type variables represented by `typeParam` are substituted by `typeArg`. For example, it can be used to construct `Map<K, V>` for any `K` and `V` type:

         static <K, V> TypeToken<Map<K, V>> mapOf(
             TypeToken<K> keyType, TypeToken<V> valueType) {
           return new TypeToken<Map<K, V>>() {}
               .where(new TypeParameter<K>() {}, keyType)
               .where(new TypeParameter<V>() {}, valueType);
         }

  Type Parameters:
    `X` - The parameter type
  Parameters:
    `typeParam` - the parameter type variable
    `typeArg` - the actual type to substitute

### where

    public final <X> TypeToken<T> where(TypeParameter<X> typeParam,
                                        Class<X> typeArg)

  Returns a new `TypeToken` where type variables represented by `typeParam` are substituted by `typeArg`. For example, it can be used to construct `Map<K, V>` for any `K` and `V` type:

         static <K, V> TypeToken<Map<K, V>> mapOf(
             Class<K> keyType, Class<V> valueType) {
           return new TypeToken<Map<K, V>>() {}
               .where(new TypeParameter<K>() {}, keyType)
               .where(new TypeParameter<V>() {}, valueType);
         }

  Type Parameters:
    `X` - The parameter type
  Parameters:
    `typeParam` - the parameter type variable
    `typeArg` - the actual type to substitute

### resolveType

    public final TypeToken<?> resolveType(Type type)

  Resolves the given `type` against the type context represented by this type. For example:

         new TypeToken<List<String>>() {}.resolveType(
             List.class.getMethod("get", int.class).getGenericReturnType())
         => String.class

### getTypes

    public final TypeToken.TypeSet getTypes()

  Returns the set of interfaces and classes that this type is or is a subtype of. The returned types are parameterized with proper type arguments.

  Subtypes are always listed before supertypes. But the reverse is not true. A type isn't necessarily a subtype of all the types following. Order between types without subtype relationship is arbitrary and not guaranteed.

  If this type is a type variable or wildcard, upper bounds that are themselves type variables aren't included (their super interfaces and superclasses are).

### getSupertype

    public final TypeToken<? super T> getSupertype(Class<? super T> superclass)

  Returns the generic form of `superclass`. For example, if this is `ArrayList<String>`, `Iterable<String>` is returned given the input `Iterable.class`.

### getSubtype

    public final TypeToken<? extends T> getSubtype(Class<?> subclass)

  Returns subtype of `this` with `subclass` as the raw class. For example, if this is `Iterable<String>` and `subclass` is `List`, `List<String>` is returned.

### isAssignableFrom

    public final boolean isAssignableFrom(TypeToken<?> type)

  Returns true if this type is assignable from the given `type`.

### isAssignableFrom

    public final boolean isAssignableFrom(Type type)

  Check if this type is assignable from the given `type`.

### isArray

    public final boolean isArray()

  Returns true if this type is known to be an array type, such as `int[]`, `T[]`, `<? extends Map<String, Integer>[]>` etc.

### getComponentType

    @Nullable
    public final TypeToken<?> getComponentType()

  Returns the array component type if this type represents an array (`int[]`, `T[]`, `<? extends Map<String, Integer>[]>` etc.), or else `null` is returned.

### equals

    public boolean equals(@Nullable
                          Object o)

  Returns true if `o` is another `TypeToken` that represents the same `Type`.

  Overrides:
    `equals` in class `Object`

### hashCode

    public int hashCode()

  Overrides:
    `hashCode` in class `Object`

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`

### writeReplace

    protected Object writeReplace()

  Implemented to support serialization of subclasses.

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 © 2010-2012. All Rights Reserved.