---
marp: true
paginate: true
math: mathjax
theme: buutti
title: 5. Arrays and Lists
---

# Arrays and Lists

<!-- headingDivider: 5 -->
<!-- class: invert -->

## Overview

* Arrays
* Multidimensional arrays
* Lists
* Iterating a list
* Foreach

## Arrays

* Arrays are a collection of variables of the same type
* To optimize memory usage, arrays allocate neighbouring memory addresses
* A single value in this collection is called an *__element__*
* Arrays can be *__declared__* with square brackets following the type of the elements:
  ```csharp
  int[] userIds;
  ```
* Declaring an array does not yet allocate space from memory

### Initializing arrays 

* *__Initialize__* an array with a length of 3 using the following syntax:
  ```csharp
  int[] userIds = new int[3];
  ```
* *__Assign a value__* to an element in an array by specifying the index in square brackets:
  ```csharp
  userIds[0] = 104;
  ```
* Indexing starts from 0, so the above line assigns a value of `104` to the ***first*** element of the array

---

* You can also create an array and instantly populate it with values with one statement:
  ```csharp
  string[] names = new string[3] { "Johannes", "Rene", "Ville" };
  ```
* The same works without specifying the length in the brackets:
  ```csharp
  double[] balances = new double[] { 1.3, 200.3, 9332.14 };
  ```

## Multidimensional Arrays

* C# supports multidimensional arrays
* Here's an example of a two-dimensional array.
* You can think of it as an array consisting of arrays
  ```csharp
  char[,] letters = new char[3, 4]
  {
    {'a', 'b', 'c', 'd'},
    {'e', 'f', 'g', 'h'},
    {'i', 'j', 'k', 'l'}
  };
  
  Console.WriteLine(letters[1, 3]);       // Outputs "h"
  ```

## Lists

* The .NET Framework Library [`System.Collections.Generic`](https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic?view=net-9.0) offers another structure to contain multiple variables: the [List](https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.list-1?view=net-9.0) class
* Importing the library:
  ```csharp
  using System.Collections.Generic;
  ```
* Declaration and initialization:
  ```csharp
  List<int> userIds = new List<int>();
  ```
* Value assignment (exactly like arrays):
  ```csharp
  userIds[0] = 22;
  ```

### Why lists?

* The key benefit of using Lists lies in its built-in functionalities
  ![](imgs/5%20Arrays%20and%20Lists_1.png)
* You can see a list (heh) of available methods in Visual Studio by following the list variable with a dot

## Arrays vs Lists

* The memory allocation of an array is ***static*** a.k.a. fixed, but list memory is ***dynamic***
* This allows the flexible mutation of lists, meaning you can always add or remove elements, thus changing the length of the list without issues
  ```csharp
  List<int> intList = new List<int>() { 1, 9, 4 };
  intList.Remove(0); // List is now [9, 4]

  int[] intArray = new int[] { 1, 9, 4 };
  intArray.Remove(0);
  // Can't do that, array is static
  // and doesn't include such method
  ```

### When to use arrays or lists?

* Use arrays when you...
  * ...need high performance
  * ...can predetermine the number of elements 
* Use lists when you...
  * ...need to add/remove elements dynamically
  * ...need the list operations

## Example: Iterating an array with a for loop

<div class='columns21' markdown='1'>
<div markdown='1'>

```csharp
string[] names = new string[]
{
  "Harry Potter",
  "Luke Skywalker",
  "Harley Quinn"
};

for (int i = 0; i < names.Length; ++i)
{
  Console.WriteLine(names[i]);
}
```

</div>
<div markdown='1'>

![](imgs/5%20Arrays%20and%20Lists_3.png)

</div>
</div>

## Iterating a List

* You can iterate the elements of a list with a for loop the same way as an array
* Just use `List.Count` instead of `Array.Length`
  ```csharp
  List<int> numbers = new List<int>() { 1, 5, 3 };
  int sum = 0;
  for (int i = 0; i < numbers.Count; ++i)
  {
    sum += numbers[i];
  }
  // sum is now 9
  ```

## `foreach` Statement

* There is one more statement to use to iterate arrays and lists: the `foreach` statement
* `foreach` is useful when you have to execute code for each element of an array or a list, and don't need the corresponding index:

<div class='columns21' markdown='1'>
<div markdown='1'>

```csharp
string[] names = new string[]
{
  "Harry Potter",
  "Luke Skywalker",
  "Harley Quinn"
};

foreach (string name in names)
{
  Console.WriteLine(name);
}
```

</div>
<div markdown='1'>

![](imgs/5%20Arrays%20and%20Lists_4.png)

</div>
</div>

### Note about `foreach`

* However, `foreach` creates a copy of each element in the object so the element cannot be mutated directly:
  ![](imgs/5%20Arrays%20and%20Lists_5.png)
* Performance-wise, using foreach is also more costly because it uses more memory space
* If you need to change every element, consider creating a new list instead

## Exercise 1: Expanding the Console Application
<!--_class: "exercise invert" -->

1) Continue working on the command line application you created in [Lecture 4, Exercise 1: The Main Loop ](4-loops#exercise-1-the-main-loop). Add a new command `add` which prompts the user to write a note.
2) After the user has inputted the note, save it to a list, and return back to listening to commands.
3) Add another command `list` which prints all the saved notes.
4) Add one more command `remove` which prints all the saved notes with the index of the note, and then prompts the user for a number. After entering the number the note with the corresponding index is deleted from the list.

* *__Note__*: you can use the `int.Parse()` method to parse the user input string to an integer

## Assignments

[Assignments about this topic can be found here](https://gitea.buutti.com/education/academy-assignments/src/branch/master/C%23%20Basics/5.%20Arrays%20&%20Lists)