Java 中類似 Python 的列表理解

Question

由於 Java 不允許將方法作為參數傳遞，那么在 Java 中您使用什么技巧來實現 Python 之類的列表理解？

我有一個字符串列表（ArrayList）。 我需要使用函數來轉換每個元素，以便獲得另一個列表。 我有幾個函數將一個字符串作為輸入並返回另一個字符串作為輸出。 我如何創建一個通用方法，該方法可以將列表和函數作為參數，以便我可以獲取處理每個元素的列表。 從字面上看這是不可能的，但是我應該使用什么技巧？

另一種選擇是為每個較小的字符串處理函數編寫一個新函數，它只是循環遍歷整個列表，這有點不太酷。

Answer 1

在 Java 8 中，您可以使用方法引用：

List<String> list = ...;
list.replaceAll(String::toUpperCase);

或者，如果您想創建一個新的列表實例：

List<String> upper = list.stream().map(String::toUpperCase).collect(Collectors.toList());

Answer 2

基本上，您創建一個 Function 接口：

public interface Func<In, Out> {
    public Out apply(In in);
}

然后將匿名子類傳遞給您的方法。

您的方法可以將函數應用到每個元素就地：

public static <T> void applyToListInPlace(List<T> list, Func<T, T> f) {
    ListIterator<T> itr = list.listIterator();
    while (itr.hasNext()) {
        T output = f.apply(itr.next());
        itr.set(output);
    }
}
// ...
List<String> myList = ...;
applyToListInPlace(myList, new Func<String, String>() {
    public String apply(String in) {
        return in.toLowerCase();
    }
});

或創建一個新List （基本上創建從輸入列表到輸出列表的映射）：

public static <In, Out> List<Out> map(List<In> in, Func<In, Out> f) {
    List<Out> out = new ArrayList<Out>(in.size());
    for (In inObj : in) {
        out.add(f.apply(inObj));
    }
    return out;
}
// ...
List<String> myList = ...;
List<String> lowerCased = map(myList, new Func<String, String>() {
    public String apply(String in) {
        return in.toLowerCase();
    }
});

哪一個更可取取決於您的用例。 如果您的列表非常大，就地解決方案可能是唯一可行的解​​決方案； 如果您希望將許多不同的函數應用於同一個原始列表以制作許多衍生列表，您將需要map版本。

Answer 3

Google Collections 庫有許多類用於在比普通 Java 支持的更高級別上以功能方式（過濾器、映射、折疊等）處理集合和迭代器。 它定義了 Function 和 Predicate 接口以及使用它們來處理集合的方法，這樣您就不必這樣做了。 它還具有方便的功能，使處理 Java 泛型變得不那么困難。

我還使用Hamcrest ** 過濾集合。

這兩個庫很容易與適配器類結合。

---

** 利益聲明：我共同編寫了 Hamcrest

Answer 4

Apache Commons CollectionsUtil.transform(Collection, Transformer)是另一種選擇。

Answer 5

我正在構建這個項目來用 Java 編寫列表理解，現在是https://github.com/farolfo/list-comprehension-in-java 中的概念證明

例子

// { x | x E {1,2,3,4} ^ x is even }
// gives {2,4}

Predicate<Integer> even = x -> x % 2 == 0;

List<Integer> evens = new ListComprehension<Integer>()
    .suchThat(x -> {
        x.belongsTo(Arrays.asList(1, 2, 3, 4));
        x.is(even);
    });
// evens = {2,4};

如果我們想以某種方式轉換輸出表達式，例如

// { x * 2 | x E {1,2,3,4} ^ x is even }
// gives {4,8}

List<Integer> duplicated = new ListComprehension<Integer>()
    .giveMeAll((Integer x) -> x * 2)
    .suchThat(x -> {
        x.belongsTo(Arrays.asList(1, 2, 3, 4));
        x.is(even);
    });
// duplicated = {4,8}

Answer 6

您可以對函數使用 lambda，如下所示：

class Comprehension<T> {
    /**
    *in: List int
    *func: Function to do to each entry
    */
    public List<T> comp(List<T> in, Function<T, T> func) {
        List<T> out = new ArrayList<T>();
        for(T o: in) {
            out.add(func.apply(o));
        }
        return out;
    }
}

用法：

List<String> stuff = new ArrayList<String>();
stuff.add("a");
stuff.add("b");
stuff.add("c");
stuff.add("d");
stuff.add("cheese");
List<String> newStuff = new Comprehension<String>().comp(stuff, (a) -> { //The <String> tells the comprehension to return an ArrayList<String>
    a.equals("a")? "1": 
            (a.equals("b")? "2": 
                (a.equals("c")? "3":
                    (a.equals("d")? "4": a
    )))
});

將返回：

["1", "2", "3", "4", "cheese"]

Answer 7

import java.util.Arrays;

class Soft{
    public static void main(String[] args){
        int[] nums=range(9, 12);
        System.out.println(Arrays.toString(nums));
    }
    static int[] range(int low, int high){
        int[] a=new int[high-low];
        for(int i=0,j=low;i<high-low;i++,j++){
            a[i]=j;
        }
        return a;

    }
}

希望，我能幫助你:)