JavaでのPythonのようなリストの理解

Question

Javaはパラメータとしてメソッドを渡すことができないので、Javaでリストの理解のようにPythonを実装するのにどのようなトリックを使用しますか？

私は文字列のリスト（ArrayList）を持っています。私は別のリストを得るために関数を使って各要素を変換する必要があります。私は文字列を入力として受け取り、別の文字列を出力として返すいくつかの関数を持っています。リストと関数をパラメータとして与えることができる汎用メソッドを作成するにはどうすればよいのでしょうか。文字通りの意味では不可能ですが、私はどんなトリックを使うべきですか？

もう一つの選択肢は、リスト全体を単にループする小さな文字列処理関数ごとに新しい関数を書くことです。これはあまりクールではありません。

Answer 1

基本的に、あなたは関数インタフェースを作成：

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 2

Google Collections libraryは、プレーンなJavaサポートよりもはるかに高いレベルで、機能的な方法（フィルタ、マップ、フォールドなど）で、コレクションとイテレータを扱うためのクラスがたくさんあります。 FunctionとPredicateのインタフェースとメソッドを定義し、コレクションを処理して、そうする必要がないようにします。また、Javaジェネリックの扱いを難しくする便利な機能も備えています。

また、フィルタリングコレクションにHamcrest **を使用します。

2つのライブラリは、アダプタクラスとの組み合わせが容易です。

---

**関心の宣言：私は共同書いたHamcrest

Answer 3

Apache Commons CollectionsUtil.transform(Collection, Transformer)は別のオプションです。

Answer 4

のJava 8で使用できるメソッド参照：

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

それとも、新しいリストのインスタンスを作成する場合：

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

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

ようないくつかの方法で出力式を変換したい場合は、そのような機能のためのラムダを使用することができます。

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"]