Java 如何比较两个有序列表

ArrayList thisDataList和dataList是两个包含大量数据的有序列表。“different”是一个ArrayList数组，它将在第一行中包含我们在这个dataList中但不在dataList中的数据，在第二行中包含我们在dataList中但不在这个dataList中的数据，我使用这种方法处理小数据但不超过50Mo的文件，你能给我一个解决方案吗？我使用相同的算法，事实上我有“有序”列表来加快速度

我正在使用Java1.6

ArrayList<?>[] different = new ArrayList<?>[2];
ArrayList<String> tmp= new ArrayList<String>(thisDataList);

thisDataList.removeAll( dataList );
different[0]=new ArrayList<String>(thisDataList);

thisDataList= tmp;
dataList.removeAll( thisDataList );

different[1]=new ArrayList<String>(dataList);

ArrayList[]不同=新的ArrayList[2]；
ArrayList tmp=新的ArrayList（thisDataList）；
thisDataList.removeAll（数据列表）；
不同[0]=新的ArrayList（thisDataList）；
thisDataList=tmp；
dataList.removeAll（thisDataList）；
不同[1]=新的ArrayList（数据列表）；

从列表的第一个元素开始。对于每个列表中当前索引处的元素，如果一个元素小于另一个元素，则该元素对于该列表是唯一的（因为列表已排序，而另一个列表再也找不到更小的元素），因此增加该列表当前索引的数量，并将该元素添加为该列表的“额外”元素，使用新的当前索引重复此操作

见下文：

public static void main(String[] args) {
    List<Integer> list1 = Arrays.asList(1, 2, 4, 6, 7, 8);
    List<Integer> list2 = Arrays.asList(1, 3, 4, 5, 6, 9);

    List<List<Integer>> listExtras = getExtraElementsOfLists(list1, list2);
    List<Integer> list1Extras = listExtras.get(0);
    List<Integer> list2Extras = listExtras.get(1);

    System.out.println("List 1 extras:");
    for (Integer i : list1Extras)
        System.out.println(i);

    System.out.println();
    System.out.println("List 2 extras:");
    for (Integer i : list2Extras)
        System.out.println(i);
}


public static <T extends Comparable<T>> List<List<T>> getExtraElementsOfLists(List<T> list1,
        List<T> list2) {
    Collections.sort(list1);
    Collections.sort(list2);

    List<T> list1Extras = new ArrayList<>();
    List<T> list2Extras = new ArrayList<>();
    int index1 = 0;
    int index2 = 0;
    while (index1 < list1.size() && index2 < list2.size()) {
        T value1 = list1.get(index1);
        T value2 = list2.get(index2);
        int delta = value1.compareTo(value2);
        if (delta < 0) { // val1 < val2, list2 !contain val1
            list1Extras.add(value1);
            index1++;
        } else if (delta > 0) { // val1 > val2, list1 !contain val2
            list2Extras.add(value2);
            index2++;
        } else { // both have the same value
            index1++;
            index2++;
        }
    }
    // whichever list still has elements, add them all to its extras
    for (; index1 < list1.size(); index1++)
        list1Extras.add(list1.get(index1));
    for (; index2 < list2.size(); index2++)
        list2Extras.add(list2.get(index2));

    return Arrays.asList(list1Extras, list2Extras);
}

publicstaticvoidmain（字符串[]args）{
list1=Arrays.asList（1,2,4,6,7,8）；
list2=Arrays.asList（1,3,4,5,6,9）；
List listExtras=getExtraElementsOfLists（列表1、列表2）；
List list1Extras=listExtras.get（0）；
List list2Extras=listExtras.get（1）；
System.out.println（“列表1附加：”）；
对于（整数i:list1Extras）
系统输出打印LN（i）；
System.out.println（）；
System.out.println（“列表2额外内容：”）；
对于（整数i:list2Extras）
系统输出打印LN（i）；
}
公共静态列表GetExtraElementsOfList（列表列表1，
列表2）{
Collections.sort（列表1）；
Collections.sort（列表2）；
List list1Extras=new ArrayList（）；
List list2Extras=new ArrayList（）；
int index1=0；
int index2=0；
而（index10）{//val1>val2，list1！包含val2
list2Extras.add（value2）；
index2++；
}else{//两者的值相同
index1++；
index2++；
}
}
//无论哪个列表仍然有元素，都将它们全部添加到它的附加项中
对于（；index1

除了排序之外，这种方法的时间复杂度是

线性的