생략
list 대상에서 어떤 필드에 따라 다시 쓰기Comparator

 1     /**
 2      *  
 3      * 
 4      * @param orderList
 5      * @return
 6      * @author ziggo
 7      */
 8     private static List removeDuplicateOrder(List orderList) {
 9         Set set = new TreeSet(new Comparator() {
10             @Override
11             public int compare(Drug a, Drug b) {
12                 //  asicc 
13                 return a.getName().compareTo(b.getName());
14             }
15         });
17         set.addAll(orderList);
18         return new ArrayList(set);
19     }

list 대상에서 여러 필드에 따라 다시 쓰기Comparator

    /**
     *  ( , )
     * 
     * @param orderList
     * @return
     * @author ziggo
     */
    private static List removeDuplicateOrder(List orderList) {
        Set set = new TreeSet(new Comparator() {
            @Override
            public int compare(Drug a, Drug b) {
                int compareToResult = 1;// ==0 
                //  asicc 
                if (a.getName().equals(b.getName()) && a.getDepartment().equals(b.getDepartment())) {
                    compareToResult = 0;
                }
                return compareToResult;
            }
        });

        set.addAll(orderList);
        return new ArrayList(set);
    }

Comparator가 여러 필드에 따라 다시 쓰기를 진행할 때 이 방법이 정상적으로 다시 쓰기를 할 수 없다는 것을 발견하였으며, 아직 어떤 원인을 찾지 못하여 포조에서 equals를 다시 쓰는 방법을 찾아보았다.
솔리드 클래스: DRUG

package com.msun.mr.app.pojo;

/**
 * @author d_hb  
 */
public class Drug {
    /**

  
********************************


*/
    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (this == obj) {
            return true;
        }
        Drug drug = (Drug) obj;
        if (this.getName() .compareTo(drug.getName())==0
                && this.getDepartment().equals(drug.getDepartment()) && this.getSpec_id().equals(drug.getSpec_id())){
            return true;
        }
        return false;
    }
}

 
중복 논리를 판단하고 세 필드를 동시에 만족시킬 때

    //  ( equals )
    private static List removeDuplicateInvoice(List orderList) {
        List list = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(orderList)) {
            for (Drug drug : orderList) {
                // list ， equals
                if (!list.contains(drug)) {
                    list.add(drug);
                }
            }
        }
        return list;
    }

그래서 현재 코드가 사용하는 리셋 논리는 한 필드가 리셋될 때Comparator를 다시 쓰고 여러 필드가 리셋될 때equals를 다시 쓰는 방법이다.하지만 여러 필드를 다시 쓰는 것도 Comparator를 다시 쓰는 방법으로도 이루어질 수 있을 것 같아서 당분간 문제를 포지셔닝할 수 없을 것 같아서...