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

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

例如，我有一个

集合

，希望用括号将所有字符串括起来

通过循环，我可以这样做：

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

Iterable collection=getCollection（）；
ArrayList newCollection=新ArrayList（）；
for（字符串str:collection）
添加（“+str+”）；

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

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

不，不允许。仅使用JDK类是做不到更好的

编辑

试试谷歌收藏库：

List out=Lists.transform（in，new Function（））{
公共字符串应用（字符串s）{
返回String.format（（%s）”，s）；
}
});

您可以从Apache commons集合中使用。

使用：

---

在我看来，您似乎在尝试将函数式习惯用法用于Java。虽然这可以通过使用第三方libs和functor实现（正如其他人所建议的），但我建议使用Java习惯用法或使用函数式语言编程Java。如果您想要一种与JVM兼容的函数式语言，请看。

这实际上是Java的一个不足，已经讨论了很多。在许多语言中，使用闭包（或代码块）只需一行代码就可以做到这一点。例如，在Groovy中，可以按如下方式编写：

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

我希望，我们可以在java 7中实现这一点。

您需要一个。这些（除其他外）在中提供。示例代码：

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);

    }

}

导入fj.F；
导入fj.data.List；
导入静态fj.data.List.*；
导入静态fj.pre.Show.listShow；
导入静态fj.pre.Show.stringShow；
导入静态java.lang.String.format；
公开课考试{
公共静态void main（字符串[]args）{
列表a=列表（“a”、“b”、“c”）；
列表b=a.map（新的F（）{
公共字符串f（字符串s）{
返回格式（（%s）”，s）；
}
});
listShow（stringShow）.println（a）；
listShow（stringShow）.println（b）；
}
}

，现在，在我烹饪“意大利面”的同时，我正在考虑一种更面向对象的方法

对于一个匿名类实现，它用一个围绕（）的元素来覆盖它的迭代器，您怎么看

公共静态集合包装（最终集合）{
final Iterator Iterator=collection.Iterator（）；
返回新的AbstractCollection（）{
@凌驾
公共整数大小（）{
返回collection.size（）；
}
@凌驾
公共迭代器迭代器（）{
返回新的迭代器（）{
公共布尔hasNext（）{
返回iterator.hasNext（）；
}
公共字符串next（）{
返回String.format（（%s）”，iterator.next（）；
}
公共空间删除（）{
iterator.remove（）；
}
};
}
};
}

演示

List in=Arrays.asList（“aaa”、“bbb”）；
List out=新阵列列表（换行（in））；
System.out.println（out）；

产出：

[(aaa), (bbb)] [（aaa）、（bbb）] 顺便说一句，这只使用JDK类，不使用循环

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

你为什么要这么做？由于Java没有闭包，因此闭包通常更加复杂、非标准且更难阅读

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

---

顺便说一句：循环仍然被使用，只是你不能直接使用，所以这种区别只是一种错觉。

查看lambdaj库

---

您将发现大量的方法可以以DSL样式操作集合，而无需编写单个显式循环

允许使用第三方：）+1用于此部分的可读性：String.format（（%s）”，s）；不过，您只是在传递循环。“无循环修改”的想法几乎类似于“无可执行运行应用程序”，必须有人将循环隐藏在某个地方。clojures因Java 7Oh而被拒绝，这真是个坏消息！我已经好几个月没看新闻了，我不知道发生了什么事。我只是在寻找，不幸的是，你似乎是真的。

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);

    }

}

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