Java - Поиск повторяющихся записей в нескольких массивах

Question

Я хочу найти уникальные точки в наборе массивов точек (т. Е. Удалить все дубликаты и посмотреть, что осталось).

Вот код, я пробовал:

int numCount = 0; 
    for (int x = 0; x < ALLARRAYS.length; x++) { 
     for (final Point test : ALLARRAYS[x]) { 
      NUMBER: for (final Point[] numbers : ALLARRAYS) { 
       if (numbers == ALLARRAYS[x]) { 
        continue; 
       } 
       for (int i = 0; i < numbers.length; i++) { 
        if (test.equals(numbers[i])) { 
         break NUMBER; 
        } else { 
         if (i == numbers.length - 1) { 
          numCount++; 
         } 
        } 
       } 
      } 
      if (numCount == 10) { 
       System.out.println(x + "\tPoint: " + test.x + ", " + test.y + " is unique."); 
      } 
      numCount = 0; 
     } 
     System.out.println(); 
    } 

В принципе, у меня есть одиннадцать массивов, я хочу, чтобы проверить, поэтому проверяет numCount на 10 массивах должны быть подтверждены. Мой подход состоял в том, чтобы циклически перебирать каждый массив, а затем циклически перебирать все точки в этом массиве, а затем циклически перебирать каждую точку в каждом другом массиве. Если он видит дубликат, он полностью пропускает все число.

Моя проблема: Я получаю ложные показания. Я не уверен, что происходит, но программа выплескивает точки, которые уже существуют в других массивах.

Моя цель: Каждый массив работает в целом. Если один элемент не выполняется, то весь массив пропускается. Мой конечный результат должен состоять из 11 массивов меньшего размера, которые являются уникальными, так что метод может проверять элементы каждого набора и определять, что они все уникальны.

ПРИМЕЧАНИЕ. Теперь массивы уникальны, они просто смехотворно огромны. Я ищу способ усечения, создав эту мини-программу для устранения дубликатов.

Мой вопрос: Может кто-нибудь, пожалуйста, помогите мне?

Answer 1

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

Вам может понадобиться сделать что-то вроде этого:

 NUMBER: for (final Point[] numbers : ALLARRAYS) { 
      if (numbers == array) { 
       continue; // skip the array that contains 'test' 
      } 
      ... 
     } 

Таким образом, вы будете пропускать массив, содержащий test элемент.

Answer 2

Поместите все записи массивов в Набор, он пропустит дубликаты.

Просто не забудьте правильно переопределить метод equals на вашем классе Point, потому что реализация интерфейса Set будет использовать его.

НТН

Answer 3

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

Чтобы избежать этого хлопот, я пометить точку как removed, полагая х и у -1, одна координата, конечно, будет достаточно, но по соображениям симметрии ...

import java.util.*; 
import java.awt.Point; 

public class RandPoints 
{ 
    Random r = new Random(); 
    Point [][] arr; 

    public void removeDuplicatesFrom2 (Point [] pa, Point [] pb) { 
     for (Point p : pb) { 
      if (p.x != - 1 && Arrays.asList (pa).contains (p)) { 
       // System.out.println ("dup: " + p.x + " " + p.y); 
       p.x = -1; 
       p.y = -1; 
      } 
     } 
    } 

    // create a random point in range (0..19)(0..19) 
    public Point randpoint() { 
     return new Point (r.nextInt (20), r.nextInt (20)); 
    } 

    // create 10 (default) arrays of size 100 (default) 
    public void init (int arrsize, int arrcount) 
    { 
     arr = new Point [arrcount][]; 
     for (int c = 0; c < arrcount; ++c) 
     { 
      Point [] points = new Point [arrsize]; 
      for (int s = 0; s < arrsize; ++s) 
      { 
       Point p = randpoint(); 
       points[s] = p; 
      } 
      arr[c] = points; 
     } 
    } 

    public void unify() 
    { 
     for (Point[] pac0 : arr) { 
      for (Point[] pac1 : arr) 
      { 
       if (pac0 != pac1) 
       removeDuplicatesFrom2 (pac0, pac1);  
      } 
     } 
    } 

    /** 
     fill arrays with duplicates by random, 
     show, delete and show again. 
    */ 
    public RandPoints (int arrsize, int arrcount) 
    { 
     init (arrsize, arrcount); 
     show(); 
     unify(); 
     System.out.println(); 
     show(); 
    } 

    public static void main (String args[]) 
    { 
     int arrsize = 100; 
     int arrcount = 10; 
     if (args.length == 2) 
     { 
      arrsize = Integer.parseInt (args[0]); 
      arrcount = Integer.parseInt (args[1]); 
     } 
     new RandPoints (arrsize, arrcount); 
    } 

    // visible feedback is always welcome while debugging/testing 
    public void show() 
    { 
     for (Point[] pa: arr) { 
      for (Point point: pa) 
       if (point.x != -1 && point.y != -1) 
        System.out.print (point.x + ", " + point.y + "\t"); 
      System.out.println(); 
     } 
    } 
} 

Я модифицировал немного, чтобы сделать максимальный диапазон для значений (20) также настраиваемым.

Начиная его с

java RandPoints 16 10 10 
3, 0 9, 0 6, 9 2, 3 6, 9 7, 4 9, 9 2, 5 8, 7 3, 3 9, 5 3, 7 0, 5 7, 6 0, 4 8, 1  
6, 1 2, 7 2, 5 6, 7 0, 7 5, 8 4, 2 1, 9 8, 4 5, 7 0, 2 3, 1 1, 9 2, 1 8, 0 1, 7  
5, 4 9, 7 9, 3 7, 3 1, 2 9, 6 0, 4 6, 0 3, 0 7, 7 1, 3 1, 1 5, 3 3, 8 1, 0 4, 9  
4, 7 8, 9 4, 0 0, 2 8, 7 5, 8 7, 0 1, 4 4, 9 8, 2 6, 9 9, 6 2, 1 1, 9 0, 8 6, 5  
6, 8 9, 6 1, 0 6, 9 4, 0 5, 1 2, 9 7, 3 5, 1 2, 5 6, 9 0, 9 7, 4 8, 1 5, 5 3, 4  
5, 9 0, 4 5, 4 2, 2 2, 6 7, 1 2, 0 6, 1 0, 4 9, 8 5, 7 5, 5 4, 6 9, 0 2, 8 8, 5  
8, 2 4, 2 0, 8 1, 1 0, 3 3, 4 1, 8 3, 1 6, 6 4, 1 3, 6 6, 0 1, 7 4, 8 1, 6 1, 1  
6, 2 1, 3 2, 4 0, 8 9, 0 3, 0 1, 1 3, 7 6, 2 2, 4 0, 9 3, 6 7, 2 1, 2 5, 0 8, 2  
2, 3 5, 6 7, 9 3, 0 9, 3 2, 6 4, 8 8, 7 9, 4 5, 3 0, 3 3, 0 5, 5 1, 4 6, 4 5, 2  
3, 2 4, 9 6, 9 4, 7 7, 1 0, 4 5, 8 7, 2 5, 2 5, 5 2, 1 9, 8 4, 9 6, 6 7, 7 0, 3  

3, 0 9, 0 6, 9 2, 3 6, 9 7, 4 9, 9 2, 5 8, 7 3, 3 9, 5 3, 7 0, 5 7, 6 0, 4 8, 1  
6, 1 2, 7 6, 7 0, 7 5, 8 4, 2 1, 9 8, 4 5, 7 0, 2 3, 1 1, 9 2, 1 8, 0 1, 7  
5, 4 9, 7 9, 3 7, 3 1, 2 9, 6 6, 0 7, 7 1, 3 1, 1 5, 3 3, 8 1, 0 4, 9  
4, 7 8, 9 4, 0 7, 0 1, 4 8, 2 0, 8 6, 5  
6, 8 5, 1 2, 9 5, 1 0, 9 5, 5 3, 4  
5, 9 2, 2 2, 6 7, 1 2, 0 9, 8 4, 6 2, 8 8, 5  
0, 3 1, 8 6, 6 4, 1 3, 6 4, 8 1, 6  
6, 2 2, 4 6, 2 2, 4 7, 2 5, 0  
5, 6 7, 9 9, 4 6, 4 5, 2  
3, 2