25

私はリストを持っていて、それを単一の値（関数型プログラミング用語「fold」、Ruby用語inject）に減らしたいと思っています。

Arrays.asList("a", "b", "c") ... fold ... "a,b,c"

関数型プログラミングのアイデア（Scala）に感染しているので、それをコーディングするよりも簡単で短い方法を探しています。

sb = new StringBuilder
for ... {
  append ...
}
sb.toString
4

14 に答える 14

13

元の質問に答えるには：

public static <A, B> A fold(F<A, F<B, A>> f, A z, Iterable<B> xs)
{ A p = z;
  for (B x : xs)
    p = f.f(p).f(x);
  return p; }

F は次のようになります。

public interface F<A, B> { public B f(A a); }

dfa が示唆したように、Functional Javaにはこれが実装されています。

例 1:

import fj.F;
import static fj.data.List.list;
import static fj.pre.Monoid.stringMonoid;
import static fj.Function.flip;
import static fj.Function.compose;

F<String, F<String, String>> sum = stringMonoid.sum();
String abc = list("a", "b", "c").foldLeft1(compose(sum, flip(sum).f(",")));

例 2:

import static fj.data.List.list;
import static fj.pre.Monoid.stringMonoid;
...
String abc = stringMonoid.join(list("a", "b", "c"), ",");

例 3:

import static fj.data.Stream.fromString;
import static fj.data.Stream.asString;
...
String abc = asString(fromString("abc").intersperse(','));
于 2009-06-04T15:38:04.033 に答える
10

与えられた

public static <T,Y> Y fold(Collection<? extends T> list, Injector<T,Y> filter){
  for (T item : list){
    filter.accept(item);
  }
  return filter.getResult();
}

public interface Injector<T,Y>{
  public void accept(T item);
  public Y getResult();
}

次に、使用法は次のようになります

fold(myArray, new Injector<String,String>(){
  private StringBuilder sb = new StringBuilder();
  public void Accept(String item){ sb.append(item); }
  public String getResult() { return sb.toString(); }
}
);
于 2009-06-04T14:38:18.623 に答える
8

LamdaJは可能ですが 、言語を切り替えることなく、プレーンな古い Java にいくつかの機能的側面を適用したい場合、fork-join (166y)とgoogle-collectionsは、その構文糖衣を追加するのに役立つライブラリです。

google-collectionsの助けを借りて、 Joiner クラスを使用できます。

Joiner.on(",").join("a", "b", "c")

Joiner.on(",")は不変オブジェクトなので、自由に共有できます (たとえば、定数として)。

Joiner.on(", ").useForNull("nil");またはのような null 処理を構成することもできますJoiner.on(", ").skipNulls()。

大きな文字列を生成しているときに大きな文字列を割り当てないようにするために、それを使用して、AppendableインターフェイスまたはStringBuilderクラスを介して既存の Streams、StringBuilders などに追加できます。

Joiner.on(",").appendTo(someOutputStream, "a", "b", "c");

マップを書き出すときは、エントリとキーと値の間の区切りに 2 つの異なる区切り記号が必要です。

Joiner.on(", ").withKeyValueSeparator(":")
            .join(ImmutableMap.of(
            "today", "monday"
            , "tomorrow", "tuesday"))
于 2009-06-08T22:22:52.123 に答える
7

あなたが探しているのは、join()Java が 8.0 以降持っている文字列メソッドです。以下のいずれかの方法を試してください。

  1. 静的メソッドString#join(delimiter, elements):

    Collection<String> source = Arrays.asList("a", "b", "c");
String result = String.join(",", source);

  2. ストリームfoldLeftインターフェイスは、Scala の関数と非常によく似た折り畳み操作をサポートしています。次の連結Collectorを見てください。

    Collection<String> source = Arrays.asList("a", "b", "c");
String result = source.stream().collect(Collectors.joining(","));

    Collectors.joiningコードをより明確にするために、静的にインポートすることをお勧めします。

    ちなみに、このコレクターは特定のオブジェクトのコレクションに適用できます。

    Collection<Integer> numbers = Arrays.asList(1, 2, 3);
String result = numbers.stream()
        .map(Object::toString)
        .collect(Collectors.joining(","));
于 2015-03-17T12:54:43.860 に答える
6

あなたが探しているのは、残念ながらJavaにはない文字列の「結合」関数です。自分の結合関数をロールする必要がありますが、それほど難しくはありません。

編集： org.apache.commons.lang.StringUtilsには、多くの便利な文字列関数（結合を含む）があるようです。

于 2009-06-04T13:58:50.297 に答える
3

Eclipse CollectionsにはinjectInto(Ruby や Smalltalk のように)、makeStringおよびappendString. 以下はあなたの例で動作します：

String result1 = FastList.newListWith("a", "b", "c").makeString(",");
StringBuilder sb = new StringBuilder();
FastList.newListWith("a", "b", "c").appendString(sb, ",");
String result2 = sb.toString();
Assert.assertEquals("a,b,c", result1); 
Assert.assertEquals(result1, result2);

注: 私は Eclipse コレクションのコミッターです。

于 2013-01-08T17:53:36.707 に答える
2

残念ながら、Javaではそのループを回避することはできませんが、いくつかのライブラリがあります。たとえば、いくつかのライブラリを試すことができます。

于 2009-06-04T13:58:33.027 に答える
2

まず、一般的なファンクターと、fold などの関数プロジェクションを提供する Java 用の関数型ライブラリが必要です。ここで、強力な（美徳による）シンプルなライブラリを設計および実装しました：http://www.codeproject.com/KB/java/FunctionalJava.aspx（言及されている他のライブラリは非常に複雑であることがわかりました）。

次に、ソリューションは次のようになります。

Seq.of("","a",null,"b","",null,"c","").foldl(
    new StringBuilder(), //seed accumulator
    new Func2<StringBuilder,String,StringBuilder>(){
        public StringBuilder call(StringBuilder acc,String elmt) {
            if(acc.length() == 0) return acc.append(elmt); //do not prepend "," to beginning
            else if(elmt == null || elmt.equals("")) return acc; //skip empty elements
            else return acc.append(",").append(elmt);
        }
    }
).toString(); //"a,b,c"

フォールドを適用することによって、実際に考慮する必要がある唯一の部分は Func2.call の実装であることに注意してください。これは、アキュムレータと要素を受け入れてアキュムレータを返す演算子を定義する 3 行のコードです (私の実装では、空の文字列とそのケースを削除すると、2 行のコードになります)。

Seq.foldl の実際の実装は次のとおりです。Seq は Iterable<E> を実装しています。

public <R> R foldl(R seed, final Func2<? super R,? super E,? extends R> binop)
{
    if(binop == null)
        throw new NullPointerException("binop is null");

    if(this == EMPTY)
        return seed;

    for(E item : this)
        seed = binop.call(seed, item);

    return seed;
}
于 2010-05-21T17:48:16.200 に答える
1

残念ながら、Javaは関数型プログラミング言語ではなく、あなたが望むことをするための良い方法がありません。

Apache Commons libには、joinと呼ばれる関数があり、必要な処理を実行できると思います。

メソッド内のループを非表示にするのに十分である必要があります。

public static String combine(List<String> list, String separator){
    StringBuilder ret = new StringBuilder();
    for(int i = 0; i < list.size(); i++){
        ret.append(list.get(i));
        if(i != list.size() - 1)
            ret.append(separator);
    }
    return ret.toString();
}

私はあなたがそれを再帰的に行うことができると思います：

public static String combine(List<String> list, String separator){
    return recursiveCombine("", list, 0, separator);
}

public static String recursiveCombine(String firstPart, List<String> list, int posInList, String separator){
    if (posInList == list.size() - 1) return firstPart + list.get(posInList);

    return recursiveCombine(firstPart + list.get(posInList) + separator, list, posInList + 1, seperator);
}
于 2009-06-04T13:59:13.273 に答える
1

String.join()Java 8 で使用できるようになりました。

    List strings = Arrays.asList("a", "b", "c");
    String joined = String.join(",", strings);
    System.out.println(joined);
于 2015-07-30T12:09:56.963 に答える
1

以下は、取り残されたノードの情報を保持し、先に進むにつれて折りたたむことによって、リストを折りたたむコードです。

public class FoldList {
    public static void main(String[] args) {
        Node a = new Node(1);
        Node b = new Node(2);
        Node c = new Node(3);
        Node d = new Node(4);
        Node e = new Node(5);
        Node f = new Node(6);
        Node g = new Node(7);
        Node h = new Node(8);
        Node i = new Node(9);
        a.next = b;
        b.next = c;
        c.next = d;
        d.next = e;
        e.next = f;
        f.next = g;
        g.next = h;
        h.next = i;

        foldLinkedList(a);

    }

    private static void foldLinkedList(Node a) {
        Node middle = getMiddleNodeOfTheList(a);
        reverseListOnWards(middle);
        foldTheList(a, middle);

    }

    private static Node foldTheList(Node a, Node middle) {
        Node leftBackTracePtr = a;
        Node leftForwardptr = null;
        Node rightBackTrack = middle;
        Node rightForwardptr = null;
        Node leftCurrent = a;
        Node rightCurrent = middle.next;
        while (middle.next != null) {
            leftForwardptr = leftCurrent.next;
            rightForwardptr = rightCurrent.next;
            leftBackTracePtr.next = rightCurrent;
            rightCurrent.next = leftForwardptr;
            rightBackTrack.next = rightForwardptr;
            leftCurrent = leftForwardptr;
            leftBackTracePtr = leftCurrent;
            rightCurrent = middle.next;
        }
        leftForwardptr = leftForwardptr.next;
        leftBackTracePtr.next = middle;
        middle.next = leftForwardptr;

        return a;

    }

    private static void reverseListOnWards(Node node) {
        Node startNode = node.next;
        Node current = node.next;
        node.next = null;
        Node previous = null;
        Node next = node;
        while (current != null) {
            next = current.next;
            current.next = previous;
            previous = current;
            current = next;
        }
        node.next = previous;

    }

    static Node getMiddleNodeOfTheList(Node a) {
        Node slowptr = a;
        Node fastPtr = a;
        while (fastPtr != null) {
            slowptr = slowptr.next;
            fastPtr = fastPtr.next;
            if (fastPtr != null) {
                fastPtr = fastPtr.next;
            }
        }
        return slowptr;

    }

    static class Node {
        public Node next;
        public int value;

        public Node(int value) {
            this.value = value;
        }

    }
}
于 2016-09-10T15:17:11.037 に答える
1

ラムダのサポートにより、次のコードで実行できます。

static <T, R> R foldL(BiFunction<R, T, R> lambda, R zero, List<T> theList){

     if(theList.size() == 0){
      return zero;
     }

     R nextZero = lambda.apply(zero,theList.get(0));

     return foldL(lambda, nextZero, theList.subList(1, theList.size()));                  
    }
于 2015-11-17T09:46:57.157 に答える
-3

そのような関数はありませんが、次のような関数を作成して、必要なときに呼び出すことができます。

import java.util.Arrays;
import java.util.List;

public class FoldTest {
    public static void main( String [] args ) {
        List<String> list = Arrays.asList("a","b","c");
        String s = fold( list, ",");
        System.out.println( s );
    }
    private static String fold( List<String> l, String with  ) {
        StringBuilder sb = new StringBuilder();
        for( String s: l ) {
            sb.append( s ); 
            sb.append( with );
        }
        return sb.deleteCharAt(sb.length() -1 ).toString();

    }
}
于 2010-09-07T18:49:08.263 に答える