识别列表中的重复项

int[] nums =  new int[] {1, 1, 2, 3, 3, 3};
Arrays.sort(nums);
for (int i = 0; i < nums.length-1; i++) {


if (nums[i] == nums[i+1]) {
System.out.println("duplicate item "+nums[i+1]+" at Location"+(i+1) );
}


}

显然，你可以对它们做任何你想做的事情(例如，放入一个 Set 来获得一个唯一的重复值列表) ，而不是打印... ... 这也有记录重复项的位置的好处。

使用 MultiMap 将每个值存储为键/值集。然后循环遍历这些键，找到具有多个值的键。

请尝试在列表中查找重复项:

ArrayList<String> arrayList1 = new ArrayList<String>();


arrayList1.add("A");
arrayList1.add("A");
arrayList1.add("B");
arrayList1.add("B");
arrayList1.add("B");
arrayList1.add("C");


for (int x=0; x< arrayList1.size(); x++)
{
System.out.println("arrayList1 :"+arrayList1.get(x));
}
Set s=new TreeSet();
s.addAll(arrayList1);
Iterator it=s.iterator();
while (it.hasNext())
{
System.out.println("Set :"+(String)it.next());
}

创建一个 Map<Integer,Integer>，迭代该列表，如果映射中有一个元素，则增加它的值，否则以 key = 1将其添加到映射中
迭代映射，并将所有键 > = 2的元素添加到列表中

public static void main(String[] args) {
List<Integer> list = new LinkedList<Integer>();
list.add(1);
list.add(1);
list.add(1);
list.add(2);
list.add(3);
list.add(3);
Map<Integer,Integer> map = new HashMap<Integer, Integer>();
for (Integer x : list) {
Integer val = map.get(x);
if (val == null) {
map.put(x,1);
} else {
map.remove(x);
map.put(x,val+1);
}
}
List<Integer> result = new LinkedList<Integer>();
for (Entry<Integer, Integer> entry : map.entrySet()) {
if (entry.getValue() > 1) {
result.add(entry.getKey());
}
}
for (Integer x : result) {
System.out.println(x);
}


}

Set的方法 add返回一个布尔值，判断某个值是否已经存在(如果不存在，返回 true; 如果已经存在，返回 false，请参阅 设置文档)。

所以只要遍历所有的值:

public Set<Integer> findDuplicates(List<Integer> listContainingDuplicates) {
final Set<Integer> setToReturn = new HashSet<>();
final Set<Integer> set1 = new HashSet<>();
         

for (Integer yourInt : listContainingDuplicates) {
if (!set1.add(yourInt)) {
setToReturn.add(yourInt);
}
}
return setToReturn;
}

将 list 放入 set (这有效地过滤唯一的条目) ，从原始列表中删除所有 set 条目(这样它将只包含出现超过1次的条目) ，并将 list 放入 new set (这将再次只过滤唯一的条目) :

List<Item> list = ...;
list.removeAll(new HashSet<Item>(list));
return new HashSet<Item>(list);

你可以使用这样的东西:

List<Integer> newList = new ArrayList<Integer>();
for(int i : yourOldList)
{
yourOldList.remove(i);
if(yourOldList.contains(i) && !newList.contains(i)) newList.add(i);
}

这应该适用于排序和未排序的情况。

public void testFindDuplicates() {


List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(1);
list.add(2);
list.add(3);
list.add(3);
list.add(3);


Set<Integer> result = new HashSet<Integer>();
int currentIndex = 0;
for (Integer i : list) {
if (!result.contains(i) && list.subList(currentIndex + 1, list.size()).contains(i)) {
result.add(i);
}
currentIndex++;
}
assertEquals(2, result.size());
assertTrue(result.contains(1));
assertTrue(result.contains(3));
}

这也行得通:

public static Set<Integer> findDuplicates(List<Integer> input) {
List<Integer> copy = new ArrayList<Integer>(input);
for (Integer value : new HashSet<Integer>(input)) {
copy.remove(value);
}
return new HashSet<Integer>(copy);
}

这正是功能性技术所擅长解决的问题。例如，下面的 F # 解决方案比最好的命令式 Java 解决方案更清晰，更不容易出错(我每天都使用 Java 和 F #)。

[1;1;2;3;3;3]
|> Seq.countBy id
|> Seq.choose (fun (key,count) -> if count > 1 then Some(key) else None)

当然，这个问题是关于 Java 的。因此，我的建议是采用一个为 Java 带来函数特性的库。例如，可以使用我的 自己的图书馆来解决这个问题，如下所示(还有其他几个值得一看的问题) :

Seq.of(1,1,2,3,3,3)
.groupBy(new Func1<Integer,Integer>() {
public Integer call(Integer key) {
return key;
}
}).filter(new Predicate<Grouping<Integer,Integer>>() {
public Boolean call(Grouping<Integer, Integer> grouping) {
return grouping.getGrouping().count() > 1;
}
}).map(new Func1<Grouping<Integer,Integer>,Integer>() {
public Integer call(Grouping<Integer, Integer> grouping) {
return grouping.getKey();
}
});

如果您知道最大值(例如 < 10000) ，您可以牺牲空间来提高速度。 我不记得这种技术的确切名称了。

伪代码:

//does not handle case when mem allocation fails
//probably can be extended to unknown values /larger values .
maybe by sorting first
public List<int> GetDuplicates(int max)
{
//allocate and clear memory to 0/false
bit[] buckets=new bit[max]
memcpy(buckets,0,max);
//find duplicates
List<int> result=new List<int>();
foreach(int val in List)
{
if (buckets[val])
{
result.add(value);
}
else
{
buckets[val]=1;
}
}
return  result
}

我也需要一个解决方案，我使用了 Leifg 的解决方案，并把它变成了通用的。

private <T> Set<T> findDuplicates(Collection<T> collection) {


Set<T> duplicates = new LinkedHashSet<>();
Set<T> uniques = new HashSet<>();


for(T t : collection) {
if(!uniques.add(t)) {
duplicates.add(t);
}
}


return duplicates;
}

我采用了 John Strickler 的解决方案，并使用 JDK8中引入的流 API 对其进行了重新制作:

private <T> Set<T> findDuplicates(Collection<T> collection) {
Set<T> uniques = new HashSet<>();
return collection.stream()
.filter(e -> !uniques.add(e))
.collect(Collectors.toSet());
}

在 Java8上使用番石榴

private Set<Integer> findDuplicates(List<Integer> input) {
// Linked* preserves insertion order so the returned Sets iteration order is somewhat like the original list
LinkedHashMultiset<Integer> duplicates = LinkedHashMultiset.create(input);


// Remove all entries with a count of 1
duplicates.entrySet().removeIf(entry -> entry.getCount() == 1);


return duplicates.elementSet();
}

如果你使用 Eclipse 集合，这将工作:

MutableList<Integer> list = Lists.mutable.with(1, 1, 2, 3, 3, 3);
Set<Integer> dupes = list.toBag().selectByOccurrences(i -> i > 1).toSet();
Assert.assertEquals(Sets.mutable.with(1, 3), dupes);

更新: 从 Eclipse Collections9.2开始，您现在可以使用 selectDuplicates了

MutableList<Integer> list = Lists.mutable.with(1, 1, 2, 3, 3, 3);
Set<Integer> dupes = list.toBag().selectDuplicates().toSet();
Assert.assertEquals(Sets.mutable.with(1, 3), dupes);

您还可以使用基元集合来完成这项工作:

IntList list = IntLists.mutable.with(1, 1, 2, 3, 3, 3);
IntSet dupes = list.toBag().selectDuplicates().toSet();
Assert.assertEquals(IntSets.mutable.with(1, 3), dupes);

注意: 我是 Eclipse 集合的提交者。

精简版的顶部答案，还增加了空的检查和预先分配的集合大小:

public static final <T> Set<T> findDuplicates(final List<T> listWhichMayHaveDuplicates) {
final Set<T> duplicates = new HashSet<>();
final int listSize = listWhichMayHaveDuplicates.size();
if (listSize > 0) {
final Set<T> tempSet = new HashSet<>(listSize);
for (final T element : listWhichMayHaveDuplicates) {
if (!tempSet.add(element)) {
duplicates.add(element);
}
}
}
return duplicates;
}

public class DuplicatesWithOutCollection {


public static void main(String[] args) {


int[] arr = new int[] { 2, 3, 4, 6, 6, 8, 10, 10, 10, 11, 12, 12 };


boolean flag = false;
int k = 1;
while (k == 1) {


arr = removeDuplicate(arr);
flag = checkDuplicate(arr, flag);
if (flag) {
k = 1;
} else {
k = 0;
}


}


}


private static boolean checkDuplicate(int[] arr, boolean flag) {
int i = 0;


while (i < arr.length - 1) {


if (arr[i] == arr[i + 1]) {


flag = true;


} else {
flag = false;
}
i++;


}


return flag;
}


private static int[] removeDuplicate(int[] arr) {


int i = 0, j = 0;
int[] temp = new int[arr.length];
while (i < arr.length - 1) {


if (arr[i] == arr[i + 1]) {


temp[j] = arr[i + 1];
i = i + 2;


} else {


temp[j] = arr[i];
i = i + 1;


if (i == arr.length - 1) {
temp[j + 1] = arr[i + 1];
break;
}


}
j++;


}
System.out.println();
return temp;
}


}

试试这个:

示例如果 List 值是: [1,2,3,4,5,6,4,3,7,8] 重复项目[3,4]。

Collections.sort(list);
List<Integer> dup = new ArrayList<>();
for (int i = 0; i < list.size() - 1; i++) {
if (list.get(i) == list.get(i + 1)) {
if (!dup.contains(list.get(i + 1))) {
dup.add(list.get(i + 1));
}
}
}
System.out.println("duplicate item " + dup);

兰巴斯可能是个解决办法

Integer[] nums =  new Integer[] {1, 1, 2, 3, 3, 3};
List<Integer> list = Arrays.asList(nums);


List<Integer> dps = list.stream().distinct().filter(entry -> Collections.frequency(list, entry) > 1).collect(Collectors.toList());

import java.util.Scanner;


public class OnlyDuplicates {
public static void main(String[] args) {
System.out.print(" Enter a set of 10 numbers: ");
int[] numbers = new int[10];
Scanner input = new Scanner(System.in);
for (int i = 0; i < numbers.length; i++) {
numbers[i] = input.nextInt();
}
numbers = onlyDuplicates(numbers);
System.out.print(" The numbers are: ");
for (int i = 0; i < numbers.length; i++) {
System.out.print(numbers[i] + "");
}
}


public static int[] onlyDuplicates(int[] list) {
boolean flag = true;
int[] array = new int[0];
array = add2Array(array, list[0]);
for (int i = 0; i < list.length; i++) {
for (int j = 0; j < array.length; j++) {
if (list[i] == array[j]) {
flag = false;
break;
}
}
if (flag) {
array = add2Array(array, list[i]);
}
flag = true;
}
return array;
}
// Copy numbers1 to numbers2
// If the length of numbers2 is less then numbers2, return false
public static boolean copyArray(int[] source, int[] dest) {
if (source.length > dest.length) {
return false;
}


for (int i = 0; i < source.length; i++) {
dest[i] = source[i];
}
return true;
}
// Increase array size by one and add integer to the end of the array
public static int[] add2Array(int[] source, int data) {
int[] dest = new int[source.length + 1];
copyArray(source, dest);
dest[source.length] = data;
return dest;
}
}

public class practicese {
public static void main(String[] args) {


List<Integer> listOf = new ArrayList<Integer>();
listOf.add(3);
listOf.add(1);
listOf.add(2);
listOf.add(3);
listOf.add(3);
listOf.add(2);
listOf.add(1);


List<Integer> tempList = new ArrayList<Integer>();
for(Integer obj:listOf){
if(!tempList.contains(obj)){
tempList.add(obj);


}
}
System.out.println(tempList);


}


}

这将是一个很好的方法来查找重复的值，而不使用 Set。

public static <T> List<T> findDuplicates(List<T> list){


List<T> nonDistinctElements = new ArrayList<>();


for(T s : list)
if(list.indexOf(s) != list.lastIndexOf(s))
if(!nonDistinctElements.contains(s))
nonDistinctElements.add(s);


return nonDistinctElements;
}

比方说，你想要一个方法返回一个不同的列表，也就是说，如果你传递一个元素出现多次的列表，你会得到一个包含不同元素的列表。

public static <T> void distinctList(List<T> list){


List<T> nonDistinctElements = new ArrayList<>();
for(T s : list)
if(list.indexOf(s) != list.lastIndexOf(s))
nonDistinctElements.add(s);


for(T nonDistinctElement : nonDistinctElements)
if(list.indexOf(nonDistinctElement) != list.lastIndexOf(nonDistinctElement))
list.remove(nonDistinctElement);
}

和使用 commons-collections CollectionUtils.getCardinalityMap方法的版本:

final List<Integer> values = Arrays.asList(1, 1, 2, 3, 3, 3);
final Map<Integer, Integer> cardinalityMap = CollectionUtils.getCardinalityMap(values);
System.out.println(cardinalityMap
.entrySet()
.stream().filter(e -> e.getValue() > 1)
.map(e -> e.getKey())
.collect(Collectors.toList()));

```

Java 8基本解决方案:

List duplicates =
list.stream().collect(Collectors.groupingBy(Function.identity()))
.entrySet()
.stream()
.filter(e -> e.getValue().size() > 1)
.map(Map.Entry::getKey)
.collect(Collectors.toList());

这个密码怎么样

public static void main(String[] args) {


//Lets say we have a elements in array
int[] a = {13,65,13,67,88,65,88,23,65,88,92};


List<Integer> ls1 = new ArrayList<>();
List<Integer> ls2 = new ArrayList<>();
Set<Integer> ls3 = new TreeSet<>();


//Adding each element of the array in the list
for(int i=0;i<a.length;i++) {
{
ls1.add(a[i]);
}
}


//Iterating each element in the arrary
for (Integer eachInt : ls1) {


//If the list2 contains the iterating element, then add that into set<> (as this would be a duplicate element)
if(ls2.contains(eachInt)) {
ls3.add(eachInt);
}
else {ls2.add(eachInt);}


}


System.out.println("Elements in array or ls1"+ls1);
System.out.println("Duplicate Elements in Set ls3"+ls3);




}

只是为了以防那些也想包括重复和非重复。基本上，答案与正确答案相似，但是不是从零开始返回，而是返回 else 部分

使用此代码(更改为您需要的类型)

public Set<String> findDup(List<String> Duplicates){
Set<String> returning = new HashSet<>();
Set<String> nonreturning = new HashSet<>();
Set<String> setup = new HashSet<>();
for(String i:Duplicates){
if(!setup.add( i )){
returning.add( i );
}else{
nonreturning.add( i );
}
}
Toast.makeText( context,"hello set"+returning+nonreturning+" size"+nonreturning.size(),Toast.LENGTH_SHORT ).show();
return nonreturning;
}

下面是一个使用 Streams 和 Java8的解决方案

// lets assume the original list is filled with {1,1,2,3,6,3,8,7}
List<String> original = new ArrayList<>();
List<String> result = new ArrayList<>();

您只需查看此对象的频率是否在您的列表中多于一次。 然后，调用. different () ，以便在结果中只包含唯一的元素

result = original.stream()
.filter(e -> Collections.frequency(original, e) > 1)
.distinct()
.collect(Collectors.toList());
// returns {1,3}
// returns only numbers which occur more than once


result = original.stream()
.filter(e -> Collections.frequency(original, e) == 1)
.collect(Collectors.toList());
// returns {2,6,8,7}
// returns numbers which occur only once


result = original.stream()
.distinct()
.collect(Collectors.toList());
// returns {1,2,3,6,8,7}
// returns the list without duplicates

我接受了塞巴斯蒂安的回答，并添加了一个密钥提取器-

    private <U, T> Set<T> findDuplicates(Collection<T> collection, Function<? super T,? extends U> keyExtractor) {
Map<U, T> uniques = new HashMap<>(); // maps unique keys to corresponding values
return collection.stream()
.filter(e -> uniques.put(keyExtractor.apply(e), e) != null)
.collect(Collectors.toSet());
}

一种线程安全的替代方法是:

/**
* Returns all duplicates that are in the list as a new {@link Set} thread-safe.
* <p>
* Usually the Set will contain only the last duplicate, however the decision
* what elements are equal depends on the implementation of the {@link List}. An
* exotic implementation of {@link List} might decide two elements are "equal",
* in this case multiple duplicates might be returned.
*
* @param <X>  The type of element to compare.
* @param list The list that contains the elements, never <code>null</code>.
* @return A set of all duplicates in the list. Returns only the last duplicate.
*/
public <X extends Object> Set<X> findDuplicates(List<X> list) {
Set<X> dups = new LinkedHashSet<>(list.size());
synchronized (list) {
for (X x : list) {
if (list.indexOf(x) != list.lastIndexOf(x)) {
dups.add(x);
}
}
}
return dups;
}

作为 https://stackoverflow.com/a/52296246的变体的更通用的方法

    /**
* Returns a duplicated values found in given collection based on fieldClassifier
*
* @param collection given collection of elements
* @param fieldClassifier field classifier which specifies element to check for duplicates(useful in complex objects).
* @param <T> Type of element in collection
* @param <K> Element which will be returned from method in fieldClassifier.
* @return returns list of values that are duplocated.
*/
public static <T, K> List<K> lookForDuplicates(List<T> collection, Function<? super T, ? extends K> fieldClassifier) {


return collection.stream().collect(Collectors.groupingBy(fieldClassifier))
.entrySet()
.stream()
.filter(e -> e.getValue().size() > 1)
.map(Map.Entry::getKey)
.collect(Collectors.toList());
}

类似于这里的一些答案，但是如果你想找到基于某些属性的副本:

  public static <T, R> Set<R> findDuplicates(Collection<? extends T> collection, Function<? super T, ? extends R> mapper) {
Set<R> uniques = new HashSet<>();
return collection.stream()
.map(mapper)
.filter(e -> !uniques.add(e))
.collect(toSet());
}

List.of(1, 1, 3, 4, 5, 5, 6).stream()
.collect(Collectors.collectingAndThen
(Collectors.groupingBy(Function.identity()),
map -> map.entrySet()
.stream()
.filter(e -> e.getValue().size() > 1)
.map(Map.Entry::getKey)
.collect(Collectors.toList())));

所以，这就是我解决它的方法。它可能会有一点开销，但返回的正是 OP 想要的结果:

 public static List<Something> findDuplicatesInList(List<Something> somethingList) {


List<Something> temp = somethingList
.stream()
.filter(alpha -> somethingList
.stream()
.filter(beta -> beta.equals(alpha))
.count() > 1)
.collect(Collectors.toList());


List<Something> duplicateSomethings = new ArrayList<>();


for(Something something: temp){
if(!duplicateSomethings.contains(something)){
duplicateSomethings.add(something);
}
}


return duplicateSomethings;
}