.NET Collections - Part Two - Generic Collections List<T>

This blog shows how to - Create a List and perform Add, Remove, Sort, Search, and other operations on List.

List is a generic collection that is defined in the System.Collection.Generic namespace. List<T> is used to store a collection elements or objects in the form of a list. It reflects a strongly typed index-accessible list of objects. The List class provides functionality to search, sort, and manipulate list elements. It offers the same features as ArrayList, but the only distinction is that-list is a generic collection while ArrayList is a non-generic collection.

 

The size of the list increases as needed. The ICollection < T >, IEnumerable < T >, IList < T >, IReadOnlyCollection < T >, IReadOnlyList < T >, ICollection, IEnumerable, and IList interface are implemented in the List class.

 

It can recognize null as a valid reference type value and enables duplicate components as well. If the count becomes equivalent to the capability, the size of the list will automatically increase by reallocating the inner array.

 

Before adding the new element, the current components will be transferred to the fresh array. The elements in the list are not sorted by default and zero-based index access to the elements.

 

A List class has 3 constructors to generate a list, and the constructors are as follows,

1. List<T>()
   This constructor is used to create an instance of the List<T> class that is empty and has the default initial capacity.
   
   
2. List<T>(Int32)
   This constructor is used to create an instance of the List<T> class that is empty and has the specified initial capacity.
   
   
3. List<T>(IEnumerable)
   This constructor is used to create an instance of the List<T> class that contains elements copied from the specified collection and has enough capacity to accommodate the number of elements copied.

We can use either of the 3 above constructors depending on the best fit to the requirement to create a new list.

 

Please refer to the below code which shows all the operations we can perform on List<T>.

public class ListsCollection
   {
       public static void Main()
       {
           // Creating list using List class
           // and List<T>() Constructor
           List<int> numberList = new List<int>();

           // Adding elements to List
           // Using Add() method
           numberList.Add(3);
           numberList.Add(5);
           numberList.Add(10);
           numberList.Add(8);
           numberList.Add(15);
           numberList.Add(66);
           numberList.Add(99);

           //AddRange(IEnumerable<T>) - Adding multiple elements to List

           List<int> numberList2=new List<int>();
           numberList2.AddRange(numberList);

           // Accessing elements of numberList
           // Using foreach loop
           foreach (int listitem in numberList)
           {
               Console.WriteLine(listitem);
           }

           // Get List count
           Console.WriteLine($"List count:{numberList.Count}");

           // Remove() method to remove the list item - using list value
           numberList.Remove(10);
           Console.WriteLine($"List count:{numberList.Count}");

           // RemoveAt() method to remove the list item - using list index
           numberList.RemoveAt(4);
           Console.WriteLine($"List count:{numberList.Count}");

           // RemoveRange() method - Remove range of elements from list
           numberList.RemoveRange(0, 2);
           Console.WriteLine($"List count:{numberList.Count}");

           // Clear() method - removes all the items from List
           numberList.Clear();
           Console.WriteLine($"List count:{numberList.Count}");

           // Sort method - Sorts listitems
           numberList.Sort();

           Console.WriteLine("Sorted List:");
           foreach (int listitem in numberList)
           {
               Console.WriteLine(listitem);
           }
    }
}