Question

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

合并列表[2,4,6]，[3,5,6,7]会产生[2,3,4,5,6,6,7]。
合并列表[“Alice”，“Tom”]，[“Bob”，“Richard”]会产生[“Alice”，“Bob”，“Richard”，“Tom”]。
合并列表[2.3,4.5]，[2,5]会产生[2,2.3,4.5,5]。

合并列表[“A”，“XYZ”，“AXTU”]和[2,4,6]（其中第一个列表按字长排序，在合并操作中，如果是字符串第一个列表中的长度与第二个列表中的数字相同，字符串首先出现）产生[“A”，2，“XYZ”，“AXTU”，4,6];

 public static void testCombine() {
    ArrayList<ArrayList<String>> mainList = new ArrayList<>();
    ArrayList<String> list1 = new ArrayList<String>(Arrays.asList("Alice", "Tom"));
    ArrayList<String> list2 = new ArrayList<String>(Arrays.asList("Bob", "Richard"));
    mainList.add(list1);
    mainList.add(list2);
    System.out.println(combine(mainList.stream()));
}

private static <T extends Comparable<? super T>> ArrayList<T> combine(Stream<ArrayList<T>> stream) {
    return stream.reduce((x, y) -> {
        x.addAll(y);
        Collections.sort(x);
        return 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();
}

Java泛型合并

1 个答案: