How to get duplicate items from a list using LINQ ?

Question

I'm having a List<string> like:

List<String> list = new List<String>{"6","1","2","4","6","5","1"};`

I need to get the duplicate items in the list into a new list. Now i'm using nested for loop to do this.

The Resulting list will contain {"6","1"}

Is there any idea to do this using LINQ or Lambda expression?

Answer 1

var duplicates = lst.GroupBy(s => s)
    .SelectMany(grp => grp.Skip(1));

Note that this will return all duplicates, so if you want only want to know which items are duplicated in the source list, you could apply Distinct to the resulting sequence or use the solution given by Mark Byers.

Answer 2

Here is one way to do it:

List<String> duplicates = lst.GroupBy(x => x)
                             .Where(g => g.Count() > 1)
                             .Select(g => g.Key)
                             .ToList();

The GroupBy groups the elements that are the same together, and the Where filters out those that only appear once, leaving you with only the duplicates.

Answer 3

Hope this wil help

int[] listOfItems = new[] { 4, 2, 3, 1, 6, 4, 3 };

var duplicates = listOfItems 
    .GroupBy(i => i)
    .Where(g => g.Count() > 1)
    .Select(g => g.Key);

foreach (var d in duplicates)
    Console.WriteLine(d);

Answer 4

Here's another option:

var list = new List<string> { "6", "1", "2", "4", "6", "5", "1" };

var set = new HashSet<string>();
var duplicates = list.Where(x => !set.Add(x));

Answer 5

  List<String> list = new List<String> { "6", "1", "2", "4", "6", "5", "1" };

    var q = from s in list
            group s by s into g
            where g.Count() > 1
            select g.First();

    foreach (var item in q)
    {
        Console.WriteLine(item);

    }

Answer 6

I wrote this extension method based off @Lee's response to the OP. Note, a default parameter was used (requiring C# 4.0). However, an overloaded method call in C# 3.0 would suffice.

  /// <summary>
  /// Method that returns all the duplicates (distinct) in the collection.
  /// </summary>
  /// <typeparam name="T">The type of the collection.</typeparam>
  /// <param name="source">The source collection to detect for duplicates.</param>
  /// <param name="distinct">Specify <b>true</b> to only return distinct elements.</param>
  /// <returns>A distinct list of duplicates found in the source collection.</returns>
  /// <remarks>This is an extension method to IEnumerable&lt;T&gt;</remarks>
  public static IEnumerable<T> Duplicates<T>(this IEnumerable<T> source, bool distinct = true)
  {
     if (source == null)
     {
        throw new ArgumentNullException("source");
     }

     // select the elements that are repeated
     IEnumerable<T> result = source.GroupBy(a => a).SelectMany(a => a.Skip(1));

     // distinct?
     if (distinct == true)
     {
        // deferred execution helps us here
        result = result.Distinct();
     }

     return result;
  }