ti-enxame.com

Convertendo um array int em um array String

Então eu tenho essa "lista" de ints. Pode ser um Vector, int[], List<Integer>, o que for. 

Meu objetivo, porém, é classificar os ints e acabar com um String[]. Como o array int começa como está no ar.

ex: Comece com: {5,1,2,11,3} Termine com: String[] = {"1","2","3","5","11"}

Existe alguma maneira de fazer isso sem um loop for? Eu tenho um loop for agora para coletar os ints. Eu preferiria pular outro loop.

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

ATUALIZAÇÃO:

Uma versão mais curta:

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

Use um Stream que está disponível no Java 8. Para obter uma instância Stream com "list" de ints:

  • Para int[]
    • IntStream intStream = Arrays.Stream(nums); ou
    • Stream<Integer> intStream = Arrays.Stream(nums).boxed(); se você precisar da mesma classe que a inferior.
  • Para qualquer turma com interface Collection<Integer> (ex. Vector<Integer>, List<Integer>)
    • Stream<Integer> intStream = nums.stream();

Finalmente, para obter um String[]:

String[] answer = intStream.sorted().mapToObj(String::valueOf).toArray(String[]::new);
10
Skywave

Posso usar um loop while em vez disso?

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

Usando asserções JUnit.

Desculpe, estou sendo irreverente. Mas dizer que você não pode usar um loop for é daft - você precisa iterate over the list de alguma forma. Se você vai chamar um método de biblioteca para classificá-lo para você (cf Collections.sort () ) - que será em loop de alguma forma sobre os elementos.

8
Noel M

Solução simples usando Goiaba :

public List<String> toSortedStrings(List<Integer> ints) {
  Collections.sort(ints);
  return Lists.newArrayList(Iterables.transform(ints, 
      Functions.toStringFunction()));
}

Obviamente, esta solução (como qualquer outra) vai usar loops internamente, mas ela sai do código que você precisa ler. Você também pode evitar alterar a ordem em ints passando o resultado de Ordering.natural().sortedCopy(ints) para transform em vez de usar Collections.sort primeiro. Além disso, a parte Lists.newArrayList não é necessária se você não precisar adicionar novos elementos à lista resultante.

A versão abreviada desse corpo de método, com importações estáticas:

return transform(Ordering.natural().sortedCopy(ints), toStringFunction());
5
ColinD

Se você usa um TreeSet, eu tenho uma (linha) longa para você (assumindo que items é o TreeSet):

final String[] arr =
    items.toString() // string representation
        .replaceAll("\\D+", " ") // replace all non digits with spaces
        .trim() // trim ends
        .split(" "); // split by spaces

Código de teste:

Set<Integer> items = new TreeSet<Integer>(Arrays.asList(5, 1, 2, 11, 3));

// insert above code here

System.out.println(Arrays.toString(arr));

Saída:

[1, 2, 3, 5, 11]

EDITAR:

OK, aqui está uma versão diferente que trabalha diretamente com o array int. Mas infelizmente não é um one-liner. No entanto, ele mantém duplicatas e provavelmente é mais rápido

EDITAR novamente:

Números fixos e negativos de bugs suportados, conforme solicitado:

EDITAR mais uma vez : apenas uma passagem de regex e sem trim

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

Saída:

[-5, 1, 2, 2, 3, 5, 11]

Ou completamente sem regex (além de split ()), mas com mais um passo adicionado:

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

Saída:

[-5, 1, 2, 2, 3, 5, 11]

Atualização: espaço em branco despojado das minhas duas últimas soluções, espero que você esteja feliz agora :-)

4
Sean Patrick Floyd

Usando Java funcional ,

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

Eu prefiro deixar de fazer outro para Loop.

Isso é bobo. É um desejo tolo e uma base tola para empreender um exercício de código. Se você puder expressar melhor as qualidades que deseja que seu código tenha, então temos algo sobre o que falar - que deve ser fácil de ler, dizer, ou ter bom desempenho, ou testável, ou robusto. Mas "eu prefiro ignorá-lo" simplesmente não nos dá nada útil para trabalhar.

3
Carl Manaster

Que tal algo como isso:

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

Usando Coleções do EclipseMutableIntList :

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

Ou negociando alguma legibilidade para eficiência potencial:

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

Nota: Eu sou um committer para coleções do Eclipse

1
Donald Raab

Java 8 maneira, sem loops de todo:

 // 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);
0
Maxim Pavlov

Você pode usar Collections.sort() e depois iterar sobre a lista e coletarString.valueOf() cada elemento.

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

Para um Vector, você primeiro obteria uma lista com Collections.list(Enumeration e).

Para um array, você usaria Arrays.sort() em vez de Collections.sort().

http://download.Oracle.com/javase/6/docs/api/Java/util/Arrays.html#sort%28int%5b%5d%29

0
gpeche

Por que você simplesmente não converte esses valores em String dentro do loop for original, criando uma matriz String em vez de uma matriz int? Supondo que você esteja reunindo seu inteiro inicial a partir de um ponto de partida e adicionando a ele em cada iteração de loop, a seguinte é uma metodologia simples para criar uma matriz de String em vez de uma matriz int. Se você precisar dos arrays int e String com os mesmos valores neles, crie ambos no mesmo loop e conclua com ele.

yourInt = someNumber;

for (int a = 0; a < aLimit; a ++) {

String stringName = String.valueOf(yourInt);
StringArrayName[a] = stringName;
yourInt ++;

}

Ou, se você precisar de ambos:

yourInt = someNumber;

for (int a = 0; a < aLimit; a ++) {

String stringName = String.valueOf(yourInt);
StringArrayName[a] = stringName;
intArrayName[a] = yourInt;
yourInt ++;

}

Eu concordo com todos os outros. For loops são fáceis de construir, não requerem quase nenhuma sobrecarga para serem executados e são fáceis de seguir ao ler o código. Elegância na simplicidade!

0
elfinkind

Podemos resolver esse problema usando a expressão regular da seguinte maneira:

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