# Type Token

```
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
```

### Problem That TypeToken solves

```java
// Consider these two lists
List<String> stringList = new ArrayList<>();
List<Integer> integerList = new ArrayList<>();

// At runtime, due to type erasure, Java sees both as just List
// This means we can't directly tell Gson what type to deserialize to

// with the help of TypeToken we tell Gson about type of data in process of ser and desr.

// Creating a TypeToken for a List of Strings
Type listType = new TypeToken<List<String>>(){}.getType();

// Using it with Gson
List<String> strings = gson.fromJson(jsonString, listType);
```

### Different Ways to Use TypeToken

1. **Simple Generic Types**

```java
// For List<String>
Type stringListType = new TypeToken<List<String>>(){}.getType();

// For Set<Integer>
Type integerSetType = new TypeToken<Set<Integer>>(){}.getType();

// For Map<String, Boolean>
Type mapType = new TypeToken<Map<String, Boolean>>(){}.getType();
```

2. **Nested Generic Types**

```java
// For List<List<String>>
Type nestedListType = new TypeToken<List<List<String>>>(){}.getType();

// For Map<String, List<User>>
Type complexMapType = new TypeToken<Map<String, List<User>>>(){}.getType();
```

3. **Custom Generic Classes**

```java
// Generic response wrapper
public class ApiResponse<T> {
    private int status;
    private T data;
    // getters and setters
}

// Usage
Type responseType = new TypeToken<ApiResponse<User>>(){}.getType();
ApiResponse<User> response = gson.fromJson(json, responseType);
```

### Creating Reusable TypeTokens

```java
public class TypeTokens {
    // Private constructor to prevent instantiation
    private TypeTokens() {}
    
    // Reusable TypeToken for List<String>
    public static final Type STRING_LIST_TYPE = new TypeToken<List<String>>(){}.getType();
    
    // Reusable TypeToken for Map<String, User>
    public static final Type STRING_USER_MAP_TYPE = new TypeToken<Map<String, User>>(){}.getType();
}

// Usage
List<String> strings = gson.fromJson(json, TypeTokens.STRING_LIST_TYPE);
```

### Advanced Usage with Parameterized Types

```java
public class GenericTypeHandler<T> {
    private final Type type;

    public GenericTypeHandler() {
        // Capture the actual type parameter
        Type superclass = getClass().getGenericSuperclass();
        if (superclass instanceof ParameterizedType) {
            this.type = ((ParameterizedType) superclass).getActualTypeArguments()[0];
        } else {
            throw new RuntimeException("Missing type parameter.");
        }
    }

    public T fromJson(String json) {
        return new Gson().fromJson(json, type);
    }
}

// Usage
public class UserListHandler extends GenericTypeHandler<List<User>> {}

UserListHandler handler = new UserListHandler();
List<User> users = handler.fromJson(jsonString);
```

### Working with Complex Nested Structures

```java
public class ComplexTypeExample {
    public static void main(String[] args) {
        Gson gson = new Gson();
        
        // Complex nested structure
        Type complexType = new TypeToken<Map<String, List<Set<User>>>>(){}.getType();
        
        // Creating sample data
        Map<String, List<Set<User>>> data = new HashMap<>();
        // ... populate data ...
        
        // Serialization
        String json = gson.toJson(data, complexType);
        
        // Deserialization
        Map<String, List<Set<User>>> parsed = gson.fromJson(json, complexType);
    }
}
```

### Some points to consider -

1. Insure proper type safety.
2. Do proper error handling.
3. Create type tokens and reuse them.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://wisdom.gitbook.io/gyan/java/gson/type-token.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.