Advertisement

---

Top

< Prev

Next >

List<T> is a generic collection class which is used to store a collection of single type of objects that can be accessed by index. The List<T> collection class that implements IEnumerable, IEnumerable<T>, and ICollection interfaces and it is defined in the System.Collections.Generic namespace.

Just like a standard array, List<T> is also used to store similar elements. In the case of a standard array, we must declare its size before we use it and once its size is declared, it's fixed. While List<T> is like a dynamic array i.e. we don't need to declare its size, it grows as we add elements to it and it shrinks as we remove elements from it, during the runtime of the program.

Note:
List<T> provides functionality similar to that found in the non-generic ArrayList class.

Important features of List<T>.



• List<T> is internally an implementation of an array which is dynamic in nature.
• Duplicate elements are allowed.
• Maintains an order in which elements are inserted in the List<T>.
• List<T> supports fast random access and quick iteration(access) of elements.
• We could use the for loop or foreach loop to iterate over the elements of a List<T>.

Constructors of List<T>:

Constructors	Description
List<T>()	This constructor of List<T> creates an empty List<T> and has the default initial capacity. The capacity of a List<T> is the number of elements it can hold, as the new elements are added to the List<T>, its capacity is automatically increased.
List<T>(IEnumerable<T>)	This constructor creates a List<T> initialized with the elements of an IEnumerable<T> collection.
List<T>(int capacity)	This constructor initializes created a List<T> that is empty and has the specified initial capacity..

Properties of List<T>:

Properties	Description
Capacity	This property is used to get or set the total number of elements a List<T> can hold.
Count	This property gives total number of elements in a List<T>.
IList.IsFixedSize	This property determines whether a List<T> has a fixed size or not.
IList.IsReadOnly	This property determines whether a List<T> is read-only or not.
IsSynchronzied	This property determines whether a List<T> is thread-safe or not.
Item[int index]	This property gets or sets an item of List<T> at a specified index. To use this property, you should not type Item, but you only need to specify the specific key within a pair of square brackets [ ].
IList.Item[int index]	This property gets or sets an item of List<T> at a specified index.

Some commonly used methods of List<T> class

Methods	Description
int Add(T object)	This method adds the specified object at the end of a List<T> and returns its index.
bool Contains(T object)	This method checks if List<T> contains a specific object.
void Clear()	This method removes all of the elements from the List<T>.
List<T>.Enumerator GetEnumerator()	This method returns to enumerate the entire List<T>.
int IndexOf(T object)	This method searches for the specified object and returns the zero-based index of the first occurrence within the entire List<T>.
int LastIndexOf(T o)	This method searches for the specified object and returns the zero-based index of the last occurrence within the entire List<T>.
bool Remove(T object)	This method removes the first occurrence of an object from the List<T>, if it is present.
bool RemoveAt(int index)	This method removes an element at a specified index in a List<T>.
T[] ToArray()	This method returns an array of type of List<T>, containing all the elements of the List<T>.
void Sort()	This method sorts a List<T>.
void Reverse()	This method reverses the order of the elements of a List<T>.

Advertisement

Creating a List<T> and displaying its features.

In the upcoming program, we will perform the following operations:
• In this program we have created a List<T> to hold String objects, by specifying them within double quotes " ".
• We will add/remove some of its elements from this List<T>.
• We will print the elements of a List<T> and display its current size of elements.
• We will display its initial capacity at the beginning of a program execution and its current capacity at a later stage.

//C# Example of List<T>


using System;
using System.Collections.Generic;

class ListEx
{
public static void Main(String[] ar)
{
	//Creating a List<T> of type List<String> to hold String objects.
	List<String> list = new List<String>();
	
	//Printing the initial capacity of a List<T>
	Console.WriteLine("Initial capacity of List<String> = "+ list.Capacity);

	//Adding String objects to List<String> by Add() method
	list.Add("C");
	list.Add("A");
	list.Add("1");
	list.Add("F");
	list.Add("Bye");
	list.Add("Hello");

	//Printing the elements of a List<String>, using for loop
	Console.Write("List<String> after adding String objects: ");
	for(int i=0;i<list.Count;i++)
		Console.Write(list[i]+ " ");

	//Printing the total number of elements in a List<String>.
	Console.WriteLine("\nSize of List<String> = "+ list.Count);

	//Removing an element at the 4th index of List<String>
	Console.WriteLine("Removing an element at 4th Index of List<String>");
	list.RemoveAt(4);	

	//Removing an element "1" of the List<String>
	Console.WriteLine("Removing an element 1 of List<String>");
	list.Remove("1"); 

	//Printing the elements of a List<String>, using foreach loop
	Console.Write("An updated List<String>: ");
	for(int i = 0; i<list.Count; i++)
		Console.Write(list[i] + " ");

	//Printing the total number of elements in a List<String>.
	Console.WriteLine("\nSize of List<String> = "+ list.Count);

	//Printing the current capacity of a List<String>
	Console.WriteLine("Current capacity of List<String> = "+ list.Capacity);
}
}

Output is - :

Initial capacity of List<String> = 0
List<String> after adding String objects: C A 1 F Bye Hello
Size of List<String> = 6
Removing an element at 4th Index of List<String>
Removing an element 1 of List<String>
An updated List<String>: C A F Hello
Size of  List<String> = 4

Program Analysis

• The property Capacity is called to check the initial capacity of a List<T>, after it is created and it returns zero(0), because for a List<T> created this way, its capacity is automatically increased as the new elements are added to it.
• The method Add() is called to add the int elements to the List<T>.
• The elements of a List<T> are printed by using a for loop and using the Count property of List<T>.
• The method Remove(Object o) is called to remove a specific element from the List<T>.
• The method RemoveAt(int index) is called to remove element from a specific index of the List<T>.

Iterating over List<T> within foreach loop.

In the last program, we have iterated over a List<T> using the for loop and we could also do the same by using the foreach loop, let us see how.



//C# Iterating over the elemets of List<T> using foreach loop


using System;
using System.Collections.Generic;

class ListEx
{
public static void Main(String[] ar)
{
	//Creating a List<T> of type List<String> to hold String objects.
	List<String> list = new List<String>();
	
	//Printing the initial capacity of a List<T>
	Console.WriteLine("Initial capacity of List<String> = "+ list.Capacity);

	//Adding String objects to List<String> by Add() method
	list.Add("Hi");
	list.Add("Hello");
	list.Add("Bonjour");
	list.Add("Salut");
	list.Add("Buna");

	//Printing the elements of a List<String>, using foreach loop
	Console.WriteLine("The contents of List<String> objects: ");
	foreach(String ob in list)
		Console.WriteLine(ob + " ");

	//Printing the total number of elements in a List<String>.
	Console.WriteLine("Size of List<String> = "+ list.Count);
}
}





Output is - :




Initial capacity of List<String> = 0
The contents of List<String> objects:
Hi
Hello
Bonjour
Salut
Buna
Size of List<String> = 5








Creating a new List<T> from an existing List<T>


In this program we will create a List<T> that holds int values and because C# has a unified type system, so any primitive values like int, char, float, etc are implicitly boxed into an Object reference.

Next, we will create and initialize a new List<T> using the contents of the existing List<T>.



//C# Example of creating a new List<T> created from an existing one

using System;
using System.Collections.Generic;

class ListEx
{
public static void Main(String[] ar)
{
	//Creating a List<T> of type List<int> to hold int
	//which are implicitly converted to objects.
	List<int> list1 = new List<int>();
	

	//Adding elements to a List<int> by Add() method
	list1.Add(4);
	list1.Add(1);
	list1.Add(5);
	list1.Add(2);
	list1.Add(3);


	//Printing the elements of a List<int>, using for loop with Count property

	Console.WriteLine("List<int> after adding objects: ");
	for(int i = 0; i<list1.Count; i++)
		Console.WriteLine(list1[i] + " ");

	//Printing the total number of elements in a List<int>.
	Console.WriteLine("Size of List<int> = "+ list1.Count);


	Console.WriteLine("Creating a new List<int> created from an existing one");

	//Calling a constructor of List<int>
	//Which creates a new List<int>, initialized from an existing one
	List<int> list2= new List<int>(list1);


	
	//Printing the elements of a List<int>, using foreach loop
	Console.WriteLine("Contents of the new List<int>: ");
	for(int i = 0; i<list2.Count; i++)
		Console.WriteLine(list2[i] + " ");

	//Printing the total number of elements in a List<int>.
	Console.WriteLine("Size of the new List<int> = "+ list2.Count);
}
}





Output is - :




List<int> after adding objects:
4
1
5
2
3
Size of List<int> = 5
Creating a new List<int> created from an existing one
Contents of the new List<int>:
4
1
5
2
3
Size of the new List<int> = 5








Converting a List<T> to an Object array using ToArray() method.




//C# Converting a List<T> to an array of the T type of List<T> by callin the ToArray() method.

using System;
using System.Collections.Generic;

class ListEx
{
public static void Main(String[] ar)
{
	//Creating a List<T> of type List<char> to hold characters 
	List<char> list1 = new List<char>();


	//Adding char elements to a List<char> by Add() method
	list1.Add('x');
	list1.Add('e');
	list1.Add('a');
	list1.Add('f');
	list1.Add('b');


	//Printing the elements of a List<char>, using foreach loop
	Console.WriteLine("List<char> after adding objects: ");
	for(int i = 0; i<list1.Count; i++)
		Console.WriteLine(list1[i]);

	//Printing the total number of elements in a List<char>.
	Console.WriteLine("Size of List<char> = "+ list1.Count);


	//By calling the ToArray() method
	//which converts a List<char> to an char array.
	char[] obArr = list1.ToArray();

	Console.WriteLine("Creating an array of type of List<char> created from List<char> - ");

	//Iterating over the elements of Object array, using for loop
	Console.WriteLine("The elements of Object array: ");
	foreach(char ch in obArr)
		Console.WriteLine(ch);
}
}





Output is - :




List<char> after adding objects:
x
e
a
f
b
Size of List&;t;char> = 5
Creating an array of type of List<char> created from List<char> -
The elements of Object array:
x
e
a
f
b


We have created an char array from an existing List<char> by calling the ToArray() method of List<T> class. Next, we have displayed the elements in this char array using a foreach loop.










Sorting a List<T>.


Calling the Sort() method of List<T> to sort its elements.



//C# Using the Sort() method of List<T>

using System;
using System.Collections.Generic;

class ListEx
{
public static void Main(String[] ar)
{
	//Creating a List<T> of type List<int> to hold int
	//which are implicitly converted to objects.
	List<int> list1 = new List<int>();
	

	//Adding elements to a List<int> by Add() method
	list1.Add(4);
	list1.Add(1);
	list1.Add(5);
	list1.Add(2);
	list1.Add(3);

.
	//Printing the elements of a List<int>, using foreach loop
	//We could used the for loop with Count property
	Console.WriteLine("List<int> after adding objects: ");
	foreach(int element in list1)
		Console.WriteLine(element);

	//Printing the total number of elements in a List<int>.
	Console.WriteLine("Size of List<int> = "+ list1.Count);


	//Sorting the elements of List<int> by calling its ToSort() method
	list1.Sort();

	Console.WriteLine("Sorted List<int>: ");

	//Iterating over the elements of sorted List<T>, using foreach loop
	//We could've used the for loop as well.
	foreach(int element in list1)
		Console.WriteLine(element);
}
}





Output is - :




<code>List<int> after adding objects:
4
1
5
2
3
Size of List<int> = 5
Sorted List<int>:
1
2
3
4
5








Reversing a List<T>.


Calling the Reverse() method of List<T> to reverse the order of elements in a List<T>.



//C# Using the Reverse() method of List<T>


using System;
using System.Collections.Generic;

class ListEx
{
public static void Main(String[] ar)
{
	//Creating a List<T> of type List<String> to hold String objects
	List<String> list1 = new List<String>();
	

	//Adding String objects to a List<String> by calling its Add() method
	list1.Add("4");
	list1.Add("A");
	list1.Add("x");
	list1.Add("E");
	list1.Add("r");


	//Printing the elements of a List<String>, using foreach loop
	//We could used the for loop with Count property
	Console.WriteLine("List<String> after adding objects: ");
	foreach(String element in list1)
		Console.WriteLine(element);

	//Printing the total number of elements in a List<String>.
	Console.WriteLine("Size of List<String> = "+ list1.Count);


	//Reversing the order of a List<String> by calling its Reverse() method
	list1.Reverse();

	Console.WriteLine("Reversed List<String>: ");

	//Iterating over the elements of our reversed List<String>, using foreach loop
	foreach(String element in list1)
		Console.WriteLine(element);
}
}





Output is - :




List<String> after adding objects:
4
A
x
E
r
Size of List<String> = 5
Reversed List<String>:
r
E
x
A
4







Please share this article -







< Prev
Next >
< C# Generic LinkedList
C# Generic HashSet >



Advertisement