Java 如何查找和写入数组中的重复元素？ 公共类Pascal{ 公共静态void main（字符串[]args）{ int数组[]={1,2,3,3,4,5,6,6,7,8,8,10,10,11,12,13}； for（int i=0；i

它不能正常工作。我尝试使用

foreach

循环，但效果并不理想。我想差不多完成了，我错过了一些无关紧要的事情

将“if（i==j）”替换为“if（array[i]==array[j]）”

您使用的是暴力方法

public class Pascal {

    public static void main(String[] args){
    int array[] = {1,2,3,3,4,5,6,6,7,8,8,10,10,11,12,13};


    for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                if (i == j){
                    System.out.println(i);
                } else {
                    System.out.println("Nothing");
                }
            }
        }
    }
}

for（int i=0；i

• 首先，应该将数组[i]与数组[j]进行比较，而不是将i与j进行比较

• 其次，如果i==j，则不应将元素与自身进行比较

例如：

for (int i = 0; i < array.length; i++) {
        for (int j = i+1; j < array.length; j++) {
            if (array[i] == array[j]){
                System.out.println(i);
            } else {
                System.out.println("Nothing");
            }
        }
    }
}

for（int i=0；i

---

这将打印重复的值。

您应该比较数组中的元素，而不是数组索引。同样，当索引相同时，数字就不会重复，它只是相同的数字

for (int i = 0; i < array.length; i++) {
    for (int j = i + 1; j < array.length; j++) {
        if (array[i] == array[j]) {
            System.out.println(array[i]);
        }
    }
}

for（int i=0；i

如果需要，请使用更多空间创建

集

对象

for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array.length; j++) {
        if ((array[i] == array[j]) && (i != j)) {
            System.out.println(array[i]);
        }
    }
}

Set Set=newhashset；
for（int i=0；i

另一种可能性是使用

地图

精确计算所有条目：

Set<Integer> set = new HashSet<Integer>;
for (int i = 0; i < array.length; i++) {
    boolean wasAdded = set.add(i);
    if(!wasAdded){
    System.out.println(array[i]);
    }
}

公共类Pascal{
公共静态void main（字符串[]args）{
int数组[]={1,2,3,3,4,5,6,6,7,8,8,10,10,11,12,13}；
Map lAllDoubleEntries=new HashMap（）；
for（int i=0；i1）{
System.out.println（“值”+lKey+“存在于列表”+lAllDoubleEntries.get（lKey）+“times”中”）；
}
}
}
}

输出：

值3在列表中存在2次

值6在列表中存在2次

值8在列表中存在2次

值10在列表中存在2次

---

你的问题

• 您正在比较

  i

  而不是

  array[i]

• 您正在分析 数组两次，因此每个值至少显示一次，即使 它不是复制品

这将起作用，但仍会打印多次重复值：

public class Pascal {

  public static void main(String[] args) {
    int array[] = { 1, 2, 3, 3, 4, 5, 6, 6, 7, 8, 8, 10, 10, 11, 12, 13 };

    Map<Integer, Integer> lAllDoubleEntries = new HashMap<Integer, Integer>();

    for (int i = 0; i < array.length; i++) {
      Integer count = lAllDoubleEntries.get(array[i]);
      if (null == count) {
        lAllDoubleEntries.put(array[i], 1);
      } else {
        lAllDoubleEntries.put(array[i], ++count);
      }
    }
    for (int lKey : lAllDoubleEntries.keySet()) {
     if (lAllDoubleEntries.get(lKey)>1) {
       System.out.println("Value "+lKey+" exists in list "+lAllDoubleEntries.get(lKey)+" times");
     }
    }

  }
}

我认为这是最有效的解决方案，但不是最具可读性的

另一个带有foreach循环的解决方案

除非明确需要访问当前元素的索引，否则使用普通的旧

for

循环是有害的，因为它引入了不必要的变量

i

，这会污染代码的可读性

您可以选择使用foreach语句：

int array[] = {1,2,3,3,4,5,6,6,7,8,8,10,10,11,12,13};

//Optionally
Arrays.sort(array);

Integer last = null;
for(int i = 0; i < array.length -1 ; i++) {
  if(array[i] == array[i+1] && (last == null || !last.equals(array[i]))) {
    System.out.println(array[i]);
    last = array[i];
  }
}

int数组[]={1,2,3,3,4,5,6,6,7,8,8,10,10,11,12,13}；
Set uniqueValues=new HashSet（）；
Set alreadyDisplayed=new HashSet（）；
for（整数值：数组）{
if（uniqueValues.contains（value）&&！alreadyDisplayed.contains（value））{
系统输出打印项次（值）；
已显示。添加（值）；
}
唯一值。添加（值）；
}

功能性风格的更好解决方案

此解决方案对Java8更加友好：

int array[] = {1,2,3,3,3,4,5,6,6,7,8,8,10,10,11,12,13,13};

Set<Integer> uniqueValues = new HashSet<>();
Set<Integer> alreadyDisplayed = new HashSet<>();
for(Integer value : array) {
  if(uniqueValues.contains(value) && !alreadyDisplayed.contains(value)) {
    System.out.println(value);
    alreadyDisplayed.add(value);
  }
  uniqueValues.add(value);
}

int数组[]={1,2,3,3,4,5,6,6,7,8,8,10,10,11,12,13}；
//计算每个数字的出现次数
Map Map=newhashmap（）；
Arrays.stream（数组）.forEach（值->{
整数出现次数=map.get（值）；
put（值，出现次数==null？1：出现次数+1）；
});
//当NB引用>1时显示引用数
map.entrySet（）
.stream（）
.filter（条目->条目.getValue（）>1）
.forEach（entry->System.out.println（entry.getKey（）+”：“+entry.getValue（））；

请注意，它还提供了每个值的出现次数。如果不需要它们，可以像以前的解决方案那样缩短代码

逻辑风格的更有趣的解决方案。

int array[] = {1,2,3,3,4,5,6,6,7,8,8,10,10,11,12,13};

//Count occurrences of each number
Map<Integer, Integer> map = new HashMap<>();
Arrays.stream(array).forEach(value -> {
  Integer occurrences = map.get(value);
  map.put(value, occurrences == null ? 1 : occurrences +1);
});

//Display number of occurrences when nbOccurrences > 1
map.entrySet()
    .stream()
    .filter(entry -> entry.getValue() > 1)
    .forEach(entry -> System.out.println(entry.getKey() + " : "+entry.getValue()));

Integer数组[]={1,2,3,3,4,5,6,6,7,8,8,10,10,11,12,13}；
//将数组转换为列表。
List List=Arrays.stream（array.collect（Collectors.toList（））；
//使用集合来构建唯一值的集合。
Set uniqueValues=新哈希集（列表）；
//从原始列表中删除每个唯一值一次。
uniqueValues.stream（）.forEach（list:：remove）；
//重新计算结果列表的唯一值并显示它们。
新的HashSet（list）.forEach（System.out:：println）；

使用Set解决方案

不包含重复元素的集合。更正式地说，集合不包含e1和e2元素对，因此e1.equals（e2）最多包含一个空元素

int[]myArr={1,2,3,3,4,5,6,6,7,8,8,10,10,11,12,13}；
Set mySet=newhashset（）；
对于（int i=0；i

算法解释
公共静态void main（字符串参数[]）{ int input[]=新int[/*选择大小/]； 输入[0]=

int array[] = {1,2,3,3,4,5,6,6,7,8,8,10,10,11,12,13};

//Count occurrences of each number
Map<Integer, Integer> map = new HashMap<>();
Arrays.stream(array).forEach(value -> {
  Integer occurrences = map.get(value);
  map.put(value, occurrences == null ? 1 : occurrences +1);
});

//Display number of occurrences when nbOccurrences > 1
map.entrySet()
    .stream()
    .filter(entry -> entry.getValue() > 1)
    .forEach(entry -> System.out.println(entry.getKey() + " : "+entry.getValue()));

Integer array[] = {1,2,3,3,4,5,6,6,7,8,8,10,10,11,12,13};

//Convert the array to a list.
List<Integer> list = Arrays.stream(array).collect(Collectors.toList());

//Use a Set in order to build the collection of unique values.
Set<Integer> uniqueValues = new HashSet<>(list);

//Remove each unique value once from the original list.
uniqueValues.stream().forEach(list::remove);

//Re-compute unique values of the resulting list and display them.
new HashSet<>(list).forEach(System.out::println);

    int[] myArr =  {1,2,3,3,4,5,6,6,7,8,8,10,10,11,12,13};
    Set<Integer> mySet = new HashSet<>();

    for (int i = 0; i < myArr.length; i++) {
        if (!mySet.add(myArr[i])) {
            System.out.println(myArr[i]);
        }
    }

    for(int i = 0; i < input.length; i++ ){
            mask = 1 << (input[i]%32);
            wordNumber = input[i]/32;
            if((mask & isDuplicate[wordNumber]) != 0){
                    System.out.println(input[i]);
            }else{
                    isDuplicate[wordNumber] |= mask;
            }
        }
   }