Which is better? array, ArrayList or List (in terms of performance and speed)

// The main thing I can add to this is that a LINQ query is almost always faster than a loop such as a foreach, etc. Here are a couple of prime examples in optimized code form.

// Try to use queries rather than loops.

    /// <summary> This one accepts the Collection of Dictionaries for
    /// ViewAllAssociations(); Has it's own special Size & Location Settings.
    /// It directly calls the Mother Method of them all below this one.
    /// NOTE: "var x = ..." below does a ton of work,
    /// & faster because instead of a loop it's a LINQ query!
    /// 
    /// <param name="listOfLists">
    private static void DisplayResults
      (IEnumerable<Dictionary<string, string>> listOfLists)
    {
      #region was
      //var i = 0;
      //var text = "";
      //foreach (var dic in listOfLists)
      //{
      ////  if (i == reportsListBox.Items.Count) break;
      //  text += GetDisplayString(dic, reportsListBox.Items[i++].ToString());
      //}
      #endregion was
      var i = 0;
      var
        x = listOfLists.Aggregate("", (current, dic) => current +
        GetDisplayString(dic, OPS.Default.reportsListBoxItems[i++]));

      const string t = "";
      var s = AUS.Default.OMA_D4_S;
      var l = AUS.Default.OMA_D4_L;
        DisplayResults(x, t, ref s, ref l);
      AUS.Default.OMA_D4_S = s;
      AUS.Default.OMA_D4_L = l;
      AUS.Default.Save();
    }

    /// <summary> This overload is where all end up.
    /// It allows for total flexibility of usages for all args.
    /// While providing critical defaults to reduce duplicity.
    /// if title is empty it defaults to:
    /// "Folder Associations Information:"
    /// 
    /// <param name="x">
    /// <param name="t">
    /// <param name="s">
    /// <param name="l">
    private static void DisplayResults
      (string x, string t, ref Size s, ref Point l)
    {
      if (string.IsNullOrEmpty(t)) t =
        "Folder Associations Information:";
      using (var f = new ShowMeForm(x, t))
      {
        f.Size     = s;
        f.Location = l;
          f.ShowDialog();
        l = f.Location;
        s = f.Size;
      }
    }

    /// <summary> This was split out so it can be used by both
    /// the View2Associations and the ViewAllAssociations: v4.7.3.75
    /// Added the string dir arg to the sig to interface it with both.
    /// 
    /// <param name="dic">
    /// <param name="dir">
    /// <returns>
    private static string GetDisplayString
      (Dictionary<string, string> dic, string dir)
    { // Sweet! Great integration.
      #region Was
      //foreach (var pair in list)
      //{
      //  // Concatenate the text string and show it.
      //  text += "The Data Folder:\n" + pair.Key +
      //    "\n\nWhich is set to the Data file: \n" +
      //    pair.Value + "\n\n";
      //}
      #endregion Was
      string
        title = string.Format("\nResults for: {0}\n\n", dir),
        text  = title +
          "The following currently use this Reports Folder:\n\n";
      return
        dic.Aggregate(text, (current, pair) => current +
          ("The Data Folder:\n" + pair.Key +
            "\n\nWhich is set to the Data file: \n" +
              pair.Value + "\n\n"));
    }
// Whereever it says .Aggregate here are good examples and it can be many Types.

// Take the first one:
// var x = listOfLists.Aggregate blah blah...
// Think for a minute what that is doing, it's iterating through a Collection of Dictionary Collections and getting the appropriate string for each and very very rapidly and efficiently!
// Follow the code path through that down to this other one above and you will see what I mean. From the Collection of Dictionaries down to this does a LOT. 

Dim a(0) As String
Dim l As New List(Of String)
Dim al As New ArrayList
Dim atimer As New DateTime
Dim ltimer As New DateTime
Dim altimer As New DateTime
Dim atime As Integer
Dim ltime As Integer
Dim altime As Integer
Dim iterations As Integer = 1000000
ReDim a(iterations)
Dim finish As DateTime
Dim read As Integer
For x = 0 To iterations
    l.Add(0)
    al.Add(0)
    a(x) = 0

Next
altimer = Now
For x = 0 To iterations
    al(x) = x
    read = al(x)
Next
finish = Now
altime = (finish.Second - altimer.Second) * 1000 + finish.Millisecond - altimer.Millisecond
Console.WriteLine("Start Time = " & altimer.Second & "." & altimer.Millisecond)
Console.WriteLine("Finish Time = " & finish.Second & "." & finish.Millisecond)
Console.WriteLine("Array List Time = " & altime)
atimer = Now
For x = 0 To iterations
    a(x) = x
    read = a(x)
Next
finish = Now
atime = (finish.Second - atimer.Second) * 1000 + finish.Millisecond - atimer.Millisecond
Console.WriteLine("Start Time = " & atimer.Second & "." & atimer.Millisecond)
Console.WriteLine("Finish Time = " & finish.Second & "." & finish.Millisecond)
Console.WriteLine("Array Time = " & atime.ToString)

ltimer = Now
For x = 0 To iterations
    l(x) = x
    read = l(x)
Next
finish = Now
ltime = (finish.Second - ltimer.Second) * 1000 + finish.Millisecond - ltimer.Millisecond
Console.WriteLine("Start Time = " & ltimer.Second & "." & ltimer.Millisecond)
Console.WriteLine("Finish Time = " & finish.Second & "." & Format(finish.Millisecond, "000"))
Console.WriteLine("List Time = " & ltime)