how to find no of duplicate values in arraylist

here is a great post how to do it with LINQ

var query =
    from c in arrayList
    group c by c into g
    where g.Count() > 1
    select new { Item = g.Key,  ItemCount = g.Count()};

foreach (var item in query)
{
    Console.WriteLine("Country {0} has {1} cities", item.Item , item.ItemCount );
}

If your object has equals method correctly overrided just call Distinct() from System.Linq namespace on it

It requires the ArrayList to be homogeneous and calling Cast<YourType>() before Distinct().

Then subtract the length of arrayList from the Distinct sequence.

arraList.Count - arraList.Cast<YourType>().Distinct().Count()

it will throw exception if your items in arrayList is not of type YourType, and if you use OfType<YourType> it filters items to objects of type YourType.

but if you want the count of each repeated item, this is not your answer.

public Dictionary<T,int> CountOccurences<T>(IEnumerable<T> items) {
  var occurences = new Dictionary<T,int>();
  foreach(T item in items) {
    if(occurences.ContainsKey(item)) {
      occurences[item]++;
    } else {
      occurences.Add(item, 1);
    }
  }
  return occurences;
}

myList.GroupBy(i => i).Count(g => g.Count() > 1)

and if you specifically need ArrayList

ArrayList arrayList = new ArrayList(new[] { 1, 1, 2, 3, 4, 4 });
Console.WriteLine(arrayList.ToArray().GroupBy(i => i).Count(g => g.Count() > 1));

Based on comments by poster

ArrayList arrayList = new ArrayList(new[] { 1, 1, 2, 3, 4, 4 });
Console.WriteLine(arrayList.ToArray().Count(i => i == 4));

int countDup = ArrayList1.Count - ArrayList1.OfType<object>().Distinct().Count();

var items = arrayList.Cast<object>()
  .GroupBy(o => o)
  .Select(g => new { Item = g, Count = g.Count() })
  .ToList();

each item of result list will have two properties: Item - source item Count - count in source list

You can acomplish this many ways. The first that comes to me would be to group by the values within your array list, and only return the grouping counts that are over 1.

ArrayList al = new ArrayList();
al.Add("a");
al.Add("b");
al.Add("c");
al.Add("f");
al.Add("a");
al.Add("f");

int count = al.ToArray().GroupBy(q => q).Count(q=>q.Count()>1);

count will return the value of 2 as a and f are duplicated.

You could sort it, then it becomes very easy.

Edit: sorting becomes a moot point when done this way.

Arraylist myList = new ArrayList();

myList = someStuff;
Dictionary<object, int> counts = new Dictionary<object,int>();
foreach (object item in myList)
{
    if (!counts.ContainsKey(item))
    {
       counts.Add(item,1);
    }
    else
    {
       counts[item]++;
    }

}

Edit:

Some minor things might vary (not certain about some of my square braces, I'm a little rusty with c#) but the concept should withstand scrutiny.