混合兩個通用列表java

Question

我有一個任務，我需要編寫一個方法，允許我混合兩個通用列表並返回一個新的混合列表。

混合列表應該在新混合列表的第一個位置具有l1的第一個元素，l2的第一個元素應該在第二個位置，然后l1的第二個元素應該在第三個位置，依此類推。

如果一個列表比另一個列表長，則其余列表應按原始順序添加。

一個例子是：l1 =（1,2,3）和l2 =（9,8） - >混合列表=（1,9,2,8,3）

public <S, T> List<T> listeMischen(List<S> l1, List<T> l2) {
    List<T> newlist = new ArrayList<T>();
    for(int i = 0; i < l1.size(); i++)
    { 
        for(int j = 0; j < l2.size(); j++) {
            newlist.add(charAt(i));
            newlist.add(charAt(j));
        }           
    }
    return newlist;
}

PS我不知道如何正確添加元素，因為它們是通用的。 我輸入了絕對錯誤的“charAt”方法，只是為了展示如果類型不是泛型而是字符，我會嘗試做什么。 由於元素可以是通用的，因此我不確定該怎么做。

Answer 1

這將返回兩個參數列表的泛型類型的公共超類型的列表：

public <R, S extends R, T extends R> List<R> listeMischen(List<S> l1, List<T> l2) {
    List<R> newList = new ArrayList<>(l1.size() + l2.size());
    int sizeOfLargerList = Math.max(l1.size(), l2.size());
    for (int i = 0; i < sizeOfLargerList; i++) {
        if (i < l1.size())
            newList.add(l1.get(i));
        if (i < l2.size())
            newList.add(l2.get(i));
    }
    return newList;
}

用法：

public static void main(String[] args) {
    List<Number> list = listeMischen(Arrays.asList(1, 2, 3), Arrays.asList(4.5, 5.5, 6.5, 7.5, 8.5));
    System.out.println(list);
}

預期產量==實際產量：

[1, 4.5, 2, 5.5, 3, 6.5, 7.5, 8.5]

---

更新 ：添加考慮了注釋的優化方法

下面顯示了該方法的兩個重載：一個用於隨機訪問列表（如ArrayList），另一個用於任何舊的可迭代類型，並為每種類型優化了主體。

 static <R> List<R> listeMischen(List<? extends R> l1, List<? extends R> l2) { if (!(l1 instanceof RandomAccess && l2 instanceof RandomAccess)) return listeMischen((Iterable<? extends R>) l1, (Iterable<? extends R>) l2); // Preallocate with known exact required capacity List<R> newList = new ArrayList<>(l1.size() + l2.size()); int sizeOfSmallerList = Math.min(l1.size(), l2.size()); int i; // Zip the lists up to common maximum index for (i = 0; i < sizeOfSmallerList; i++) { newList.add(l1.get(i)); newList.add(l2.get(i)); } // Add any remaining items from one or the other list for (; i < l1.size(); i++) newList.add(l1.get(i)); for (; i < l2.size(); i++) newList.add(l2.get(i)); return newList; } static <R> List<R> listeMischen(Iterable<? extends R> l1, Iterable<? extends R> l2) { List<R> newList = new ArrayList<>(); Iterator<? extends R> it1 = l1.iterator(); Iterator<? extends R> it2 = l2.iterator(); // Zip the lists up to common maximum index while (it1.hasNext() && it2.hasNext()) { newList.add(it1.next()); newList.add(it2.next()); } // Add any remaining items from one or the other lists it1.forEachRemaining(newList::add); it2.forEachRemaining(newList::add); return newList; } 

Answer 2

唯一明智的做法是返回Object列表。 泛型不會有幫助，因為您的列表是非同質的（並且不對列表的兩個對象類型之間的關系進行任何保證，暗示或明確）。

public List<Object> mixedList(List<?> a, List<?> b) {
    List<Object> result = new ArrayList<>();
    for(int i = 0, j = 0; i < a.size() && j < b.size(); i++, j++) {
        result.add(a.get(i));
        result.add(b.get(j));
    }

    return result;
}

我將編織元素的實際問題留給你為讀者規定的練習方式。 這應該滿足兩個列表長度相同的情況。

Answer 3

你必須為你的S和T找到一些共同點，或者S是T或者反過來或兩者都是某些 U子類型：

public <S extends T, T> List<T> listeMischen(List<S> l1, List<T> l2) {
    List<T> newlist = new ArrayList<>();
    // i will leave the "adding" logic to you, just for the sake of demonstration that you can add elements of both lists
    newlist.add(l1.get(0));
    newlist.add(l2.get(0));

    return newlist;
}

public <U, S extends U, T extends U> List<U> listeMischen2(List<S> l1, List<T> l2) {
    List<U> newlist = new ArrayList<>();
    // i will leave the "adding" logic to you, just for the sake of demonstration that you can add elements of both lists
    newlist.add(l1.get(0));
    newlist.add(l2.get(0));

    return newlist;
} 

Answer 4

假設S和T之間存在共同類型，您可以使用Iterator輕松完成此操作。

public <S extends T, T> List<T> listeMischen(Iterable<S> l1, Iterable<T> l2) {
    List<T> newlist = new ArrayList<T>();
    Iterator<S> l1i = l1.iterator();
    Iterator<T> l2i = l2.iterator();
    // Consume both while we can.
    while (l1i.hasNext() && l2i.hasNext()) {
        newlist.add(l1i.next());
        newlist.add(l2i.next());
    }
    // Consume whatever remains of the remaining list.
    while (l1i.hasNext()) {
        newlist.add(l1i.next());
    }
    while (l2i.hasNext()) {
        newlist.add(l2i.next());
    }
    return newlist;
}

如果沒有通用類型或接口，則必須使用List<Object> 。

Answer 5

其他答案表明不能使用泛型，或者結果的類型必須是List<Object> 。 更好的答案表明，兩個輸入列表的元素和輸出列表的元素之間必定存在某種類型關系。 其中最好的是DodgyCodeException的答案 （+1），它使用泛型類型邊界來要求結果列表的元素是兩個輸入列表的元素類型的超類型。

我將提供一個替代方案，即結果列表的類型是從輸入列表轉換元素的結果，並且輸入列表的元素類型不需要彼此有任何直接關系，也不需要與元素有任何直接關系結果列表的類型。 相反，提供了進行轉換的函數參數。

這是一個派生自DodgyCodeException的示例，它使用轉換函數，而不需要輸入和輸出之間的類型關系。

static <T, U, R> List<R> listMerge(List<T> l1, List<U> l2,
                                   Function<? super T, ? extends R> f1,
                                   Function<? super U, ? extends R> f2) {
    int size1 = l1.size();
    int size2 = l2.size();
    int max = Math.max(size1, size2);
    List<R> result = new ArrayList<>(size1 + size2);

    for (int i = 0; i < max; i++) {
        if (i < size1)
            result.add(f1.apply(l1.get(i)));
        if (i < size2)
            result.add(f2.apply(l2.get(i)));
    }

    return result;
}

這允許列表混合/轉換，如下所示：

List<String> list = listMerge(List.of(1, 2, 3), List.of(4.5, 5.5, 6.5, 7.5, 8.5),
                              i -> String.format("0x%x", i),
                              d -> String.format("%.1f", d));

[0x1, 4.5, 0x2, 5.5, 0x3, 6.5, 7.5, 8.5]

各種流式壓縮方法，例如Guava的Streams.zip ，也采用功能轉換方法而不是類型綁定方法。