подсчет уникальных комбинаций свойств объекта

Question

У меня есть класс TypesHolder, который имеет четыре свойства, которые имеют значения int. Я хочу определить, сколько уникальных комбинаций значений находится в четырех переменных int, а затем для подсчета количества экземпляров TypesHolder имеют каждую конкретную комбинацию из четырех целых переменных. Как это сделать в коде? Произошла неудачная попытка моего кода, в результате неудачные результаты суммировались в конце. Должен быть более простой способ сделать это правильно.

Вот мой TypesHolder класс:

public class TypesHolder { 
private int with; 
private int type; 
private int reason1; 
private int reason2; 
    //getters and setters 
} 

Провести уникальные комбинации во время анализа, я создал следующий TypesSummaryHolder класс:

public class TypesSummaryHolder { 
private int with; 
private int type; 
private int reason1; 
private int reason2; 
    private int count; 
    //getters and setters 
} 

Затем я создал ArrayList для хранения экземпляров более 15000 от TypesHolder и еще один ArrayList для хранения объектов TypesSummaryHolder, которые представляют каждую из уникальных комбинаций width, type, reason1 и reason2 от объектов TypesHolder, а также переменную count для каждой из уникальных комбинаций. Я написал следующий код для заполнения ArrayList из TypesSummaryHolder объектов вместе с их подсчетами:

@SuppressWarnings("null") 
static void countCommunicationTypes(){ 
    int CommunicationWithNumber;int CommunicationTypeNumber;int CommunicationReasonNumber; 
    int SecondReasonNumber;int counter = 0; 
    ArrayList<EncounterTypesHolder> types = new ArrayList<EncounterTypesHolder>(); 
    ArrayList<EncounterTypesSummaryHolder> summaries = new ArrayList<EncounterTypesSummaryHolder>(); 
//////// 
    try {Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");} 
    catch (ClassNotFoundException e1) {e1.printStackTrace();} 
    Connection sourceConn = null; 
    try {sourceConn = DriverManager.getConnection("jdbc:odbc:PIC_NEW_32");} 
    catch (Exception e1) {e1.printStackTrace();} 
    Statement st = null; 
    try {st = sourceConn.createStatement();} 
    catch (Exception e1) { e1.printStackTrace();} 
    ResultSet rest = null; 
    try { 
     rest = st.executeQuery("SELECT * FROM someTable"); 
     while (rest.next()) { 
      CommunicationWithNumber = rest.getInt(3); 
      CommunicationTypeNumber = rest.getInt(5); 
      CommunicationReasonNumber = rest.getInt(6); 
      SecondReasonNumber = rest.getInt(6); 
      EncounterTypesHolder etype = new EncounterTypesHolder(); 
      etype.setWith(CommunicationWithNumber); 
      etype.setType(CommunicationTypeNumber); 
      etype.setReason1(CommunicationReasonNumber); 
      etype.setReason2(SecondReasonNumber); 
      if(!isDuplicateType(etype,types)){ 
       EncounterTypesSummaryHolder summaryholder = new EncounterTypesSummaryHolder(); 
       summaryholder.setWith(CommunicationWithNumber); 
       summaryholder.setType(CommunicationTypeNumber); 
       summaryholder.setReason1(CommunicationReasonNumber); 
       summaryholder.setReason2(SecondReasonNumber); 
       summaryholder.setCount(1); 
       summaries.add(summaryholder); 
      } else { 
       EncounterTypesSummaryHolder summaryholder = new EncounterTypesSummaryHolder(); 
       summaryholder.setWith(etype.getWith()); 
       summaryholder.setType(etype.getType()); 
       summaryholder.setReason1(etype.getReason1()); 
       summaryholder.setReason2(etype.getReason2()); 
       if(isDuplicateSummaryType(summaryholder, summaries)){ 
        for(int u = 0; u<summaries.size();u++){ 
         if((CommunicationWithNumber==summaries.get(u).getWith()) && (CommunicationTypeNumber==summaries.get(u).getType()) && (CommunicationReasonNumber==summaries.get(u).getReason1()) && (SecondReasonNumber==summaries.get(u).getReason2())){ 
          int oldcount = summaries.get(u).getCount(); 
          int newcount = oldcount+1; 
          summaries.get(u).setCount(newcount); 
         } 
        } 
       }else { 
        summaryholder.setCount(1); 
        summaries.add(summaryholder); 
       } 
      } 
      types.add(etype); 
      counter += 1; 
      System.out.println("counter is: "+counter); 
      System.out.println("summaries.size() is: "+summaries.size()); 
     } 
    } catch (Exception e) {e.printStackTrace();} 
    System.out.println("at end: counter is: "+counter); 
    System.out.println("at end: types.size() is: "+types.size()); 
    System.out.println("at end: summaries.size() is: "+summaries.size()); 
    int total = 0; 
    for(int r=0;r<summaries.size();r++){ 
     total += summaries.get(r).getCount(); 
     int with = summaries.get(r).getWith();int type = summaries.get(r).getType();int reason1 = summaries.get(r).getReason1();int reason2 = summaries.get(r).getReason2();int thiscount = summaries.get(r).getCount(); 
    } 
    System.out.println("total is: "+total); 
} 
static boolean isDuplicateType(EncounterTypesHolder testType, ArrayList<EncounterTypesHolder> types){ 
    for(int j = 0; j<types.size(); j++){ 
     if((testType.getWith() == types.get(j).getWith()) && (testType.getType() == types.get(j).getType()) && (testType.getReason1() == types.get(j).getReason1()) && (testType.getReason2() == types.get(j).getReason2())){ 
      System.out.println("=====TRUE!!===="); 
      return true; 
     } 
    } 
    return false; 
} 
static boolean isDuplicateSummaryType(EncounterTypesSummaryHolder testType, ArrayList<EncounterTypesSummaryHolder> types){ 
     for(int j = 0; j<types.size(); j++){ 
      if((testType.getWith() == types.get(j).getWith()) && (testType.getType() == types.get(j).getType()) && (testType.getReason1() == types.get(j).getReason1()) && (testType.getReason2() == types.get(j).getReason2())){ 
       System.out.println("=====TRUE!!===="); 
       return true; 
      } 
     } 
     return false; 
} 

Код выше производит следующий вывод SYSO в конце:

at end: counter is: 15415 
at end: types.size() is: 15415 
at end: summaries.size() is: 15084 
total is: 2343089 

Максимально возможное значение для summaries.size() должно быть около 600, но 331 вы получаете от types.size() минус summaries.size() выше в пределах допустимых значений для summaries.size(). Однако значение для общего числа должно быть равно значению 15414 types.size(). Что не так с моим кодом выше? Как я могу изменить свой код выше, чтобы получить как список уникальных комбинаций из with, type, reason1, так и reason2, а также count числа экземпляров с каждой из этих уникальных комбинаций значений?

Answer 1

Если я правильно Вас понял, вы могли бы добавить hashcode() и equals() методы в TypesHolder, затем добавить все значения в Set<TypesHolder> какой-то. Затем просто подсчитайте общие объекты (вызовите size()) в наборе, чтобы получить количество уникальных комбинаций.

Вот ссылка на implementing hashcode() and equals() от SO, если вы не знакомы с этими методами. Google - ваш друг.