Question

如何在不使用任何循环的情况下修改集合中的值以获取具有修改值的新集合？

例如，我有一个Collection<String>并希望用括号括起所有字符串。

使用循环我会这样做：

Iterable<String> collection = getCollection();
ArrayList<String> newCollection = new ArrayList<String>();    
for(String str : collection) 
    newCollection.add("(" + str + ")");

必须有一个更优雅的解决方案。

编辑：允许使用第三方实用程序：）

Answer 1

~~不，没有。仅使用JDK类，您无法做得更好。~~ Check my second answer

修改

尝试谷歌收藏库Lists.trasform：

List<String> out = Lists.transform(in, new Function<String, String>() { public String apply(String s) { return String.format("(%s)", s); } });

Answer 2

您可以使用Apache commons集合中的CollectionUtils.transform。

Answer 3

使用Apache Commons CollectionUtils：

List l = someList;
CollectionUtils.transform(l, new Transformer() {
    public Object transform(Object o)
    {
        String s = (String) o;
        return "(" + s + ")";
    }
});

Answer 4

听起来我觉得你正在尝试使用Java的功能习语。虽然这可以使用第三方库和仿函数来实现（正如其他人所建议的那样），但我建议使用Java习语编写Java或使用函数式语言。如果您需要与JVM兼容的函数式语言，请查看Scala。

Answer 5

你想要一个Map function。 functional java中提供了这些内容（以及其他内容）。示例代码：

import fj.F;
import fj.data.List;
import static fj.data.List.*;
import static fj.pre.Show.listShow;
import static fj.pre.Show.stringShow;

import static java.lang.String.format;

public class Test {

    public static void main(String[] args) {

        List<String> a = list("a", "b", "c");
        List<String> b = a.map(new F<String, String>() {

            public String f(String s) {
                return format("(%s)", s);
            }

        });

        listShow(stringShow).println(a);
        listShow(stringShow).println(b);

    }

}

Answer 6

如何在不使用任何循环的情况下修改集合中的值以获取具有修改值的新集合？

你为什么要这样？由于Java没有闭包，这通常更复杂，非标准且更难以阅读。

您将注意到您的示例比其他解决方案更短更简单，并且它使用标准java。

BTW：循环仍然被使用，而不是直接由你使用，因此区别是一种错觉。

Answer 7

查看lambdaj库

http://code.google.com/p/lambdaj/

你会发现一大堆少数方法来处理DSL风格的集合，而无需编写单个显式循环

Answer 8

这实际上是Java短缺，已经讨论了很多。在许多语言中，您只需使用闭包（或代码块）就可以在一行代码中完成。例如，在Groovy中，您可以按如下方式编写它：

newCollection = collection.collect { "($it)" }

我希望，我们可以在java 7中做到这一点。

Answer 9

my previous answer was functional oriented，现在，同时我正在烹饪“spaghetti al pomodoro”，我正在考虑更多面向对象的方法。

你如何看待一个匿名类实现覆盖它的迭代器，并将它的元素括在（）周围？

public static <T> Collection<String> wrap(final Collection<T> collection) {
    final Iterator<T> iterator = collection.iterator();
    return new AbstractCollection<String>() {

        @Override
        public int size() {
            return collection.size();
        }

        @Override
        public Iterator<String> iterator() {
            return new Iterator<String>() {

                public boolean hasNext() {
                    return iterator.hasNext();
                }

                public String next() {
                    return String.format("(%s)", iterator.next());
                }

                public void remove() {
                    iterator.remove();
                }
            };
        }
    };
}

演示

List<String> in = Arrays.asList("aaa","bbb");
List<String> out = new ArrayList<String>(wrap(in));
System.out.println(out);

输出：

[(aaa), (bbb)]

BTW这只使用JDK类并且不使用循环！

如何在没有任何循环的情况下修改集合值以获取新集合？

9 个答案:

演示