Java泛型合并

Question

我编写了一个合并函数，它将两个排序列表合并为一个排序列表。下面是代码的场景。

1. 合并列表2、4、6、3、5、6、7会产生2、3、4、5、6、6、7。
2. 将“Alice”、“Tom”、“Bob”、“Richard”的列表合并，生成“Alice”、“Bob”、“Richard”、“Tom”。
3. 合并列表2.3，4.5，2,5产生2，2.3，4.5，5。
4. 将“A”、“XYZ”、“AXTU”和2, 4, 6列表合并产生“A”、2、“XYZ”、“AXTU”、4、6； 公共静态testCombine() { ArrayList mainList =新ArrayList<>()；ArrayList list1 =新ArrayList(Arrays.asList("Alice"，"Tom"))；ArrayList list2 =新ArrayList(“Bob”，“Richard”)；mainList.add(list1)；mainList.add(list2)；私有静态> ArrayList组合(Stream流){返回stream.reduce((x，y) -> { x.addAll(y)；Collections.sort(x)；返回x；}).get()；}

但是，我没有得到3和4类型的结果。我必须实现最通用的合并函数，假设输入列表按排序顺序(根据自然顺序或指定顺序)。

Answer 1

这和你想要的差不多吗？使用Stream可能有一种更简单的方法来做到这一点，最好尽可能地使用List<String>而不是ArrayList<String>，例如List<String> list=new ArrayList<String>。

public static void testCombine() {
    List<String> stringList1 = new ArrayList<>(Arrays.asList("A", "AB", "XYZ", "AXTU"));
    List<Integer> integerList2 = new ArrayList<>(Arrays.asList(2, 4, 6));
    System.out.println(Main.combine(stringList1, integerList2, new MergeTwoTypes<String, Integer>() {
        @Override
        public Function<? super Integer, ? extends String> map() {
            return (x)->Integer.toString(x);
        }

        @Override
        public boolean isVal2Larger(String val, Integer val2) {
            return val.length()>val2;
        }
    }));
    List<Double> list1 = new ArrayList<>(Arrays.asList(2.3, 4.5));
    List<Integer> list2 = new ArrayList<>(Arrays.asList(2, 5));
    System.out.println(Main.combine(list1, list2, new MergeTwoTypes<Double, Integer>() {
        @Override
        public Function<? super Integer, ? extends Double> map() {
            return ((Integer x) -> new Double(x));
        }

        @Override
        public boolean isVal2Larger(Double val, Integer val2) {
            return val>val2;
        }
    }));
}

private static <T, U> List<T> combine(List<T> vals1, List<U> vals2, MergeTwoTypes<T, U> mergeTwoTypes) {
    List<T> list=new ArrayList<>();
    int vals2Index=0;
    for(T val:vals1) {
        for(; vals2Index<vals2.size(); vals2Index++) {
            U val2=vals2.get(vals2Index);
            if(mergeTwoTypes.isVal2Larger(val, val2)) {
                list.add(mergeTwoTypes.map().apply(val2));
            }
            else {
                break;
            }
        }
        list.add(val);
    }
    for(; vals2Index<vals2.size(); vals2Index++) {
        U val2=vals2.get(vals2Index);
        list.add(mergeTwoTypes.map().apply(val2));
    }
    return list;
}

private static <T extends Comparable<? super T>> List<T> combine(List<T> vals1, List<T> vals2) {
    List<T> list=new ArrayList<>();
    list.addAll(vals1);
    list.addAll(vals2);
    Collections.sort(list);
    return list;
}

interface MergeTwoTypes<T,U> {
    boolean isVal2Larger(T val, U val2);
    Function<? super U, ? extends T> map();
}