Arrays and Lists

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:

  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:

  int[] userIds = new int[3];
  

• Assign a value to an element in an array by specifying the index in square brackets:

  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:

  string[] names = new string[3] { "Johannes", "Rene", "Ville" };
  

• The same works without specifying the length in the brackets:

  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

  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 offers another structure to contain multiple variables: the List class
• Importing the library:

  using System.Collections.Generic;
  

• Declaration and initialization:

  List<int> userIds = new List<int>();
  

• Value assignment (exactly like arrays):

  userIds[0] = 22;
  

Why lists?

• The key benefit of using Lists lies in its built-in functionalities
  
• 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

  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

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

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

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

  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:

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

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

Note about foreach

• However, foreach creates a copy of each element in the object so the element cannot be mutated directly:
  
• 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

Assignments

Assignments about this topic can be found here