Difference between revisions of "Iterable Immutable List Assignment"
Line 3: | Line 3: | ||
{{JavaToImplement|DefaultImmutableList|head<br>tail<br>isEmpty<br>iterator|immutable.list.assignment}} | {{JavaToImplement|DefaultImmutableList|head<br>tail<br>isEmpty<br>iterator|immutable.list.assignment}} | ||
===default constructor=== | ===default constructor=== | ||
+ | <nowiki>DefaultImmutableList()</nowiki> | ||
===head and tail constructor=== | ===head and tail constructor=== | ||
+ | <nowiki>DefaultImmutableList(E head, ImmutableList<E> tail)</nowiki> | ||
===head=== | ===head=== | ||
+ | <nowiki>public E head()</nowiki> | ||
===tail=== | ===tail=== | ||
+ | <nowiki>public ImmutableList<E> tail()</nowiki> | ||
===isEmpty=== | ===isEmpty=== | ||
+ | <nowiki>public boolean isEmpty()</nowiki> | ||
===iterator=== | ===iterator=== | ||
+ | <nowiki>public Iterator<E> iterator()</nowiki> | ||
==Lists== | ==Lists== |
Revision as of 00:49, 31 July 2019
Contents
Code To Implement
DefaultImmutableList
class: | DefaultImmutableList.java | |
methods: | head tail isEmpty iterator |
|
package: | immutable.list.assignment | |
source folder: | src/main/java |
default constructor
DefaultImmutableList()
head and tail constructor
DefaultImmutableList(E head, ImmutableList<E> tail)
head
public E head()
tail
public ImmutableList<E> tail()
isEmpty
public boolean isEmpty()
iterator
public Iterator<E> iterator()
Lists
Lists
is a class which holds a number of static methods. As we know, in the Kingdom of Nouns, Verbs must always have an escort.
The first two static methods nil
and cons
will each call a constructor of the DefaultImmutableList
class. The third method brackets
will use nil
and cons
to build up the desired ImmutableList.
class: | Lists.java | |
methods: | nil cons brackets |
|
package: | immutable.list.assignment | |
source folder: | src/main/java |
nil
public static <E> ImmutableList<E> nil()
Analogous to the SML List nil constructor.
Note: often SML programs use empty brackets []
instead of nil
.
cons
public static <E> ImmutableList<E> cons(E head, ImmutableList<E> tail)
Analogous to the SML List :: constructor.
brackets
@SafeVarargs public static <E> ImmutableList<E> brackets(E... elements)
brackets
accepts variable length arguments as specified by the ...
syntax. When implementing the brackets
method you can treat elements
as an array. Combining generics and varargs https://stackoverflow.com/questions/14231037/java-safevarargs-annotation-does-a-standard-or-best-practice-exist can be problematic] if the implementation lets the E[] escape since it will actually be an Object[]. The @SafeVarargs annotation indicates a promise that you will rely only on the elements of the array being of type E and not the array being of type E[]. This should not be a problem since you should not require any unsafe use of varargs.
Note: be sure to cons
the elements on from the back of the elements
array to the front.
Performance
The code:
ImmutableList<Integer> numbers = Lists.brackets(4, 66, 99); for (int i : numbers) { System.out.println(i); }
produces:
4 66 99
Test
class: | ListsTestSuite.java | |
package: | immutable.list.assignment | |
source folder: | src/test/java |