CtrlK
BlogDocsLog inGet started
Tessl Logo

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

array-type-names.mddocs/

Array Type Names

ArrayTypeName represents array types in JavaPoet. It extends TypeName and provides methods for creating and working with single-dimensional and multi-dimensional arrays of any component type.

Capabilities

Creating Array Types

Factory methods for creating array type instances.

/**
 * Creates an array type from a component TypeName
 * @param componentType - The type of array elements
 * @return ArrayTypeName for the array type
 */
static ArrayTypeName of(TypeName componentType);

/**
 * Creates an array type from a reflection Type
 * @param componentType - The component type
 * @return ArrayTypeName for the array type
 */
static ArrayTypeName of(Type componentType);

/**
 * Creates an ArrayTypeName from an ArrayType mirror
 * @param mirror - The array type from annotation processing
 * @return ArrayTypeName from the mirror
 */
static ArrayTypeName get(javax.lang.model.type.ArrayType mirror);

/**
 * Creates an ArrayTypeName from a GenericArrayType
 * @param type - The generic array type from reflection
 * @return ArrayTypeName from the reflection type
 */
static ArrayTypeName get(GenericArrayType type);

Usage Examples:

// int[]
ArrayTypeName intArray = ArrayTypeName.of(TypeName.INT);

// String[]
ArrayTypeName stringArray = ArrayTypeName.of(ClassName.get(String.class));

// User[]
ClassName user = ClassName.get("com.example", "User");
ArrayTypeName userArray = ArrayTypeName.of(user);

// From Class
ArrayTypeName byteArray = ArrayTypeName.of(byte[].class);

// Multi-dimensional: int[][]
ArrayTypeName intArray2D = ArrayTypeName.of(ArrayTypeName.of(TypeName.INT));

// Generic component: List<String>[]
ParameterizedTypeName listOfStrings = ParameterizedTypeName.get(
    ClassName.get(List.class),
    ClassName.get(String.class)
);
ArrayTypeName arrayOfLists = ArrayTypeName.of(listOfStrings);

Accessing Component Type

Get the component type of the array.

/**
 * Returns the component type of this array
 * @return TypeName of the array elements
 */
TypeName componentType();

Usage Examples:

ArrayTypeName stringArray = ArrayTypeName.of(String.class);
TypeName component = stringArray.componentType(); // String

ArrayTypeName intArray2D = ArrayTypeName.of(ArrayTypeName.of(TypeName.INT));
TypeName firstLevel = intArray2D.componentType(); // int[]

ArrayTypeName nested = (ArrayTypeName) firstLevel;
TypeName secondLevel = nested.componentType(); // int

Working with Annotations

Add or remove type annotations.

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

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

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

Common Patterns

Primitive Arrays

// Primitive type arrays
ArrayTypeName booleanArray = ArrayTypeName.of(TypeName.BOOLEAN);  // boolean[]
ArrayTypeName byteArray = ArrayTypeName.of(TypeName.BYTE);        // byte[]
ArrayTypeName shortArray = ArrayTypeName.of(TypeName.SHORT);      // short[]
ArrayTypeName intArray = ArrayTypeName.of(TypeName.INT);          // int[]
ArrayTypeName longArray = ArrayTypeName.of(TypeName.LONG);        // long[]
ArrayTypeName charArray = ArrayTypeName.of(TypeName.CHAR);        // char[]
ArrayTypeName floatArray = ArrayTypeName.of(TypeName.FLOAT);      // float[]
ArrayTypeName doubleArray = ArrayTypeName.of(TypeName.DOUBLE);    // double[]

Object Arrays

// String array
ArrayTypeName stringArray = ArrayTypeName.of(String.class);

// Object array
ArrayTypeName objectArray = ArrayTypeName.of(Object.class);

// Custom class array
ClassName user = ClassName.get("com.example", "User");
ArrayTypeName userArray = ArrayTypeName.of(user);

Multi-Dimensional Arrays

// int[][]
ArrayTypeName intArray2D = ArrayTypeName.of(ArrayTypeName.of(TypeName.INT));

// String[][][]
ArrayTypeName stringArray = ArrayTypeName.of(String.class);
ArrayTypeName stringArray2D = ArrayTypeName.of(stringArray);
ArrayTypeName stringArray3D = ArrayTypeName.of(stringArray2D);

// byte[][]
ArrayTypeName byteArray2D = ArrayTypeName.of(ArrayTypeName.of(TypeName.BYTE));

Generic Component Arrays

// List<String>[]
ParameterizedTypeName listOfStrings = ParameterizedTypeName.get(
    ClassName.get(List.class),
    ClassName.get(String.class)
);
ArrayTypeName arrayOfLists = ArrayTypeName.of(listOfStrings);

// Map<String, Integer>[]
ParameterizedTypeName mapType = ParameterizedTypeName.get(
    ClassName.get(Map.class),
    ClassName.get(String.class),
    TypeName.INT.box()
);
ArrayTypeName arrayOfMaps = ArrayTypeName.of(mapType);

Type Variable Arrays

// T[]
TypeVariableName t = TypeVariableName.get("T");
ArrayTypeName arrayOfT = ArrayTypeName.of(t);

// Generic method: public <T> T[] toArray(T[] a)
MethodSpec toArray = MethodSpec.methodBuilder("toArray")
    .addModifiers(Modifier.PUBLIC)
    .addTypeVariable(t)
    .addParameter(arrayOfT, "a")
    .returns(arrayOfT)
    .build();

Using in Fields

// private String[] names;
FieldSpec names = FieldSpec.builder(ArrayTypeName.of(String.class), "names")
    .addModifiers(Modifier.PRIVATE)
    .build();

// private int[][] matrix;
ArrayTypeName intArray2D = ArrayTypeName.of(ArrayTypeName.of(TypeName.INT));
FieldSpec matrix = FieldSpec.builder(intArray2D, "matrix")
    .addModifiers(Modifier.PRIVATE)
    .build();

// private User[] users;
ClassName user = ClassName.get("com.example", "User");
FieldSpec users = FieldSpec.builder(ArrayTypeName.of(user), "users")
    .addModifiers(Modifier.PRIVATE)
    .initializer("new $T[10]", user)
    .build();

Using in Method Parameters

// public void process(byte[] data)
MethodSpec process = MethodSpec.methodBuilder("process")
    .addModifiers(Modifier.PUBLIC)
    .addParameter(ArrayTypeName.of(TypeName.BYTE), "data")
    .returns(TypeName.VOID)
    .build();

// public String join(String[] parts)
MethodSpec join = MethodSpec.methodBuilder("join")
    .addModifiers(Modifier.PUBLIC)
    .addParameter(ArrayTypeName.of(String.class), "parts")
    .returns(String.class)
    .build();

Using in Method Return Types

// public String[] getNames()
MethodSpec getNames = MethodSpec.methodBuilder("getNames")
    .addModifiers(Modifier.PUBLIC)
    .returns(ArrayTypeName.of(String.class))
    .addStatement("return names")
    .build();

// public User[] getAllUsers()
ClassName user = ClassName.get("com.example", "User");
MethodSpec getAllUsers = MethodSpec.methodBuilder("getAllUsers")
    .addModifiers(Modifier.PUBLIC)
    .returns(ArrayTypeName.of(user))
    .build();

Varargs

// public void log(String format, Object... args)
ArrayTypeName objectArray = ArrayTypeName.of(Object.class);

MethodSpec log = MethodSpec.methodBuilder("log")
    .addModifiers(Modifier.PUBLIC)
    .addParameter(String.class, "format")
    .addParameter(objectArray, "args")
    .varargs()
    .returns(TypeName.VOID)
    .build();

// public static <T> List<T> of(T... elements)
TypeVariableName t = TypeVariableName.get("T");
ArrayTypeName arrayOfT = ArrayTypeName.of(t);
ParameterizedTypeName listOfT = ParameterizedTypeName.get(
    ClassName.get(List.class),
    t
);

MethodSpec of = MethodSpec.methodBuilder("of")
    .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
    .addTypeVariable(t)
    .addParameter(arrayOfT, "elements")
    .varargs()
    .returns(listOfT)
    .build();

Array Initialization

// int[] numbers = new int[10];
FieldSpec numbers = FieldSpec.builder(ArrayTypeName.of(TypeName.INT), "numbers")
    .addModifiers(Modifier.PRIVATE)
    .initializer("new int[$L]", 10)
    .build();

// String[] colors = {"red", "green", "blue"};
FieldSpec colors = FieldSpec.builder(ArrayTypeName.of(String.class), "colors")
    .addModifiers(Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL)
    .initializer("{$S, $S, $S}", "red", "green", "blue")
    .build();

// User[] users = new User[capacity];
ClassName user = ClassName.get("com.example", "User");
FieldSpec users = FieldSpec.builder(ArrayTypeName.of(user), "users")
    .addModifiers(Modifier.PRIVATE)
    .initializer("new $T[capacity]", user)
    .build();

Annotated Arrays

// @NonNull String[]
AnnotationSpec nonNull = AnnotationSpec.builder(
    ClassName.get("org.checkerframework.checker.nullness.qual", "NonNull")
).build();

ArrayTypeName nonNullStringArray = ArrayTypeName.of(String.class)
    .annotated(nonNull);

FieldSpec field = FieldSpec.builder(nonNullStringArray, "items")
    .addModifiers(Modifier.PRIVATE)
    .build();

Working with Component Types

ArrayTypeName array = ArrayTypeName.of(String.class);

// Check component type
TypeName component = array.componentType();
if (component.equals(ClassName.get(String.class))) {
    System.out.println("Array of strings");
}

// Multi-dimensional component access
ArrayTypeName array2D = ArrayTypeName.of(ArrayTypeName.of(TypeName.INT));
ArrayTypeName firstDim = (ArrayTypeName) array2D.componentType(); // int[]
TypeName primitive = firstDim.componentType(); // int

Converting Between Arrays and Collections

// Method to convert array to list
ArrayTypeName stringArray = ArrayTypeName.of(String.class);
ParameterizedTypeName listOfStrings = ParameterizedTypeName.get(
    ClassName.get(List.class),
    ClassName.get(String.class)
);

MethodSpec toList = MethodSpec.methodBuilder("toList")
    .addModifiers(Modifier.PUBLIC)
    .addParameter(stringArray, "array")
    .returns(listOfStrings)
    .addStatement("return $T.asList(array)", Arrays.class)
    .build();

// Method to convert collection to array
MethodSpec toArray = MethodSpec.methodBuilder("toArray")
    .addModifiers(Modifier.PUBLIC)
    .addParameter(listOfStrings, "list")
    .returns(stringArray)
    .addStatement("return list.toArray(new $T[0])", String.class)
    .build();

Types

class ArrayTypeName extends TypeName {
    static ArrayTypeName of(TypeName componentType);
    static ArrayTypeName of(Type componentType);
    static ArrayTypeName get(javax.lang.model.type.ArrayType mirror);
    static ArrayTypeName get(GenericArrayType type);

    TypeName componentType();
    ArrayTypeName annotated(AnnotationSpec... annotations);
    ArrayTypeName annotated(List<AnnotationSpec> annotations);
    ArrayTypeName 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