java中两个list对比，查出增加和删除的数据然后去重

package rmd_pms_web;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;

/**
 * @Description: 两个list对比，查出增加，删除的数据然后去重
 * @date 2017年8月17日
 */
public class Test {
	 
    public static void main(String[] args) {
    	List<Integer> arr = new ArrayList<Integer>();
    	
        List<Integer> a = Arrays.asList(1, 2, 3, 4,6);
        List<Integer> b = Arrays.asList(4, 3, 2, 1,9);
        
        //增加的元素组成的列表
        List<Integer> aList= getAddaListThanbList(a, b);
        for (Integer integer : aList) {
        	 System.out.println("增加的元素："+integer);
		}
        
        //减少的元素组成的列表
        List<Integer> bList= getReduceaListThanbList(a, b);
        for (Integer integer : bList) {
        	 System.out.println("减少的元素："+integer);
		}
        
        //封装
        arr.addAll(a);
        arr.addAll(b);
        arr.addAll(aList);
        arr.addAll(bList);
        
        
        //去重
        cleanDisRepet(arr);
        
        for (Integer integer : arr) {
        	 System.out.println("全部元素："+integer);
		}
    }
    
    /**
     * @Description: 计算列表aList相对于bList的增加的情况，兼容任何类型元素的列表数据结构
     * @param aList 本列表
     * @param bList 对照列表
     * @return 返回增加的元素组成的列表
     */
    public static <E> List<E> getAddaListThanbList(List<E> aList, List<E> bList){
        List<E> addList = new ArrayList<E>();
        for (int i = 0; i < aList.size(); i++){
            if(!myListContains(bList, aList.get(i))){
                addList.add(aList.get(i));
            }
        }
        return addList;
    }
    
    /**
     * @Description: 计算列表aList相对于bList的减少的情况，兼容任何类型元素的列表数据结构
     * @param aList 本列表
     * @param bList 对照列表
     * @return 返回减少的元素组成的列表
     */
    public static <E> List<E> getReduceaListThanbList(List<E> aList, List<E> bList){
        List<E> reduceaList = new ArrayList<E>();
        for (int i = 0; i < bList.size(); i++){
            if(!myListContains(aList, bList.get(i))){
                reduceaList.add(bList.get(i));
            }
        }
        return reduceaList;
    }
    
    
    /**
     * @Description: 判断元素element是否是sourceList列表中的一个子元素
     * @param sourceList 源列表
     * @param element 待判断的包含元素
     * @return 包含返回 true，不包含返回 false
     */
    private static <E> boolean myListContains(List<E> sourceList, E element) {
        if (sourceList == null || element == null){
            return false;
        }
        if (sourceList.isEmpty()){
            return false;
        }
        for (E tip : sourceList){
            if(element.equals(tip)){
                return true;
            }
        }
        return false;
    }
    
    /**
     * @Description: 去除list重复数据
     * @param list
     * @return list
     */
    public static <E> List<E> cleanDisRepet(List<E> list){
    	 HashSet h = new HashSet(list);   
    	 list.clear();   
    	 list.addAll(h); 
		return list;
    }
  
}