Преобразование массива int в массив String

Ответ 1

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

UPDATE:

Более короткая версия:

int[] nums = {-5,1,2,11,3};
Arrays.sort(nums);
String[] a=Arrays.toString(nums).split("[\\[\\]]")[1].split(", "); 
System.out.println(Arrays.toString(a));  

Ответ 2

Можно ли использовать цикл 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 - это глупо - вам нужно как-то перебирать список. Если вы собираетесь вызвать метод библиотеки, чтобы отсортировать его для вас (cf Collections.sort()) - это будет как-то зацикливаться на элементы.

Ответ 3

Используйте Stream, который доступен на Java 8. Чтобы получить экземпляр Stream с "списком" из ints:

• Для 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);

Ответ 4

Простое решение с использованием 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());

Ответ 5

Если вы используете 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]

EDIT:

ОК, вот другая версия, которая напрямую работает с массивом int. Но, к сожалению, это не однострочный. Однако он сохраняет дубликаты и, вероятно, быстрее

ИЗМЕНИТЬ еще раз:

Исправлены исправленные и отрицательные числа в соответствии с запросом:

РЕДАКТИРОВАТЬ еще раз: только один проход регулярных выражений и без обрезки

    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]

Обновление: удаленные пробелы из моих последних двух решений, надеюсь, что вы счастливы сейчас: -)

Ответ 6

Я бы предпочел пропустить другую для цикл.

Это глупо. Это глупое желание и глупая основа для осуществления упражнений с кодом. Если вы можете лучше выразить те качества, которые хотите, чтобы ваш код имел, то нам есть о чем поговорить - что это должно быть легко читать, скажем, или выполнять, или проверять, или надежно. Но "я бы скорее пропустил это", просто не дает нам ничего полезного для работы.

Ответ 7

Использование Функциональная Java,

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

Ответ 8

Как насчет чего-то вроде этого:

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

Ответ 9

Использование Коллекции Eclipse 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

Ответ 10

Вы можете использовать Collections.sort(), а затем перебирать список и собирать String.valueOf() каждый элемент.

http://download.oracle.com/javase/6/docs/api/java/util/Collections.html#sort%28java.util.List%29

Для вектора сначала вы получите список с 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

Ответ 11

Почему бы вам просто не передать эти значения в String в цикле оригинала for, создав массив String, а не массив int? Предполагая, что вы собираете начальное целое из начальной точки и добавляете к ней каждую итерацию цикла, следующая простая методика создания массива String, а не массива int. Если вам нужны как массивы int, так и String с одинаковыми значениями в них, создайте их как в цикле для цикла, так и с ним.

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

}

Я согласен со всеми остальными. Для циклов легко создавать, не требуют почти никаких накладных расходов для запуска, и их легко отслеживать при чтении кода. Элегантность в простоте!

Ответ 12

Arrays.sort(НУМС); var stringArray = (nums.toString()). split (','). map (String);