关于java：将List <Integer>转换为List <String>

Converting List to List

我有一个整数列表，List，我想将所有整数对象都转换为字符串，从而以一个新的List结尾。

自然，我可以创建一个新的List并遍历每个整数调用String.valueOf()的列表，但是我想知道是否有更好的方法(阅读：更自动)？

使用Guava-Project提供的Google Collections，您可以在Lists类中使用transform方法

1
2
3
4
5
6

import com.google.common.collect.Lists;
import com.google.common.base.Functions

List<Integer> integers = Arrays.asList(1, 2, 3, 4);

List<String> strings = Lists.transform(integers, Functions.toStringFunction());

transform返回的List是后备列表上的视图-转换将应用于对转换列表的每次访问。

请注意，将Functions.toStringFunction()应用于null时将抛出NullPointerException，因此仅当您确定列表中不包含null时才使用它。

据我所知，迭代和实例化是实现此目的的唯一方法。诸如此类的东西(对于其他潜在的帮助，因为我确定您知道该怎么做)：

1
2
3
4
5
6

List<Integer> oldList = ...
/* Specify the size of the list up front to prevent resizing. */
List<String> newList = new ArrayList<String>(oldList.size())
for (Integer myInt : oldList) {
newList.add(String.valueOf(myInt));
}

Java 8.的解决方案比Guava的解决方案长一点，但是至少您不必安装库。

1
2
3
4
5
6
7
8
9

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

//...

List<Integer> integers = Arrays.asList(1, 2, 3, 4);
List<String> strings = integers.stream().map(Object::toString)
.collect(Collectors.toList());

您正在做的事情很好，但是如果您需要" Java-it-up"，则可以使用Transformer和Apache Commons的collect方法，例如：

1
2
3
4
5

public class IntegerToStringTransformer implements Transformer<Integer, String> {
public String transform(final Integer i) {
return (i == null ? null : i.toString());
}
}

..接着..

1
2
3
4

CollectionUtils.collect(
collectionOfIntegers,
new IntegerToStringTransformer(),
newCollectionOfStrings);

而不是使用String.valueOf我会使用.toString();它避免了@ johnathan.holland描述的一些自动装箱

Javadoc说valueOf返回与Integer.toString()相同的东西。

1
2
3
4
5
6

List<Integer> oldList = ...
List<String> newList = new ArrayList<String>(oldList.size());

for (Integer myInt : oldList) {
newList.add(myInt.toString());
}

这是一种单行解决方案，无需与非JDK库作弊。

1	List<String> strings = Arrays.asList(list.toString().replaceAll("\\[(.*)\\]","$1").split(","));

String.valueOf的源显示如下：

1
2
3

public static String valueOf(Object obj) {
return (obj == null) ?"null" : obj.toString();
}

并不是很重要，但是我会使用toString。

使用Guava和Java 8的另一种解决方案

1 2	List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); List<String> strings = Lists.transform(numbers, number -> String.valueOf(number));

不是核心Java，也不是通用化的，但是流行的Jakarta Commons Collections库为此类任务提供了一些有用的抽象。具体来说，看看下面的collect方法

实用工具

如果您已经在项目中使用了commons集合，请考虑一下。

对于那些关心"拳击"的人们，jsight的回答是：没有。在此使用String.valueOf(Object)，并且从未执行过对int的拆箱操作。

使用Integer.toString()还是String.valueOf(Object)取决于您要如何处理可能的null。您是否要引发异常(可能)，或列表中包含"空"字符串(也许)。如果是前者，是否要抛出NullPointerException或其他类型？

另外，jsight响应中的一个小缺陷：List是一个接口，您不能在其上使用new运算符。在这种情况下，我可能会使用java.util.ArrayList，尤其是因为我们预先知道该列表可能会持续多长时间。

Lambdaj允许以非常简单且易读的方式进行操作。例如，假设您有一个Integer列表，并且想要将它们转换为相应的String表示形式，则可以编写类似的代码；

1
2
3
4

List<Integer> ints = asList(1, 2, 3, 4);
Iterator<String> stringIterator = convertIterator(ints, new Converter<Integer, String> {
public String convert(Integer i) { return Integer.toString(i); }
}

Lambdaj仅在迭代结果时才应用转换功能。

仅针对专家的答案：

1
2
3
4

List<Integer> ints = ...;
String all = new ArrayList<Integer>(ints).toString();
String[] split = all.substring(1, all.length()-1).split(",");
List<String> strs = Arrays.asList(split);

@乔纳森：我可能会误会，但我相信在这种情况下，String.valueOf()会调用String.valueOf(Object)函数，而不是装箱成String.valueOf(int)。 String.valueOf(Object)如果为null，则仅返回" null"；如果非null，则调用Object.toString()，这不应该涉及装箱(尽管显然要实例化新的字符串对象)。

1	List<String> stringList = integerList.stream().map((Object s)->String.valueOf(s)).collect(Collectors.toList())

我认为将Object.toString()用于除调试以外的其他目的可能是一个非常糟糕的主意，即使在这种情况下，两者在功能上是等效的(假设列表中没有空值)。开发人员可以自由更改任何toString()方法的行为，而不会发出任何警告，包括标准库中任何类的toString()方法。

甚至不用担心装箱/拆箱过程导致的性能问题。如果性能至关重要，则只需使用一个阵列即可。如果确实很关键，请不要使用Java。试图超越JVM只会导致心痛。

您无法避免"装箱费用"； Java的虚假通用容器只能存储对象，因此必须将int装箱为Integers。原则上，它可以避免从Object到Integer的贬低(因为它毫无意义，因为Object对于String.valueOf和Object.toString都足够好)，但我不知道编译器是否足够聪明。从String到Object的转换应该或多或少是无操作的，因此我不希望为此担心。

这是一件非常基本的事情，我不会使用外部库(这会导致您的项目中可能不需要的依赖项)。

我们有一类专门设计用于完成此类工作的静态方法。因为此代码非常简单，所以让Hotspot为我们进行优化。最近，这似乎是我代码中的主题：编写非常简单(直接)的代码，然后让Hotspot发挥作用。我们很少会遇到类似这样的代码的性能问题-当出现新的VM版本时，您将获得所有额外的速度优势等。

尽管我非常喜欢雅加达(Jakarta)系列，但它们不支持Generics，并使用1.4作为LCD。我对Google Collections保持警惕，因为它们被列为Alpha支持级别！

使用流：
如果说结果是整数列表(List result)，则：

1	List<String> ids = (List<String>) result.stream().map(intNumber -> Integer.toString(intNumber)).collect(Collectors.toList());

解决它的方法之一。希望这可以帮助。

I didn't see any solution which is following the principal of space
complexity. If list of integers has large number of elements then it's
big problem.

1 2	It will be really good to remove the integer from the List<Integer> and free the space, once it's added to List<String>.

我们可以使用迭代器来实现相同的目的。

1
2
3
4
5
6
7
8
9
10
11
12

List<Integer> oldList = new ArrayList<>();
oldList.add(12);
oldList.add(14);
.......
.......

List<String> newList = new ArrayList<String>(oldList.size());
Iterator<Integer> itr = oldList.iterator();
while(itr.hasNext()){
newList.add(itr.next().toString());
itr.remove();
}

只是为了好玩，一个应该在JDK7中使用jsr166y fork-join框架的解决方案。

1
2
3
4
5
6
7
8
9
10
11
12

import java.util.concurrent.forkjoin.*;

private final ForkJoinExecutor executor = new ForkJoinPool();
...
List<Integer> ints = ...;
List<String> strs =
ParallelArray.create(ints.size(), Integer.class, executor)
.withMapping(new Ops.Op<Integer,String>() { public String op(Integer i) {
return String.valueOf(i);
}})
.all()
.asList();

(免责声明：未编译。规范尚未最终)

在JDK7中不太可能使用一些类型推断和语法糖，以使withMapping调用不太冗长：