## 1 Last Item

Find the last item in an List of String objects

### 1.1 Solution

```1: String lastItem(List<String> a)
2: {
3:     return  a.get(a.size()-1);
4: }
```

## 2 Last Item Generic

Find the last item in a Generic List

### 2.1 Solution

```1: Object gLastItem(List<?> a)
2: {
3:     return  a.get(a.size()-1);
4: }
```

## 3 Last But One

Find the last but one item in a List

### 3.1 Solution

```1: Object lastButOneItem(List<?> a)
2: {
3:     if (a.size() > 1)
4:  return  a.get(a.size()-2);
5:     else
6:  return "List too small";
7: }
```

## 4 Iterate through the Elements of a List

Iterate through the Elements of a List, printing them out in turn

### 4.1 Solution

```1: void printEach(List<?> a)
2: {
3:     for (Object e: a)
4:     {
5:  System.out.println(e);
6:     }
7: }
```

or using a stream

```1: void streamPrintEach(List<?> list)
2: {
3:     list
4:  .stream()
5:  .forEach(System.out::println);
6:
7: }
```

## 5 Eliminate consecutive duplicates from a List.

Write a method that removes consecutive duplicates from a List. The order of the elements should not be changed.

### 5.1 Solution

```1: List<?> removeDuplicates(List<?> a)
2: {
3:     for (int i = 0; i<a.size()-1; i++)
4:     {
5:  if(a.get(i) == a.get(i+1)) a.remove(a.get(i));
6:     }
7:     return a;
8: }
```

## 6 Eliminate consecutive duplicates from a List using HashSet

Remembering that a HashSet cannot contain duplicates, repeat the above question using a HashSet

### 6.1 Solution

```1: HashSet<String> hashRemoveDuplicates(List<String> a)
2: {
3:     HashSet<String> hSet = new HashSet<String>(a);
4:     return hSet;
5: }
```

## 7 RLE

Run-length encoding of a list. Consecutive duplicates of elements are encoded as pairs where N is the number of duplicates of the element E.

Note this solution uses the Pair class, defined in the question

### 7.1 Solution

``` 1: List<Pair> RLE(List<?> list)
2: {
3:     List<Pair> encoded = new ArrayList<Pair>();
4:     for (int i = 0; i < list.size(); i++)
5:     {
6:     int runLength = 1;
7:     while (i < list.size() -1 && list.get(i) == list.get(i+1))
8:     {
9:         runLength++;
10:         i++;
11:     }
12:
13:      Pair<Object> pair = new Pair<Object>(runLength, list.get(i));
15:     }
16:     return encoded;
17:
18: }
```

## 8 Decode a run-length encoded list

Given a run-length code list generated in a previous problem, construct its uncompressed version.

Note this solution uses the Pair class, defined in the question

### 8.1 Solution

``` 1: List<Object> decodeRLE(List<Pair> list)
2: {
3:
4:     List<Object> decoded = new ArrayList<Object>();
5:     for (Pair pair: list)
6:     {
7:     for (int i =0; i<(int)pair.count; i++)
8:     {
10:     }
11:     }
12:
13:     return decoded;
14: }
```

## 9 Duplicate the elements of a list

### 9.1 Solution

``` 1: List<String> dupli(List<String> list)
2: {
3:     List<String> dup = new ArrayList<String>();
4:
5:     for(String s: list)
6:     {
9:     }
10:
11:     return dup;
12: }
```

or, using a stream

```1: List<String> streamDupli(List<String> list)
2: {
3:     List<String> dupli = list
4:              .stream()
5:              .collect(Collectors.toList());
6:
7:     return dupli;
8:
9: }
```

## 10 Replicate the elements of a list a given number of times

### 10.1 Solution

``` 1: List<String> repli(List<String> list, int num)
2: {
3:     List<String> rep = new ArrayList<String>();
4:
5:     for(String s: list)
6:     {
7:     for (int i=0; i<num; i++)
8:     {