Overview Of Collection, Array List, Hash Table, Sorted List, Stack And Queue

Collections

In many applications we need to create and manage groups of related objects. There are two ways to do it, either by creating an array of objects or by creating a collection of objects.

Arrays are most useful for creating a fixed number of strongly typed objects.

Collections provide a more flexible way to work with groups of objects and the group of objects you work with can grow and shrink dynamically as the needs of the application change. It also allows access to a list of items using an index. C# collections classes are defined as part of the System.Collections. So first we need to use the System.Collections namespace.

Various Collections Classes and Their Usage

The following are the various commonly used classes of the System.Collections namespace.

 

ArrayList

ArrayList represents an ordered collection of a specified object that can be indexed individually. It allows dynamic memory allocation, adding, searching and sorting items in the list.

The following are the properties of the ArrayList class:

1. Capacity: Gets or sets the number of elements that the ArrayList can contain.
   
2. Count: Returns the number of elements present in the ArrayList.
   
3. IsFixedSize: Returns a value indicating whether the ArrayList has a fixed size.
   
4. IsReadOnly: Returns a value indicating whether the ArrayList is read-only.
   
5. Item: Gets or sets the element at the specified index position.

The following are the methods of the ArrayList class,

1. public virtual int add(object value); Inserts the object at the end of the ArrayList.
   
2. public virtual void AddRange(Icollection c); Adds the elements of a collection to the end of the ArrayList.
   
3. public virtual void Clear(); Removes all the elements from the ArrayList. Does not affect the capacity of the ArrayList.
   
4. public virtual bool Contains(object item); Determines whether an element is present or not in the ArrayList.
   
5. public virtual ArrayList GetRange( int index, int count ); Returns an ArrayList that represents a subset of the elements in the source ArrayList.
   
6. public virtual int IndexOf(object); Returns the index of the first occurrence of a value in the ArrayList or in a portion of it.
   
7. public virtual void Insert(int index, object value); Inserts an element into the ArrayList at the specified index.
   
8. public virtual void InsertRange(int index, ICollection c); Inserts the element of a collection into the ArrayList at the specified index.
   
9. Public virtual void Remove(object obj); Removes the first occurrence of a specified object from the ArrayList.
   
10. public virtual void RemoveAt(int index); Removes the element at the given specified index of the ArrayList.
    
11. public virtual void RemoveRange(int index,int count); Removes a range of elements from the ArrayList.
    
12. public virtual void Reverse(); Reverses the order of the elements in the ArrayList.
    
13. public virtual void Sort(); Sorts all the elements in the ArrayList.
    
14. public virtual void TrimToSize(); Sets the capacity to the actual number of elements present in the ArrayList. Basically the capacity is not increased one by one. Capacity is just doubled each time whenever the size reaches the threshold. So the TrimToSize() method sets the capacity to the exact the size of the ArrayList.

The following is the example,

using System;
using System.Collections;

namespace Collection_Example
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList al = new ArrayList();
            ArrayList al1 = new ArrayList();
            // Adding object into the ArrayList
            al1.Add('a');
            al1.Add('b');
            al.Add('k');
            al.Add('l');
            al.Add('j');
            // Adding Arraylist at specific position into the ArrayList
            al.InsertRange(2,al1);
            //Get the Capacity and number of element present in the ArrayList
            // Note that Capacity and Count are not equal
            Console.WriteLine("Count: {0}", al.Count);
            Console.WriteLine("Capacity before TrimToSize: {0} ", al.Capacity);
            al.TrimToSize();
            Console.WriteLine("Capacity after TrimToSize: {0} ", al.Capacity);
            Console.WriteLine(al.Contains('b'));
            Console.Write("Element befor sort: ");
            foreach (object obj in al)
                Console.Write(obj + " ");
            Console.Write("\nElement after sort: ");
            al.Sort();
            foreach (object obj in al)
                Console.Write(obj + " ");
            al.Reverse();
            Console.Write("\nElement after reverse: ");
            foreach (object obj in al)
                Console.Write(obj + " ");
            Console.WriteLine("\nIndex of char 'k' is : {0}", al.IndexOf('k'));
            // clear the ArrayList
            al.Clear();
            Console.WriteLine("\nCount: {0}", al.Count);
            Console.ReadKey();
        }
    }
}

Output

 

HashTable

The Hashtable class represents a collection of key-and-value pairs organized based on the hash code of the key. It uses the key to access the elements in the collection. Hash table is used when you need to access elements using a key. Each item in the hash table has a key/value pair. The key is used to access the items in the collection.

The following are the properties of HashTable class,

1. Count: Returns the number of elements present in the Hashtable.
   
2. IsFixedSize: Returns a value indicating whether the Hashtable has a fixed size.
   
3. IsReadOnly: Returns a value indicating whether the Hashtable is read-only.
   
4. Item: Gets or sets the value with the specific key.
   
5. Keys: Returns an ICollection containing the keys in the HashTable.
   
6. Values: Returns an ICollection containing the values in the HashTable.

The following are the methods of the HashTable Class,

1. public virtual void add(object key,object value); Adds a value with the specified key into the HashTable.
   
2. public virtual void Clear(); Clears the HashTable.
   
3. public virtual bool ContainsKey(object key); Determines whether the HashTable contains a specific key, if Yes then returns true otherwise it returns false.
   
4. public virtual bool ContainsValue(object key); Determines whether the HashTable contains a specific value, if Yes then returns true otherwise it returns false.
   
5. public virtual void Remove(object key); Removes an element with the specific key from the HashTable.

The following is the example:

using System;
using System.Collections;

namespace Collection_Example
{
    class Program
    {
        static void Main(string[] args)
        {
            Hashtable ht = new Hashtable();
            //Adding item into HashTable
            ht.Add(1, "Alwar");
            ht.Add(12, "Ajmer");
            ht.Add(8, "Jaipur");
            ht.Add(4, "Kota");
            Console.WriteLine("Count : {0}", ht.Count);
            if (ht.ContainsValue("Sikar"))
                Console.WriteLine("Sikar is already exist in the HashTable");
            else
                ht.Add(5, "Sikar");

            //Get a collection of values
            Console.WriteLine("Values are :");
            ICollection values = ht.Values;
            foreach (string str in values)
                Console.WriteLine(str);
            //Get a collection of Keys
            Console.WriteLine("Keys are :");
            ICollection keys = ht.Keys;
            foreach (int i in keys)
                Console.WriteLine(i);
            ht.Remove(3);
            ht.Clear();
            Console.ReadKey();
        }
    }
}

Output

 

SortedList

SortedList represents a collection of key-value pairs sorted by the keys and are accessible by key and by index. A sorted list is a combination of an array and a hash table. It contains a list of items that can be accessed using a key or an index. Note that SortedList is always sorted by the key value.

The following are the properties of the SortedList class,

1. Capacity: Gets or sets the number of elements that the SortedList can contain.
   
2. Count: Returns the number of elements present in the SortedList.
   
3. IsFixedSize: Returns a value indicating whether the SortedList has a fixed size.
   
4. IsReadOnly: Returns a value indicating whether the SortedList is read-only.
   
5. Item: Gets or sets the value associated with a specific key in the SortedList.
   
6. Keys: Returns an ICollection containing the keys in the SortedList.
   
7. Values: Returns an ICollection containing the values in the SortedList.

Method of the SortedList Class

1. public virtual void add(object key , object value); Adds a value with the specified key into the SortedList.
   
2. public virtual void Clear(); Clears the SortedList.
   
3. public virtual bool ContainsKey(object key); Determines whether the SortedList contains a specific key, if Yes then returns true otherwise it returns false.
   
4. public virtual bool ContainsValue(object key); Determines whether the SortedList contains a specific value, if Yes then returns true otherwise it returns false.
   
5. public virtual object GetByIndex(int index); It returns the value at the specified index of the SortedList.
   
6. public virtual object GetKey(int index); Returns the key at the specified index of the SortedList.
   
7. public virtual IList GetKeyList(); Gets the keys in the SortedList.
   
8. public virtual IList GetValueList(); Gets the values in the SortedList.
   
9. public virtual int IndexOfKey(object key); Gets the index of the specified key in the SortedList.
   
10. public virtual int IndexOfValue(object value); Gets the index of the first occurrence of the specified value in the SortedList.
    
11. public virtual void Remove(object key); Remove an element with the specific key from the SortedList.
    
12. public virtual void RemoveAt(int index); Removes the element at the specified index of SortedList.

The following is the example,

using System;
using System.Collections;

namespace Collection_Example
{
    class Program
    {
        static void Main(string[] args)
        {
            SortedList sl = new SortedList();
            //Adding item into HashTable
            sl.Add(1, "Alwar");
            sl.Add(12, "Ajmer");
            sl.Add(8, "Jaipur");
            sl.Add(4, "Kota");
            Console.WriteLine("Count : {0}", sl.Count);
            if (sl.ContainsValue("Sikar"))
                Console.WriteLine("Sikar is already exist in the SortedList");
            else
                sl.Add(5, "Sikar");
            Console.WriteLine("Value and key at position 2 is {0} , {1}", sl.GetByIndex(2), sl.GetKey(2));
            Console.Write("keys are : ");
            foreach (int i in sl.Keys)
                Console.Write(i + " ");
            sl.Remove(3);
            //Geting the keys and value from SortedList
            IList keys = sl.GetKeyList();
            IList values = sl.GetValueList();
            Console.WriteLine("\nValues are :");
            foreach (object obj in values)
                Console.WriteLine(obj);
            Console.WriteLine("Index of Ajmer is : {0}", sl.IndexOfValue("Ajmer"));
            // Remove an element at specified index
            sl.RemoveAt(2);
            Console.ReadKey();
        }
    }
}

Output

 

Stack

A Stack is a Last In First Out (LIFO) collection of objects. A Stack is used when you need last-in, first-out access to the objects. That means accessing the last inserting item. A Stack basically consists of two operations, Push and Pop. When you insert an element into the stack, it is called pushing the item and when you extract the item from the stack, it is called popping the item. Both Push and Pop are done at the top of the stack. To use the Stack data type in C# first you need to use the System.Collections namespace.

The following are the properties of Stack:

1. Count: Returns the number of elements in the stack.

The following are the methods of stack:

1. public virtual void Push(object obj); Simply inserts an object at the top of the stack.
   
2. public virtual object Pop(object obj); Simply removes and returns the object from the top of the stack.
   
3. public virtual void Clear(); Clears the stack. Removes all the elements from the stack.
   
4. public virtual object Peek(); Returns the objects from the top of the stack (without removing).
   
5. public virtual object[] ToArray(); Copies the stack into an object array.
   
6. public virtual bool Contains(object obj); Checks whether an element exists in the stack. Returns True when an item exists in the stack otherwise it returns False.

The following is the example,

using System;
using System.Collections;

namespace Test_Cdac
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaring a stack
            Stack st = new Stack();
            // Inserting an element at the top of stack i.e. Push operation
            st.Push("Pankaj");
            st.Push(1);
            st.Push(10.5);
            st.Push(true);
            st.Push('A');
            //Get the number of elements contained in the stack
            Console.WriteLine("Count : {0}", st.Count);
            Console.WriteLine();
            //Printing all the element of stack
            Console.WriteLine("Element in stack : ");
            foreach (object obj in st)
                Console.WriteLine(obj);
            Console.WriteLine();
            //Returns the topmost element of the stack without removing
            Console.WriteLine("Top most element of stack : {0}", st.Peek());
            Console.WriteLine();
            //Removes and Returns the topmost element of the stack i.e. Pop operation
            object TopElement = st.Pop();
            Console.WriteLine("Removing Top element of Stack = {0}\nNow Top element of stack = {1}\n", TopElement, st.Peek());
            //Determines whether an element present or not in the stack
            if (st.Contains("Pankaj"))
                Console.WriteLine("Pankaj Found");
            else
                Console.WriteLine("Pankaj Not found");
            //Copies the stack to a new Array(object)
            Object[] ob=st.ToArray();
            Console.WriteLine();
            foreach (object obj in ob)
                Console.WriteLine(obj);
            //Removes all the element from stack
            st.Clear();
            Console.WriteLine();
            Console.WriteLine("Count : {0}", st.Count);
            Console.ReadKey();
        }
    }
}

Output

 

Queue

A Queue is a First-In-First-Out (FIFO) collection of objects. Queue is used when you need first-in, first-out access to objects. That means accessing the first inserting item. A Queue basically consists of two operations, Enqueue and Dequeue. When you insert an element into a Queue, it is called Enqueue and when you extract an item from the Queue, it is called Dequeue. The Enqueue operation is done at the end of the queue and the Dequeue operation is done at end of the queue. To use the Queue data type in C# you need to use the System.Collections namespace.

The following is the property of Queue,

1. Count: Returns the number of elements in the Queue.

The following are the methods of Queue,

1. public virtual void Enqueue(object obj); Simply inserts an object at the end of the queue.
   
2. public virtual object Dequeue(object obj); Simply removes and returns the object from the front of the queue.
   
3. public virtual void Clear(); Clears the queue. This method removes all the elements from the queue.
   
4. public virtual object Peek(); This method returns the object from the front of the queue (without removing).
   
5. public virtual object[] ToArray(); Copies the queue into an object array.
   
6. public virtual bool Contains(object obj); Checks whether an element exists in the queue. Returns True when the item exists in the queue otherwise it returns False.
   
7. public virtual void TrimToSize(); Sets the capacity to the actual number of elements present in the Queue. Basically the capacity is not increased one by one. Capacity is just doubled each time whenever the size reaches the threshold. So the TrimToSize() method sets the capacity to the exact the size of the queue.

The following is the example,

using System;
using System.Collections;

namespace Teq_Cdac
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaring a Queue
            Queue q = new Queue();
            // Adds an element at the end of Queue i.e. Enqueue operation
            q.Enqueue("Pankaj");
            q.Enqueue(1);
            q.Enqueue(10.5);
            q.Enqueue(true);
            q.Enqueue('A');
            //Get the number of elements present in the Queue
            Console.WriteLine("Count : {0}", q.Count);
            Console.WriteLine();
            //Printing all the element of Queue
            Console.WriteLine("Element in Queue : ");
            foreach (object obj in q)
                Console.WriteLine(obj);
            Console.WriteLine();
            //Returns the end of the Queue without removing
            Console.WriteLine("End element of Queue : {0}", q.Peek());
            Console.WriteLine();
            //Removes and Returns the end element of the Queue i.e. Dequeue operation
            object TopElement = q.Dequeue();
            Console.WriteLine("Removing End element of Queue = {0}\nNow End element of Queue = {1}\n", TopElement, q.Peek());
            //Determines whether an element present or not in the Queue
            if (q.Contains("Pankaj"))
                Console.WriteLine("Pankaj Found");
            else
                Console.WriteLine("Pankaj Not found");
            //Copies the qack to a new Array(object)
            Object[] ob=q.ToArray();
            Console.WriteLine();
            foreach (object obj in ob)
                Console.WriteLine(obj);
            //Trim the Queue
            q.TrimToSize();
            //Removes all the element from Queue
            q.Clear();
            Console.WriteLine();
            Console.WriteLine("Count : {0}", q.Count);
            Console.ReadKey();
        }
    }
}

Output