tessl/maven-com-palantir-javapoet--javapoet

JavaPoet is a Java API for generating .java source files programmatically with support for modern Java features including records and sealed types

Overview

Eval results

Files

Parameterized Type Names

Name: tessl/maven-com-palantir-javapoet--javapoet
Author: tessl

ParameterizedTypeName represents parameterized generic types such as List<String>, Map<String, Integer>, or custom generic classes. It extends TypeName and provides methods for working with raw types, type arguments, and nested parameterized types.

Capabilities

Creating Parameterized Types

Factory methods for creating parameterized type instances.

/**
 * Creates a parameterized type from a raw type and type arguments
 * @param rawType - The raw class name (e.g., List)
 * @param typeArguments - Type arguments (e.g., String)
 * @return ParameterizedTypeName for the generic type
 */
static ParameterizedTypeName get(ClassName rawType, TypeName... typeArguments);

/**
 * Creates a parameterized type from reflection types
 * @param rawType - The raw class
 * @param typeArguments - Type argument classes
 * @return ParameterizedTypeName for the generic type
 */
static ParameterizedTypeName get(Class<?> rawType, Type... typeArguments);

/**
 * Creates a parameterized type from a ParameterizedType
 * @param type - The parameterized type from reflection
 * @return ParameterizedTypeName for the type
 */
static ParameterizedTypeName get(ParameterizedType type);

Usage Examples:

// List<String>
ParameterizedTypeName listOfStrings = ParameterizedTypeName.get(
    ClassName.get(List.class),
    ClassName.get(String.class)
);

// Map<String, Integer>
ParameterizedTypeName mapType = ParameterizedTypeName.get(
    ClassName.get(Map.class),
    ClassName.get(String.class),
    ClassName.get(Integer.class)
);

// Using Class objects
ParameterizedTypeName listOfInts = ParameterizedTypeName.get(
    List.class,
    Integer.class
);

// From reflection
ParameterizedType reflectionType = ...; // e.g., from Field.getGenericType()
ParameterizedTypeName fromReflection = ParameterizedTypeName.get(reflectionType);

// Custom generic class: Container<T>
ClassName container = ClassName.get("com.example", "Container");
ParameterizedTypeName containerOfString = ParameterizedTypeName.get(
    container,
    ClassName.get(String.class)
);

Accessing Type Components

Get information about the parameterized type's structure.

/**
 * Returns the enclosing parameterized type if this is a nested generic type
 * @return Enclosing ParameterizedTypeName, or null if not nested
 */
ParameterizedTypeName enclosingType();

/**
 * Returns the raw class name without type arguments
 * @return ClassName of the raw type
 */
ClassName rawType();

/**
 * Returns the list of type arguments
 * @return List of TypeName for type arguments
 */
List<TypeName> typeArguments();

Usage Examples:

ParameterizedTypeName listOfStrings = ParameterizedTypeName.get(
    ClassName.get(List.class),
    ClassName.get(String.class)
);

ClassName rawType = listOfStrings.rawType();          // List
List<TypeName> args = listOfStrings.typeArguments();  // [String]

// Nested parameterized type: Map.Entry<String, Integer>
ParameterizedTypeName mapEntry = ParameterizedTypeName.get(
    ClassName.get(Map.class).nestedClass("Entry"),
    ClassName.get(String.class),
    ClassName.get(Integer.class)
);

ParameterizedTypeName enclosing = mapEntry.enclosingType(); // Map

Creating Nested Parameterized Types

Create nested generic types.

/**
 * Creates a nested parameterized class
 * @param name - Simple name of the nested class
 * @return ParameterizedTypeName for the nested class
 */
ParameterizedTypeName nestedClass(String name);

/**
 * Creates a nested parameterized class with type arguments
 * @param name - Simple name of the nested class
 * @param typeArguments - Type arguments for the nested class
 * @return ParameterizedTypeName for the nested class
 */
ParameterizedTypeName nestedClass(String name, List<TypeName> typeArguments);

Usage Examples:

// Map<String, Integer>
ParameterizedTypeName map = ParameterizedTypeName.get(
    ClassName.get(Map.class),
    ClassName.get(String.class),
    ClassName.get(Integer.class)
);

// Map<String, Integer>.Entry<String, Integer>
ParameterizedTypeName entry = map.nestedClass("Entry",
    Arrays.asList(
        ClassName.get(String.class),
        ClassName.get(Integer.class)
    )
);

Working with Annotations

Add or remove type annotations.

/**
 * Returns a copy with additional annotations
 * @param annotations - Annotations to add
 * @return New ParameterizedTypeName with annotations
 */
ParameterizedTypeName annotated(AnnotationSpec... annotations);

/**
 * Returns a copy with additional annotations from a list
 * @param annotations - List of annotations to add
 * @return New ParameterizedTypeName with annotations
 */
ParameterizedTypeName annotated(List<AnnotationSpec> annotations);

/**
 * Returns a copy without any annotations
 * @return New ParameterizedTypeName without annotations
 */
ParameterizedTypeName withoutAnnotations();

Common Patterns

Collection Types

// List<String>
ParameterizedTypeName listOfStrings = ParameterizedTypeName.get(
    ClassName.get(List.class),
    ClassName.get(String.class)
);

// Set<Integer>
ParameterizedTypeName setOfIntegers = ParameterizedTypeName.get(
    ClassName.get(Set.class),
    TypeName.INT.box()
);

// ArrayList<String>
ParameterizedTypeName arrayListOfStrings = ParameterizedTypeName.get(
    ClassName.get(ArrayList.class),
    ClassName.get(String.class)
);

// Map<String, Object>
ParameterizedTypeName stringToObjectMap = ParameterizedTypeName.get(
    ClassName.get(Map.class),
    ClassName.get(String.class),
    ClassName.get(Object.class)
);

// Queue<Task>
ClassName task = ClassName.get("com.example", "Task");
ParameterizedTypeName queueOfTasks = ParameterizedTypeName.get(
    ClassName.get(Queue.class),
    task
);

Nested Generic Types

// List<List<String>>
ParameterizedTypeName innerList = ParameterizedTypeName.get(
    ClassName.get(List.class),
    ClassName.get(String.class)
);
ParameterizedTypeName listOfLists = ParameterizedTypeName.get(
    ClassName.get(List.class),
    innerList
);

// Map<String, List<Integer>>
ParameterizedTypeName listOfIntegers = ParameterizedTypeName.get(
    ClassName.get(List.class),
    TypeName.INT.box()
);
ParameterizedTypeName complexMap = ParameterizedTypeName.get(
    ClassName.get(Map.class),
    ClassName.get(String.class),
    listOfIntegers
);

Custom Generic Classes

// MyContainer<T>
ClassName container = ClassName.get("com.example", "MyContainer");
ParameterizedTypeName containerOfString = ParameterizedTypeName.get(
    container,
    ClassName.get(String.class)
);

// Repository<User>
ClassName repository = ClassName.get("com.example", "Repository");
ClassName user = ClassName.get("com.example", "User");
ParameterizedTypeName userRepository = ParameterizedTypeName.get(
    repository,
    user
);

// Pair<String, Integer>
ClassName pair = ClassName.get("com.example", "Pair");
ParameterizedTypeName stringIntPair = ParameterizedTypeName.get(
    pair,
    ClassName.get(String.class),
    TypeName.INT.box()
);

Functional Interfaces

// Function<String, Integer>
ParameterizedTypeName stringToInt = ParameterizedTypeName.get(
    ClassName.get(Function.class),
    ClassName.get(String.class),
    TypeName.INT.box()
);

// Consumer<User>
ClassName user = ClassName.get("com.example", "User");
ParameterizedTypeName userConsumer = ParameterizedTypeName.get(
    ClassName.get(Consumer.class),
    user
);

// Supplier<List<String>>
ParameterizedTypeName listOfStrings = ParameterizedTypeName.get(
    ClassName.get(List.class),
    ClassName.get(String.class)
);
ParameterizedTypeName listSupplier = ParameterizedTypeName.get(
    ClassName.get(Supplier.class),
    listOfStrings
);

// Predicate<String>
ParameterizedTypeName stringPredicate = ParameterizedTypeName.get(
    ClassName.get(Predicate.class),
    ClassName.get(String.class)
);

Using in Field Declarations

// private List<String> names;
ParameterizedTypeName listOfStrings = ParameterizedTypeName.get(
    ClassName.get(List.class),
    ClassName.get(String.class)
);

FieldSpec names = FieldSpec.builder(listOfStrings, "names")
    .addModifiers(Modifier.PRIVATE)
    .initializer("new $T<>()", ArrayList.class)
    .build();

// private Map<String, User> userMap;
ClassName user = ClassName.get("com.example", "User");
ParameterizedTypeName mapType = ParameterizedTypeName.get(
    ClassName.get(Map.class),
    ClassName.get(String.class),
    user
);

FieldSpec userMap = FieldSpec.builder(mapType, "userMap")
    .addModifiers(Modifier.PRIVATE, Modifier.FINAL)
    .initializer("new $T<>()", HashMap.class)
    .build();

Using in Method Signatures

// public List<User> getUsers()
ClassName user = ClassName.get("com.example", "User");
ParameterizedTypeName listOfUsers = ParameterizedTypeName.get(
    ClassName.get(List.class),
    user
);

MethodSpec getUsers = MethodSpec.methodBuilder("getUsers")
    .addModifiers(Modifier.PUBLIC)
    .returns(listOfUsers)
    .addStatement("return users")
    .build();

// public void processItems(List<String> items)
ParameterizedTypeName listOfStrings = ParameterizedTypeName.get(
    ClassName.get(List.class),
    ClassName.get(String.class)
);

MethodSpec process = MethodSpec.methodBuilder("processItems")
    .addModifiers(Modifier.PUBLIC)
    .addParameter(listOfStrings, "items")
    .returns(TypeName.VOID)
    .build();

Comparable and Comparator

// Comparable<User>
ClassName user = ClassName.get("com.example", "User");
ParameterizedTypeName comparableUser = ParameterizedTypeName.get(
    ClassName.get(Comparable.class),
    user
);

// Comparator<String>
ParameterizedTypeName stringComparator = ParameterizedTypeName.get(
    ClassName.get(Comparator.class),
    ClassName.get(String.class)
);

Optional Types

// Optional<String>
ParameterizedTypeName optionalString = ParameterizedTypeName.get(
    ClassName.get(Optional.class),
    ClassName.get(String.class)
);

// Optional<User>
ClassName user = ClassName.get("com.example", "User");
ParameterizedTypeName optionalUser = ParameterizedTypeName.get(
    ClassName.get(Optional.class),
    user
);

MethodSpec findUser = MethodSpec.methodBuilder("findUser")
    .addParameter(String.class, "id")
    .returns(optionalUser)
    .addStatement("return $T.ofNullable(users.get(id))", Optional.class)
    .build();

Stream Types

// Stream<String>
ParameterizedTypeName streamOfStrings = ParameterizedTypeName.get(
    ClassName.get(Stream.class),
    ClassName.get(String.class)
);

// Collector<String, ?, List<String>>
ParameterizedTypeName listOfStrings = ParameterizedTypeName.get(
    ClassName.get(List.class),
    ClassName.get(String.class)
);
ParameterizedTypeName collector = ParameterizedTypeName.get(
    ClassName.get(Collector.class),
    ClassName.get(String.class),
    WildcardTypeName.subtypeOf(Object.class),
    listOfStrings
);

With Wildcards

// List<? extends Number>
ParameterizedTypeName listOfNumbers = ParameterizedTypeName.get(
    ClassName.get(List.class),
    WildcardTypeName.subtypeOf(Number.class)
);

// Map<String, ? super Integer>
ParameterizedTypeName flexibleMap = ParameterizedTypeName.get(
    ClassName.get(Map.class),
    ClassName.get(String.class),
    WildcardTypeName.supertypeOf(Integer.class)
);

// Class<?>
ParameterizedTypeName unboundedClass = ParameterizedTypeName.get(
    ClassName.get(Class.class),
    WildcardTypeName.subtypeOf(Object.class)
);

Types

class ParameterizedTypeName extends TypeName {
    static ParameterizedTypeName get(ClassName rawType, TypeName... typeArguments);
    static ParameterizedTypeName get(Class<?> rawType, Type... typeArguments);
    static ParameterizedTypeName get(ParameterizedType type);

    ParameterizedTypeName enclosingType();
    ClassName rawType();
    List<TypeName> typeArguments();
    ParameterizedTypeName nestedClass(String name);
    ParameterizedTypeName nestedClass(String name, List<TypeName> typeArguments);
    ParameterizedTypeName annotated(AnnotationSpec... annotations);
    ParameterizedTypeName annotated(List<AnnotationSpec> annotations);
    ParameterizedTypeName withoutAnnotations();
}

Install with Tessl CLI

npx tessl i tessl/maven-com-palantir-javapoet--javapoet@0.11.0

docs

annotation-specifications.md

array-type-names.md

class-names.md

code-blocks.md

field-specifications.md

index.md

java-files.md

method-specifications.md

name-allocator.md

parameter-specifications.md

parameterized-type-names.md

type-names.md

type-specifications.md

type-variable-names.md

wildcard-type-names.md

tile.json

tessl/maven-com-palantir-javapoet--javapoet