2つの配列で同じ要素または異なる要素を巡回

public <T> List<T> compareList(List<T> t1, List<T> t2) {
        List<T> listMax;
        List<T> listMin;
        if (t1.size() > t2.size()) {
            listMax = t1;
            listMin = t2;
        } else {
            listMax = t2;
            listMin = t1;
        }
        List<T> result = new ArrayList<T>();
        for (T t : listMax) {
            if (!listMin.contains(t)) {
                result.add(t);
            }
        }
        return result;
    }

   public <T> List<T> compare(T[] t1, T[] t2) {
        List<T> listMax;
        List<T> listMin;
        if (t1.length > t2.length) {
            listMax = Arrays.asList(t1);
            listMin = Arrays.asList(t2);
        } else {
            listMax = Arrays.asList(t2);
            listMin = Arrays.asList(t1);
        }
        List<T> result = new ArrayList<T>();
        for (T t : listMax) {
            if (!listMin.contains(t)) {
                result.add(t);
            }
        }
        return result;
    }

public static Set getIds(Integer[] a, Integer[] b){  

      Set same = new HashSet();  //                
      Set temp = new HashSet();  //      a      

      for (int i = 0; i < a.length; i++) {  
          temp.add(a[i]);   //   a      Set ，           
      }  

      for (int j = 0; j < b.length; j++) {  
        //   b       temp   
        //  temp         ， temp.add（b[j]）  false  
        if(!temp.add(b[j]))  
            same.add(b[j]);  
    }  
    return same;   
  }  

/**
     *         
     *
     * @param left           
     * @param right          
     * @param comparator      
     * @param           
     * @return   
     */
    public static  List remain(Collection left, Collection right, Comparator comparator) {
        Set leftSet = new TreeSet<>(comparator);
        leftSet.addAll(left);
        return right.stream().filter(leftSet::contains).collect(Collectors.toList());
    }