Как объединить общие элементы в один массив?

Question

Я пытаюсь объединить три массива в один массив. Только соблюдение общих элементов. Это не дублирующий вопрос. Я знаю, что есть другие примеры в Интернете, но это использование int [], и я не знаю, как это сделать с помощью Comparable.

Что мне нужна помощь с:

1. Как добавить единый комбинированный/обновленный массив в 2d массив.

2. Как подсчитать итерации каждый раз, когда элемент сравнивается.

3. Если бы я хотел, как я могу изменить массивы, которые у меня есть сейчас в списке? - Я думал, может быть, это было бы легче добавить.

Я новичок в программировании, и я был бы признателен за помощь. Я пытаюсь изучить java, просто прочитав книги и поиская в Интернете.

Это то, что у меня есть до сих пор.

public class Common{ 

Comparable [] col_1 = {1, 1, 2}; 
Comparable [] col_2 = {1, 1, 2,3}; 
Comparable [] col_3= {1, 1, 2,3,4,}; 
Comparable [][] collections = {col_1, col_2, col_3}; 
int comparisonCount = 0 


public Comparable[] findCommon(Comparable [][] collections){ 

int i, j, k, x, y; 

for(i = 0; i< col_1.length; i++){ 
    for(j = 0; j < col_2.length; j++){ 
     for(k = 0; k < col_3.length; k++){ 

comparisonCount++;  
// This should be counting but is not... 

if(col_1[i].compareTo(col_2[j]) == 0 && col_1[i].compareTo(col_3[k]) ==0){ 

//keep searching until last element & allow duplicates & add to collections or a temp[] 


       } 
     } 
    } 
} 

// Here I'm not sure how to add the elements to the collection 


for (x = 0; x < collections.length; x++){ 
    for(y = 0; y< collections[x].length; y++){ 
     collections [x][y] = ?????? // not sure how to add results here 
     } 
    } 
} 


public void setComparisons(int count){ 
    count = comparisonCount; 
} 



public int getComparisons(){ 

    return comparisonCount; 
} 



public class Sorting { 

public static void main(String[] args) { 

    Common m = new Common(); 
    //I want to test it from here but I don't know how to initialize each array.   

    for(int x=0; x < m.collections.length; x++){ 
     for(int y= 0; y< m.collections[x].length; y++){ 
     System.out.println(m.collections[x][y]); 
    } 
// what I should be getting is only (1, 1, 2) - the order is not important really. I just want to learn. 

    } 
    System.out.println(m.getComparisons()); 

} 

}

Answer 1

Чтобы сохранить только общие элементы в сопоставимых наборах, вы можете использовать TreeSet, который сравнивает элементы с использованием переданного компаратора.

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

import java.util.Arrays; 
import java.util.Collections; 
import java.util.Comparator; 
import java.util.TreeSet; 

public class Main { 
    public static Comparable[] findCommon(Comparable[][] collections, Comparator comparator) { 
     TreeSet<Comparable> set = new TreeSet<Comparable>(comparator); 
     Collections.addAll(set, collections[0]); 

     for (int i = 1; i < collections.length; i++) 
      set.retainAll(Arrays.asList(collections[i])); 

     return set.toArray(new Comparable[set.size()]); 
    } 

    public static void main(String[] args) { 
     Comparable[] col_1 = {1, 1, 2}; 
     Comparable[] col_2 = {1, 1, 2, 3}; 
     Comparable[] col_3 = {1, 1, 2, 3, 4}; 

     Comparable[][] collections = {col_1, col_2, col_3}; 
     final int comparisonCount = 0; 

     CountingComparator comparator = new CountingComparator(); 
     System.out.println(Arrays.toString(findCommon(collections, comparator))); 
     System.out.println(comparator.getComparisonCount()); 
    } 

    private static class CountingComparator implements Comparator<Comparable> { 
     private int comparisonCount; 

     public int getComparisonCount() { 
      return comparisonCount; 
     } 

     @Override 
     public int compare(Comparable o1, Comparable o2) { 
      comparisonCount++; 
      return o1.compareTo(o2); 
     } 
    } 
} 

Answer 2

Ответы (в порядке упрощения):

• Вопрос 2: Почему вы должны держать рассчитывать сравнение? То, как оно у вас есть, всегда будет результатом длины массива (col_1.length * col_2.length * col_3.length).
• Вопрос 1: Возможно, вы можете использовать HashSet (см. Здесь: http://docs.oracle.com/javase/7/docs/api/java/util/HashSet.html). Это работает намного быстрее, чем у вас, но может не иметь такого же количества сравнения.
• Вопрос 3: Наконец, чтобы иметь возможность добавлять последнюю коллекцию, вы можете использовать список (a List<Comparable[]> ls не является необоснованным). Все, что вам нужно сделать с HashSet (при условии, что вы делаете HashSet<Comparable> hs = new HashSet<>();), - ls.add(hs.toArray()). Честно говоря, я не знаю, почему вы это сделаете, потому что ваш метод должен возвращать hs.toArray() (на самом деле, ваш код компилируется, видя, что вы не возвращаетесь в соответствии с кодом, который вы опубликовали?).