Usando o LINQ, de a List<int>
, como recuperar uma lista que contém entradas repetidas mais de uma vez e seus valores?
Usando o LINQ, de a List<int>
, como recuperar uma lista que contém entradas repetidas mais de uma vez e seus valores?
Respostas:
A maneira mais fácil de resolver o problema é agrupar os elementos com base em seu valor e escolher um representante do grupo se houver mais de um elemento no grupo. No LINQ, isso se traduz em:
var query = lst.GroupBy(x => x)
.Where(g => g.Count() > 1)
.Select(y => y.Key)
.ToList();
Se você quiser saber quantas vezes os elementos são repetidos, você pode usar:
var query = lst.GroupBy(x => x)
.Where(g => g.Count() > 1)
.Select(y => new { Element = y.Key, Counter = y.Count() })
.ToList();
Isso retornará um List
de um tipo anônimo e cada elemento terá as propriedades Element
e Counter
, para recuperar as informações necessárias.
E, finalmente, se você procura um dicionário, pode usar
var query = lst.GroupBy(x => x)
.Where(g => g.Count() > 1)
.ToDictionary(x => x.Key, y => y.Count());
Isso retornará um dicionário, com seu elemento como chave, e o número de vezes que ele será repetido como valor.
code
for (int i = 0; i <duplicates.Count; i ++) {int duplicate = duplicatas [i]; duplicatesLocation.Add (duplicado, nova List <int> ()); for (int k = 0; k <hitsList.Length; k ++) {if (hitsList [k]. Contém (duplicado)) {duplicatesLocation.ElementAt (i) .Value.Add (k); }} // remove duplicatas de acordo com algumas regras. }code
Descubra se um enumerável contém alguma duplicata :
var anyDuplicate = enumerable.GroupBy(x => x.Key).Any(g => g.Count() > 1);
Descubra se todos os valores em um enumerável são únicos :
var allUnique = enumerable.GroupBy(x => x.Key).All(g => g.Count() == 1);
Outra maneira é usar HashSet
:
var hash = new HashSet<int>();
var duplicates = list.Where(i => !hash.Add(i));
Se você deseja valores únicos na sua lista de duplicatas:
var myhash = new HashSet<int>();
var mylist = new List<int>(){1,1,2,2,3,3,3,4,4,4};
var duplicates = mylist.Where(item => !myhash.Add(item)).Distinct().ToList();
Aqui está a mesma solução que um método de extensão genérico:
public static class Extensions
{
public static IEnumerable<TSource> GetDuplicates<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> selector, IEqualityComparer<TKey> comparer)
{
var hash = new HashSet<TKey>(comparer);
return source.Where(item => !hash.Add(selector(item))).ToList();
}
public static IEnumerable<TSource> GetDuplicates<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
{
return source.GetDuplicates(x => x, comparer);
}
public static IEnumerable<TSource> GetDuplicates<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> selector)
{
return source.GetDuplicates(selector, null);
}
public static IEnumerable<TSource> GetDuplicates<TSource>(this IEnumerable<TSource> source)
{
return source.GetDuplicates(x => x, null);
}
}
List<int> { 1, 2, 3, 4, 5, 2 }
como fonte, o resultado é um IEnumerable<int>
com um elemento com o valor de 1
(onde o valor duplicado correto é 2) #
Console.WriteLine("Count: {0}", duplicates.Count());
diretamente abaixo e ela imprime 6
. A menos que esteja faltando algo sobre os requisitos para esta função, deve haver apenas 1 item na coleção resultante.
ToList
para corrigir o problema, mas isso significa que o método é executado assim que chamado, e não quando você itera os resultados.
var hash = new HashSet<int>();
var duplicates = list.Where(i => !hash.Add(i));
levará a uma lista que inclui todas as ocorrências de duplicatas. Portanto, se você tiver quatro ocorrências de 2 em sua lista, sua lista duplicada conterá três ocorrências de 2, pois apenas uma das 2 pode ser adicionada ao HashSet. Se você deseja que sua lista contenha valores exclusivos para cada duplicata, use este código:var duplicates = mylist.Where(item => !myhash.Add(item)).ToList().Distinct().ToList();
Você consegue fazer isso:
var list = new[] {1,2,3,1,4,2};
var duplicateItems = list.Duplicates();
Com estes métodos de extensão:
public static class Extensions
{
public static IEnumerable<TSource> Duplicates<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> selector)
{
var grouped = source.GroupBy(selector);
var moreThan1 = grouped.Where(i => i.IsMultiple());
return moreThan1.SelectMany(i => i);
}
public static IEnumerable<TSource> Duplicates<TSource, TKey>(this IEnumerable<TSource> source)
{
return source.Duplicates(i => i);
}
public static bool IsMultiple<T>(this IEnumerable<T> source)
{
var enumerator = source.GetEnumerator();
return enumerator.MoveNext() && enumerator.MoveNext();
}
}
Usar IsMultiple () no método Duplicates é mais rápido que Count () porque isso não itera a coleção inteira.
Count()
é pré-calculado e sua solução provavelmente é mais lenta.
Count()
] é basicamente diferente de iterar a lista inteira. Count()
é pré-calculado, mas a iteração de toda a lista não é.
Eu criei uma extensão para responder a isso, você pode incluí-la em seus projetos, acho que isso retorna mais quando você procura por duplicatas na List ou no Linq.
Exemplo:
//Dummy class to compare in list
public class Person
{
public int Id { get; set; }
public string Name { get; set; }
public string Surname { get; set; }
public Person(int id, string name, string surname)
{
this.Id = id;
this.Name = name;
this.Surname = surname;
}
}
//The extention static class
public static class Extention
{
public static IEnumerable<T> getMoreThanOnceRepeated<T>(this IEnumerable<T> extList, Func<T, object> groupProps) where T : class
{ //Return only the second and next reptition
return extList
.GroupBy(groupProps)
.SelectMany(z => z.Skip(1)); //Skip the first occur and return all the others that repeats
}
public static IEnumerable<T> getAllRepeated<T>(this IEnumerable<T> extList, Func<T, object> groupProps) where T : class
{
//Get All the lines that has repeating
return extList
.GroupBy(groupProps)
.Where(z => z.Count() > 1) //Filter only the distinct one
.SelectMany(z => z);//All in where has to be retuned
}
}
//how to use it:
void DuplicateExample()
{
//Populate List
List<Person> PersonsLst = new List<Person>(){
new Person(1,"Ricardo","Figueiredo"), //fist Duplicate to the example
new Person(2,"Ana","Figueiredo"),
new Person(3,"Ricardo","Figueiredo"),//second Duplicate to the example
new Person(4,"Margarida","Figueiredo"),
new Person(5,"Ricardo","Figueiredo")//third Duplicate to the example
};
Console.WriteLine("All:");
PersonsLst.ForEach(z => Console.WriteLine("{0} -> {1} {2}", z.Id, z.Name, z.Surname));
/* OUTPUT:
All:
1 -> Ricardo Figueiredo
2 -> Ana Figueiredo
3 -> Ricardo Figueiredo
4 -> Margarida Figueiredo
5 -> Ricardo Figueiredo
*/
Console.WriteLine("All lines with repeated data");
PersonsLst.getAllRepeated(z => new { z.Name, z.Surname })
.ToList()
.ForEach(z => Console.WriteLine("{0} -> {1} {2}", z.Id, z.Name, z.Surname));
/* OUTPUT:
All lines with repeated data
1 -> Ricardo Figueiredo
3 -> Ricardo Figueiredo
5 -> Ricardo Figueiredo
*/
Console.WriteLine("Only Repeated more than once");
PersonsLst.getMoreThanOnceRepeated(z => new { z.Name, z.Surname })
.ToList()
.ForEach(z => Console.WriteLine("{0} -> {1} {2}", z.Id, z.Name, z.Surname));
/* OUTPUT:
Only Repeated more than once
3 -> Ricardo Figueiredo
5 -> Ricardo Figueiredo
*/
}
Para encontrar apenas os valores duplicados:
var duplicates = list.GroupBy(x => x.Key).Any(g => g.Count() > 1);
Por exemplo. var list = new [] {1,2,3,1,4,2};
então agrupar por agrupará os números por suas teclas e manterá a contagem (número de vezes que repetiu) com ele. Depois disso, estamos apenas verificando os valores que se repetiram mais de uma vez.
Para encontrar apenas os valores uniuqe:
var unique = list.GroupBy(x => x.Key).All(g => g.Count() == 1);
Por exemplo. var list = new [] {1,2,3,1,4,2};
então agrupar por agrupará os números por suas teclas e manterá a contagem (número de vezes que repetiu) com ele. Depois disso, estamos apenas verificando os valores que repetiram apenas uma vez que as médias são únicas.
var unique = list.Distinct(x => x)
Conjunto completo de extensões Linq para SQL das funções Duplicadas verificadas no MS SQL Server. Sem usar .ToList () ou IEnumerable. Essas consultas são executadas no SQL Server e não na memória. . Os resultados retornam apenas na memória.
public static class Linq2SqlExtensions {
public class CountOfT<T> {
public T Key { get; set; }
public int Count { get; set; }
}
public static IQueryable<TKey> Duplicates<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> groupBy)
=> source.GroupBy(groupBy).Where(w => w.Count() > 1).Select(s => s.Key);
public static IQueryable<TSource> GetDuplicates<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> groupBy)
=> source.GroupBy(groupBy).Where(w => w.Count() > 1).SelectMany(s => s);
public static IQueryable<CountOfT<TKey>> DuplicatesCounts<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> groupBy)
=> source.GroupBy(groupBy).Where(w => w.Count() > 1).Select(y => new CountOfT<TKey> { Key = y.Key, Count = y.Count() });
public static IQueryable<Tuple<TKey, int>> DuplicatesCountsAsTuble<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> groupBy)
=> source.GroupBy(groupBy).Where(w => w.Count() > 1).Select(s => Tuple.Create(s.Key, s.Count()));
}
há uma resposta, mas eu não entendi porque não está funcionando;
var anyDuplicate = enumerable.GroupBy(x => x.Key).Any(g => g.Count() > 1);
minha solução é assim nessa situação;
var duplicates = model.list
.GroupBy(s => s.SAME_ID)
.Where(g => g.Count() > 1).Count() > 0;
if(duplicates) {
doSomething();
}