Star projection for unknown types in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a star projection in Kotlin generics?

A star projection is a way to say "I don't know the exact type" for a generic parameter. It uses the * symbol to represent an unknown type safely.

beginner

How do you write a star projection for a generic type List in Kotlin?

You write it as List<*> which means a list of some unknown type.

intermediate

Why use star projection instead of a raw type in Kotlin?

Star projection keeps type safety by acknowledging unknown types, while raw types can cause unsafe operations and errors.

intermediate

What is the difference between List<*> and List in Kotlin?

List<*> means a list of some unknown type, while List means a list that can hold any type including null. The first is safer for reading unknown types.

beginner

Can you add elements to a List<*> in Kotlin?

No, you cannot add elements to a List<*> because the exact type is unknown, so adding could break type safety.

What does List<*> mean in Kotlin?

A A list with an unknown element type

B A list of Any type elements

C A list that can only hold null

D A list with no elements

List<*> means the list holds elements of some unknown type, preserving type safety.

Can you add an element to a List<*> in Kotlin?

A No, because the element type is unknown

B Yes, any element can be added

C Only null can be added

D Only elements of type Any can be added

You cannot add elements to List<*> because Kotlin does not know the exact type, so adding could cause errors.

Which symbol is used for star projection in Kotlin generics?

A &

B ?

C #

D *

The star (*) symbol is used to represent an unknown generic type in Kotlin.

Why is star projection safer than using raw types?

A Because it allows adding any type

B Because it converts all types to Any

C Because it preserves type safety by acknowledging unknown types

D Because it disables generics

Star projection keeps the compiler aware of unknown types, preventing unsafe operations.

What is the difference between List<*> and List?

A List<*> can hold any type; List<Any?> is unknown

B List<*> is unknown type; List<Any?> can hold any type including null

C Both are exactly the same

D List<*> can only hold null; List<Any?> cannot

List<*> means unknown element type; List means elements can be any type or null.

Explain what star projection means in Kotlin generics and why it is useful.

Think about how Kotlin handles unknown generic types safely.

Describe the difference between List<*> and List in Kotlin and when you might use each.

Consider what each means for the types of elements allowed.