A **generic type** is a generic class or interface that is parameterized over types.

This allows the compiler to enforce type safety on the class or interface.

Consider this non-generic `Container` interface:

class Container {

private Object object;

public void set(Object object) { this.object = object; }

public Object get() { return object; }

}

Since it accepts and returns Object types, it works with any non-primitive type.

However, this comes at a cost because some code may call `get` expecting `Integer`s while other code calls `set` adding `String`s resulting in a runtime exception.

A **generic class** and **generic interface** have the following formats:

class ClassName<T1, T2, ..., Tn> { ... }

interface InterfaceName<T1, T2, ..., Tn> { ... }

The type parameter section, delimited by angle brackets (`<>`), following the class or interface name specifies the type parameters (also called type variables) `T1`, `T2`, ..., and `Tn`.

These can be used inside the body of the class or interface to get generic type safety.

Here is the generic version of `Container`:

class Container<E> {

private E object;

public void set(E object) { this.object = object; }

public E get() { return object; }

}

When created, now we have to declare what type it holds and the compiler will enforce that constraint:

Container<String> stringContainer = new Container<>();

stringContainer.set("Some string");

String result = stringContainer.get();

stringContainer.set(42);

A **generic type** is a generic class or interface that is parameterized over types.

This allows the compiler to enforce type safety on the class or interface.

Consider this non-generic `Container` interface:

class Container {

private Object object;

public void set(Object object) { this.object = object; }

public Object get() { return object; }

}

Since it accepts and returns Object types, it works with any non-primitive type.

However, this comes at a cost because some code may call `get` expecting `Integer`s while other code calls `set` adding `String`s resulting in a runtime exception.

A **generic class** and **generic interface** have the following formats:

class ClassName<T1, T2, ..., Tn> { ... }

interface InterfaceName<T1, T2, ..., Tn> { ... }

The type parameter section, delimited by angle brackets (`<>`), following the class or interface name specifies the type parameters (also called type variables) `T1`, `T2`, ..., and `Tn`.

These can be used inside the body of the class or interface to get generic type safety.

Here is the generic version of `Container`:

class Container<E> {

private E object;

public void set(E object) { this.object = object; }

public E get() { return object; }

}

When created, now we have to declare what type it holds and the compiler will enforce that constraint:

Container<String> stringContainer = new Container<>();

stringContainer.set("Some string");

String result = stringContainer.get();

stringContainer.set(42);

[

{

"url": "https://docs.oracle.com/javase/tutorial/java/generics/types.html",

"description": "generics"

}

]

"blurb": "Lists are an ordered collection that allows duplicates.",

"jmrunkle"

**Lists** are the ordered sequence collection in Java.

Unlike arrays, a [`List`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html) can grow in size to accomodate any number of items.

One standard implementation is the `ArrayList` which is backed by a re-sizable array.

Another standard implementation is the `LinkedList` class which is backed by a doubly-linked list.

`List`s may be empty or hold any number of items (including duplicates).

`List`s are a **generic interface** typed to indicate which type of objects they can contain.

For example:

List<String> emptyListOfStrings = List.of();

List<Integer> singleInteger = List.of(1);

List<Boolean> threeBooleans = List.of(true, false, true);

List<Object> listWithMulitipleTypes = List.of("hello", 1, true);

`List`s have various helpful methods to add, remove, get, and check for an element to be present:

List<Character> vowels = new ArrayList<>(List.of('a', 'e', 'i', 'o', 'i', 'e', 'a'));

int startingSize = vowels.size(); // 7

vowels.add('u'); // vowels is now ['a', 'e', 'i', 'o', 'i', 'e', 'a', 'u']

char a = vowels.get(0); // 'a'

boolean hadI = vowels.remove('i'); // true and vowels is now ['a', 'e', 'o', 'i', 'e', 'a', 'u']

boolean hasI = vowels.contains('i'); // true (still have one more left)

The [`Collections`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collections.html) class also has some helpful utilities for dealing with collections like `List`:

List<Integer> numbers = new ArrayList<>(List.of(1, 5, 3, 2, 4));

Collections.sort(numbers); // [1, 2, 3, 4, 5]

Collections.reverse(numbers); // [5, 4, 3, 2, 1]

Collections.fill(numbers, 42); // [42, 42, 42, 42, 42]

List<Integer> fiveNines = Collections.nCopies(5, 9); // [9, 9, 9, 9, 9]

**Lists** are the ordered sequence collection in Java.

Unlike arrays, a [`List`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html) can grow in size to accomodate any number of items.

One standard implementation is the `ArrayList` which is backed by a re-sizable array.

Another standard implementation is the `LinkedList` class which is backed by a doubly-linked list.

`List`s may be empty or hold any number of items (including duplicates).

`List`s are a **generic interface** typed to indicate which type of objects they can contain.

For example:

List<String> emptyListOfStrings = List.of();

List<Integer> singleInteger = List.of(1);

List<Boolean> threeBooleans = List.of(true, false, true);

List<Object> listWithMulitipleTypes = List.of("hello", 1, true);

`List`s have various helpful methods to add, remove, get, and check for an element to be present:

List<Character> vowels = new ArrayList<>(List.of('a', 'e', 'i', 'o', 'i', 'e', 'a'));

int startingSize = vowels.size(); // 7

vowels.add('u'); // vowels is now ['a', 'e', 'i', 'o', 'i', 'e', 'a', 'u']

char a = vowels.get(0); // 'a'

boolean hadI = vowels.remove('i'); // true and vowels is now ['a', 'e', 'o', 'i', 'e', 'a', 'u']

boolean hasI = vowels.contains('i'); // true (still have one more left)

[

{

"url": "https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html",

"description": "javadoc"

},

{

"url": "https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collections.html",

"description": "collections"

}

]

{

"slug": "karls-languages",

"name": "Karl's Languages",

"uuid": "1ad2ab97-df3e-4bc9-b0f6-e8dcc9eb10f1",

"concepts": [

"lists",

"generic-types"

],

"prerequisites": [

"arrays",

"for-loops",

"strings"

],

"status": "active"

},

"status": "active"

{

"uuid": "7de03b7d-ed91-4699-b275-96a6ab2e441c",

"slug": "generic-types",

"name": "Generic Types"

},

* Try using the [`isEmpty()`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html#isEmpty()) method.

* Try using the [`add(E element)`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html#add(E)) method.

* Reminder: methods that return `void` do not need any `return` statements.

* Try using the [`remove(Object o)`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html#remove(java.lang.Object)) method.

* Reminder: methods that return `void` do not need any `return` statements.

* Try using the [`get(int index)`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html#get(int)) method.

* Try using the [`size()`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html#size()) method.

* Try using the [`contains(Object o)`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html#contains(java.lang.Object)) method.

* Try using a [for-each loop](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/for.html) through all of the elements, checking each one.

* Alternatively, try using the `containsLanguage` method from the previous step.