JAVA List容器内部差异化比较工具类（咋个办呢 zgbn）

背景:

最近在做一个小项目的时候，遇到需要将两组不同的数据集合进行对比，将相互有差异的元素挑选出来，所以就顺手写了一个工具类，今天发表出来提供给大家参考。

泛型<String>为List<String> l1 和 List<String> l2 两个List容器内部元素对象类型，下面方法只能比较两个List<T>泛型为同一个类型的容器对象。

SortListCmpTools.DiffedLists<String> diffedLists = s.diffSortList(l1, l2, new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				return o1.compareTo(o2);
			}
		});

package com.test.list;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;

/**
 * 数组、列表差异性比较
 * 
 * @author ChenGang
 */
public class SortListCmpTools {

	private static final int EID_1 = 1;
	private static final int EID_2 = 2;

	/**
	 * 测试方法
	 * @param args
	 */
	public static void main(String[] args) {

		SortListCmpTools s = new SortListCmpTools();

		List<String> l1 = new ArrayList<String>();
		List<String> l2 = new ArrayList<String>();

		l1.add("1211111111111");
		l1.add("1311111111111");
		l1.add("1411111111111");
		l1.add("1511111111111");
		l1.add("1611111111111");
		l1.add("1131111111111");
		l1.add("1121111111111");
		l1.add("1113111111111");
		l1.add("1113111111112");
		l1.add("1113111111122");
		l1.add("1113111141122");

		l2.add("1211111111111");
		l2.add("1311111111111");
		l2.add("1411111111111");
		l2.add("1511111111111");
		l2.add("1611111111111");
		l2.add("1131111161111");
		l2.add("1121111111111");
		l2.add("1113111111111");
		l2.add("1113111111111");

		SortListCmpTools.DiffedLists<String> diffedLists = s.diffSortList(l1, l2, new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				return o1.compareTo(o2);
			}
		});

		for (CmpE<String> e : diffedLists.getListA()) {
			System.out.println(String.format("ID:%d\t IDX:%d\t E:%s\t F:%s", e.getY(), e.getIdx(), e.getE(), String.valueOf(e.isFlag())));
		}

		for (CmpE<String> e : diffedLists.getListB()) {
			System.out.println(String.format("ID:%d\t IDX:%d\t E:%s\t F:%s", e.getY(), e.getIdx(), e.getE(), String.valueOf(e.isFlag())));
		}

	}

	
	public class CmpE<T> {

		private T e;

		private int idx;

		int y;

		private boolean flag;

		public CmpE(T e, int idx, int y) {
			this.e = e;
			this.idx = idx;
			this.y = y;
			this.flag = true;
		}

		public final int getY() {
			return y;
		}

		public final void setY(int y) {
			this.y = y;
		}

		public final boolean isFlag() {
			return flag;
		}

		public final void setFlag(boolean flag) {
			this.flag = flag;
		}

		public final T getE() {
			return e;
		}

		public final int getIdx() {
			return idx;
		}

	}

	public class DiffedLists<T> {

		private List<CmpE<T>> listA;

		private List<CmpE<T>> listB;

		private Comparator<CmpE<T>> cmptor = new Comparator<SortListCmpTools.CmpE<T>>() {
			@Override
			public int compare(CmpE<T> o1, CmpE<T> o2) {
				return o1.getIdx() - o2.getIdx();
			}
		};

		DiffedLists(List<CmpE<T>> listA, List<CmpE<T>> listB) {
			this.listA = listA;
			this.listB = listB;
		}

		public final List<CmpE<T>> getListA() {
			Collections.sort(this.listA, this.cmptor);
			return listA;
		}
		
		public final List<CmpE<T>> getListB() {
			return listB;
		}
		
		public final List<CmpE<T>> getSortListA() {
			return listA;
		}
		
		public final List<CmpE<T>> getSortListB() {
			return listB;
		}
		
		public final List<CmpE<T>> getSortListA(Comparator<CmpE<T>> cmptor) {
			Collections.sort(this.listA, cmptor);
			return listA;
		}
		
		public final List<CmpE<T>> getSortListB(Comparator<CmpE<T>> cmptor) {
			Collections.sort(this.listA, cmptor);
			return listB;
		}

	}

	public <T> DiffedLists<T> diffSortList(T[] t1, T[] t2, final Comparator<T> comparator) {
		List<T> list1 = Arrays.asList(t1);
		List<T> list2 = Arrays.asList(t2);
		return this.diffSortList(list1, list2, comparator);
	}

	public <T> DiffedLists<T> diffSortList(List<T> list1, List<T> list2, final Comparator<T> comparator) {

		int len1 = list1.size();
		int len2 = list2.size();

		List<CmpE<T>> list = new LinkedList<CmpE<T>>();

		for (int i = 0; i < len1; i++) {
			list.add(new CmpE<T>(list1.get(i), i, EID_1));
		}

		for (int i = 0; i < len2; i++) {
			list.add(new CmpE<T>(list2.get(i), i, EID_2));
		}

		Collections.sort(list, new Comparator<CmpE<T>>() {
			@Override
			public int compare(CmpE<T> o1, CmpE<T> o2) {
				int f1 = comparator.compare(o1.getE(), o2.getE());
				int f2 = o1.getIdx() - o2.getIdx();
				return f1 == 0 ? f2 : f1;
			}
		});

		List<CmpE<T>> elist1 = new LinkedList<CmpE<T>>();
		List<CmpE<T>> elist2 = new LinkedList<CmpE<T>>();

		int len = list.size();
		for (int i = 0; i < len - 1;) {
			int ii = i + 1;

			CmpE<T> e1 = list.get(i);
			CmpE<T> e2 = list.get(ii);

			if (e1.getY() < e2.getY()) {

				boolean f = comparator.compare(e1.getE(), e2.getE()) == 0;

				e1.setFlag(f);
				e2.setFlag(f);

				if (e1.getY() == EID_1) {
					elist1.add(e1);
				}

				if (e1.getY() == EID_2) {
					elist2.add(e1);
				}

				if (e2.getY() == EID_1) {
					elist1.add(e2);
				}

				if (e2.getY() == EID_2) {
					elist2.add(e2);
				}

				i = i + 2;

			} else {

				e1.setFlag(false);

				if (e1.getY() == EID_1) {
					elist1.add(e1);
				}

				if (e1.getY() == EID_2) {
					elist2.add(e1);
				}

				i = i + 1;

			}

		}

		return new DiffedLists<T>(elist1, elist2);

	}
}