Обнаружение повторяющихся значений в примитивном массиве Java

Question

Я хочу обнаружить дублирующиеся значения в массиве Java.Например:

int[] array = { 3, 3, 3, 1, 5, 8, 11, 4, 5 };

Как я могу получить конкретную дублированную запись и сколько раз это происходит?

Answer 1

У меня будет Map<Integer, Integer>, где первое целое число - это value числа, встречающегося в массиве, а второе целое число - count (число вхождений).

• Выполнить через array.length в цикле
• для каждого элемента в массиве, выполните map.containsKey(array[i]). Если на карте существует число, увеличьте его (например, map.put(array[i], map.get(array[i]) + 1). В противном случае создайте новую запись на карте (например, map.put(array[i], 1).
• Наконец, выполните итерацию по карте и извлеките все ключи, где значение больше 1.

Answer 2

Похоже, задание на структуру данных называется multiset.

Multiset<Integer> mp = HashMultiset.create();
mp.addAll(Arrays.asList(new Integer[] { 3, 3, 3, 1, 5, 8, 11, 4, 5 }));

Стандартный JDK 6 является примитивным и не содержит multiset. Если вы не хотите переписывать его, вы можете использовать уже существующие библиотеки, такие как Google Guava-библиотеки или Apache Commons.

Например, с Guava-библиотеками вы можете

    for (Integer i : mp.elementSet())
        System.out.println(i + " is contained " + mp.count(i) + " times.");

И это выведет:

1 is contained 1 times.
3 is contained 3 times.
4 is contained 1 times.
5 is contained 2 times.
8 is contained 1 times.
11 is contained 1 times.

Answer 3

Ответ зависит от диапазона номеров в исходном массиве. Если диапазон достаточно мал, вы можете выделить массив, пройтись по источнику и увеличить его до индекса номера источника:

int[] counts = new int[max_value + 1];

for (int n: array) {
    counts[n]++;
}

Если ваш исходный массив содержит неизвестный или слишком большой диапазон, вы можете создать Map и считать в нем:

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

for (Integer n: array) {
    if (counts.containsKey(n)) {
        counts.put(n, counts.get(n) + 1);
    } else {
        counts.put(n, 1);
    }
}

NB. набрал выше без помощи JVM, избавление от опечаток осталось в качестве упражнения для читателя: -)

Answer 4

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class DuplicatedValuesInArray 
{

    public static void main(String args[]) {  
        int[] array = { 3, 3, 3, 1, 5, 8, 11, 4, 5 };
        Map<Integer, Integer> map= new HashMap<Integer, Integer>();

      for(int i=0;i<array.length;i++) {   
          if(map.containsKey(array[i]))

          map.put(array[i],map.get(array[i]) + 1);
      else
          map.put(array[i], 1);
      }

      for (Integer i : map.keySet()) {
          System.out.println(i + " is contained " + map.get(i) + " times.");
      }
   }
}

Answer 5

public class Duplicate {

    public static void main(String[] arg) {
        int[] array = {1, 3, 5, 6, 2, 3, 6, 4, 3, 2, 1, 6, 3};

        displayDuplicate(array);

    }

    static void displayDuplicate(int[] ar) {
        boolean[] done = new boolean[ar.length];
        for(int i = 0; i < ar.length; i++) {
            if(done[i])
                continue;
            int nb = 0;
            for(int j = i; j < ar.length; j++) {
                if(done[j])
                    continue;
                if(ar[j] == ar[i]) {
                    done[j] = true;
                    nb++;
                }
            }
            System.out.println(ar[i] + " occurs " + nb + " times");
        }
    }
}

Answer 6

Вы можете использовать Collectors.frecuency () и Collectors.groupingBy.

Вот как я это делаю, надеюсь, это поможет вам.

    Map<Object,Long> finalValues = new HashMap<Object, Long>();

    finalValues = Arrays.asList(new Integer[] {3, 3, 3, 1, 5, 8, 11, 4, 5 })
            .stream()
            .collect(Collectors.groupingBy(e -> e, Collectors.counting()));

    //Check the output
    finalValues.entrySet().forEach(entry -> {
        System.out.println("number: " + entry.getKey() + "| Times: "+ entry.getValue());
    });

Вывод:

number: 1| Times: 1
number: 3| Times: 3
number: 4| Times: 1
number: 5| Times: 2
number: 8| Times: 1
number: 11| Times: 1

Вы можете даже использовать частоту, чтобы удалить все числа, которые не повторяются:

Map finalValues ​​= new HashMap ();

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

    finalValues = numbers
            .stream()
            .filter(x-> Collections.frequency(numbers, x) > 1)
            .collect(Collectors.groupingBy(e -> e, Collectors.counting()));

    //Check the output
    finalValues.entrySet().forEach(entry -> {
        System.out.println("number: " + entry.getKey() + "| Times: "+ entry.getValue());
    });

Вывод:

number: 1| Times: 2
number: 4| Times: 2

Answer 7

 Java 8, the solution:
1. Create Map when the Key is the Value of Array and Value is counter.
2. Check if Map contains the Key increase counter or add a new set.
private static void calculateDublicateValues(int[] array) {
      //key is value of array, value is counter
      Map<Integer, Integer> map = new HashMap<Integer, Integer>();

      for (Integer element : array) {
        if (map.containsKey(element)) {
          map.put(element, map.get(element) + 1); // increase counter if contains
        } else
          map.put(element, 1);
      }

      map.forEach((k, v) -> {
        if (v > 1)
          System.out.println("The element " + k + " duplicated " + v + " times");
      });

    }

Answer 8

Сортируйте массив, затем либо отсканируйте его, либо Arrays.binarySearch + сканируйте в любом направлении.Из-за гораздо меньшего количества выделений и отсутствия переноса это может быть быстрее, особенно для больших массивов.

Answer 9

назначьте счетчик для первого шага, затем вы можете связать их с другим массивом, назначив каждому номеру индекс, а затем, если ваш номер дублируется, увеличьте свой счетчик ...