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

Question

Итак, у меня есть этот «список» целых. Это может быть Vector, int[], List<Integer>, что угодно.

Моя цель - отсортировать целые и получить String[]. Как массив int начинается как в воздухе.

например: Начать с: {5,1,2,11,3} Конец: String[] = {"1","2","3","5","11"}

Есть ли способ сделать это без цикла for? У меня есть цикл for для сбора ints. Я бы предпочел пропустить другой цикл for.

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

ОБНОВЛЕНИЕ:

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

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

Answer 2

Используйте Stream, который доступен из Java 8. Чтобы получить 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);

Answer 3

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

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

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

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

Answer 6

Использование Функциональная 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);

Answer 7

Я бы предпочел пропустить еще один цикл for.

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

Answer 8

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

Answer 9

Как насчет этого:

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

Answer 10

Мы можем решить эту проблему с помощью регулярного выражения следующим образом:

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