所以我有这个“清单”的整数。它可以是Vector，int[]，List<Integer>，无论如何。
我的目标是对整数进行排序，最后得到一个String[]。 int数组如何在空中开始。
例如：
从：{5,1,2,11,3}开始
结束于：String[] = {"1","2","3","5","11"}
无论如何没有for循环吗？我现在有一个for循环用于收集整数。我宁愿跳过另一个循环。
答案 0 :(得分：21)
int[] nums = {5,1,2,11,3}; //List or Vector
Arrays.sort(nums); //Collections.sort() for List,Vector
String a=Arrays.toString(nums); //toString the List or Vector
String ar[]=a.substring(1,a.length()-1).split(", ");
System.out.println(Arrays.toString(ar));
<强>更新
较短的版本：
int[] nums = {-5,1,2,11,3};
Arrays.sort(nums);
String[] a=Arrays.toString(nums).split("[\\[\\]]")[1].split(", ");
System.out.println(Arrays.toString(a));
答案 1 :(得分：11)
使用Java 8中提供的Stream。使用＆＃34; list＆＃34;获取Stream实例。整理：
int[]
IntStream intStream = Arrays.Stream(nums);或Stream<Integer> intStream = Arrays.Stream(nums).boxed();如果您需要与底层相同的课程。Collection<Integer>界面的任何类（例如Vector<Integer>，List<Integer>）
Stream<Integer> intStream = nums.stream(); 最后，获得String[]：
String[] answer = intStream.sorted().mapToObj(String::valueOf).toArray(String[]::new);
答案 2 :(得分：8)
我可以使用while循环吗？
@Test
public void test() {
int[] nums = {5,1,2,11,3};
Arrays.sort(nums);
String[] stringNums = new String[nums.length];
int i = 0;
while (i < nums.length) {
stringNums[i] = String.valueOf(nums[i++]);
}
Assert.assertArrayEquals(new String[]{"1","2","3","5","11"}, stringNums);
}
使用JUnit断言。
抱歉，我很轻浮。但是说你不能使用for循环是愚蠢的 - 你必须以某种方式在列表上迭代。如果您打算调用库方法为您排序（参见Collections.sort()） - 这将在元素上以某种方式循环 。
答案 3 :(得分：5)
使用Guava的简单解决方案：
public List<String> toSortedStrings(List<Integer> ints) {
Collections.sort(ints);
return Lists.newArrayList(Iterables.transform(ints,
Functions.toStringFunction()));
}
显然，这个解决方案（和其他任何解决方案一样）将在内部使用循环，但它会从你必须阅读的代码中获取它。您也可以通过将ints的结果传递给Ordering.natural().sortedCopy(ints)而不是先使用transform来避免更改Collections.sort中的顺序。此外，如果您不需要将新元素添加到结果列表中，则不需要Lists.newArrayList部分。
该方法体的缩短版本，带有静态导入：
return transform(Ordering.natural().sortedCopy(ints), toStringFunction());
答案 4 :(得分：4)
如果你使用TreeSet，我有一个（长）单行（假设items是TreeSet）：
final String[] arr =
items.toString() // string representation
.replaceAll("\\D+", " ") // replace all non digits with spaces
.trim() // trim ends
.split(" "); // split by spaces
测试代码：
Set<Integer> items = new TreeSet<Integer>(Arrays.asList(5, 1, 2, 11, 3));
// insert above code here
System.out.println(Arrays.toString(arr));
输出：
[1, 2, 3, 5, 11]
修改
好的，这是一个直接与int数组一起使用的不同版本。但不幸的是，这不是一个单行。但是，它确实保留了重复，而且可能更快
再次编辑：
根据要求支持Bug固定和负数：
再次编辑：只有一个正则表达式传递且没有修剪
final int[] in = { 5, 1, 2, 11, 3, 2, -5 }; // with duplicate
Arrays.sort(in);
final String[] out =
Arrays.toString(in)
.replaceAll("(?:\\[?)([-\\d]+)(?:\\]?)", "$1") // just remove [ and ]
.split("\\s*,\\s*"); // split by comma
System.out.println(Arrays.toString(out));
输出：
[-5, 1, 2, 2, 3, 5, 11]
或完全没有正则表达式（除了split（）），但又增加了一步：
final int[] in = { 5, 1, 2, 11, 3, 2, -5 }; // with duplicate
Arrays.sort(in);
final String stringRep = Arrays.toString(in);
final String[] out =
stringRep.substring(1, stringRep.length() - 1).split("\\s*,\\s*");
System.out.println(Arrays.toString(out));
输出：
[-5, 1, 2, 2, 3, 5, 11]
更新：从我的最后两个解决方案中剥离空白，希望你现在开心： - ）
答案 5 :(得分：3)
我宁愿跳过另一个 循环。
那太傻了。进行代码练习是一种愚蠢的愿望和愚蠢的基础。如果你能更好地表达你希望你的代码具有的品质，那么我们就有了一些可以讨论的东西 - 它应该易于阅读，比如说，性能，可测试性或健壮性。但“我宁愿跳过它”只是没有给我们任何有用的东西。
答案 6 :(得分：3)
import fj.data.List;
import static fj.data.List.*;
import static fj.pre.Show.*;
.
.
.
final List<Integer> xs = list(5,1,2,11,3);
final List<String> ys = xs.sort(Ord.intOrd).map(
new F<Integer, String>() {
@Override public String f(final Integer i) {
return String.valueOf(i);
}
}
);
listShow(stringShow).println(ys);
答案 7 :(得分：1)
这样的事情怎么样：
List<String> stringList = new ArrayList<String>();
List<Integer> list = new ArrayList<Integer>(Arrays.asList(5,1,2,11,3));
Collections.sort(list);
Iterator<Integer> iterator = list.iterator();
while(iterator.hasNext()) {
stringList.add(iterator.next().toString());
}
System.out.println(stringList);
答案 8 :(得分：1)
使用Eclipse Collections MutableIntList：
String[] result = IntLists.mutable.with(5, 1, 2, 11, 3)
.sortThis()
.collect(Integer::toString)
.toArray(new String[]{});
Assert.assertArrayEquals(
new String[]{"1", "2", "3", "5", "11"}, result);
或者为可能的效率交换一些可读性：
MutableIntList intList = IntLists.mutable.with(5, 1, 2, 11, 3).sortThis();
String[] result = intList.injectIntoWithIndex(
new String[intList.size()],
(r, each, index) -> {
r[index] = Integer.toString(each);
return r;
});
Assert.assertArrayEquals(
new String[]{"1", "2", "3", "5", "11"}, result);
注意：我是Eclipse Collections的提交者
答案 9 :(得分：0)
您可以使用Collections.sort()，然后遍历列表并收集String.valueOf()每个元素。
http://download.oracle.com/javase/6/docs/api/java/util/Collections.html#sort%28java.util.List%29
对于Vector，您首先会得到一个包含Collections.list(Enumeration e)的列表。
对于数组，您可以使用Arrays.sort()代替Collections.sort()。
http://download.oracle.com/javase/6/docs/api/java/util/Arrays.html#sort%28int%5b%5d%29
答案 10 :(得分：0)
为什么不简单地将这些值转换为原始for循环中的String，创建一个String数组而不是一个int数组？假设您从起始点收集初始整数并在每个for循环迭代中添加它，以下是创建String数组而不是int数组的简单方法。如果你需要int和String数组都有相同的值，那么在同一个for循环中创建它们并完成它。
yourInt = someNumber;
for (int a = 0; a < aLimit; a ++) {
String stringName = String.valueOf(yourInt);
StringArrayName[a] = stringName;
yourInt ++;
}
或者，如果您需要两者：
yourInt = someNumber;
for (int a = 0; a < aLimit; a ++) {
String stringName = String.valueOf(yourInt);
StringArrayName[a] = stringName;
intArrayName[a] = yourInt;
yourInt ++;
}
我同意其他人的意见。 For循环很容易构造，几乎不需要运行开销，并且在阅读代码时很容易理解。优雅简约！
答案 11 :(得分：0)
Java 8方式，根本没有循环：
// Given
int[] array = {-5, 8, 3, 10, 25};
// When
String[] actual = Arrays.stream(array)
.sorted()
.mapToObj(String::valueOf)
.toArray(String[]::new);
// Then
String[] expected = {"-5", "3", "8", "10", "25"};
assertArrayEquals(expected, actual);
答案 12 :(得分：0)
我们可以使用正则表达式来解决此问题，如下所示：
int[] intArray = {1, 2, 3, 4, 5, 6, 7, 8};
String str = new String(Arrays.toString(intArray));
String stripNoneDigits= str.replaceAll("[^\\d]", "");
String[] stringArray = stripNoneDigits.split("");
答案 13 :(得分：-2)
Arrays.sort（NUMS）; var stringArray =（nums.toString（））。split（'，'）。map（String）;