Convertir una matriz int a una matriz de cadenas

Question

Tengo esta "lista" de entradas. Podría ser un Vector, int[], List<Integer>, lo que sea.

Mi objetivo, sin embargo, es ordenar los datos y terminar con un String[]. Cómo comienza la matriz int como está en el aire.

ejemplo: Inicio con: {5,1,2,11,3} final con: String[] = {"1","2","3","5","11"}

¿Hay alguna forma de hacer esto sin un bucle? Tengo un bucle for ahora para recopilar los enteros. Preferiría omitir hacer otro ciclo 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)); 

UPDATE:

Una versión más corta:

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

Puede usar Collections.sort() y luego iterar sobre la lista y recopilar String.valueOf() cada elemento.

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

para un vector, primero una lista con Collections.list(Enumeration e).

Para una matriz, debe utilizar Arrays.sort() en lugar de Collections.sort().

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

Answer 3

¿Puedo usar un bucle while en su lugar?

@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 JUnit assertions.

Lo siento, estoy siendo impertinente. Pero decir que no se puede usar un bucle for es tonto: tienes que iterar en la lista de alguna manera. Si va a llamar a un método de la biblioteca para ordenarlo por usted (cf Collections.sort()), eso hará que se repita de alguna manera sobre los elementos.

Answer 4

¿Qué tal algo como esto:

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 5

Si utiliza un TreeSet, tengo un (alargada) de una sola línea para usted (suponiendo items es el TreeSet):

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

prueba código:

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

// insert above code here 

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

salida:

[1, 2, 3, 5, 11] 

---

EDIT:

OK, aquí es una versión diferente que funciona con la matriz int directamente. Pero lamentablemente no es de una sola línea.Sin embargo, lo hace mantener duplicados y es probable que sea más rápido

nuevo EDIT:

Bug fijo y los números negativos apoyado, conforme a lo solicitado:

EDITAR vez más: sólo un pase de expresiones regulares y ningún ajuste

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

salida:

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

o completamente sin expresión regular (aparte de split()), pero con un paso más añadido:

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

Salida:

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

Actualización: despojado espacios en blanco de mis dos últimas soluciones , espero que estés feliz ahora :-)

Answer 6

Prefiero omitir hacer otra para loop.

Eso es tonto. Es un deseo tonto y una base tonta para emprender un ejercicio de código. Si puede expresar mejor las cualidades que desea que tenga su código, entonces tenemos algo de lo que hablar, que debería ser fácil de leer, decir, o realizar, o probar, o robusto. Pero "prefiero omitirlo" simplemente no nos da nada útil para trabajar.

Answer 7

solución simple usando Guava:

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

Obviamente, esta solución (como cualquier otro) va a utilizar bucles internos, pero se pone fuera del código que tiene que leer. También puede evitar cambiar el orden en ints pasando primero el resultado de Ordering.natural().sortedCopy(ints) a transform en lugar de usar Collections.sort. Además, la parte Lists.newArrayList no es necesaria si no necesita poder agregar nuevos elementos a la lista resultante.

La versión abreviada de ese cuerpo método, con las importaciones estáticas:

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

Answer 8

Uso de Functional 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 9

¿Por qué no simplemente transfiere esos valores a String dentro del bucle for original, creando una matriz String en lugar de una matriz int? Suponiendo que está reuniendo su número entero inicial desde un punto inicial y añadiéndole cada iteración de bucle, la siguiente es una metodología simple para crear una matriz String en lugar de una matriz int.Si necesita ambas matrices int y String con los mismos valores, créelas en el mismo ciclo for y termine con ellas.

yourInt = someNumber; 

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

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

} 

O, si necesita tanto:

yourInt = someNumber; 

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

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

} 

Estoy de acuerdo con todos los demás. Los bucles son fáciles de construir, no requieren casi ninguna sobrecarga y son fáciles de seguir cuando se lee el código. Elegancia en la simplicidad!

Answer 10

Arrays.sort (nums); var stringArray = (nums.toString()). Split (','). Map (String);

Answer 11

Utilice un Stream que está disponible en Java 8. Para obtener una instancia Stream con "lista" de enteros:

• Para int[]
  • IntStream intStream = Arrays.Stream(nums); o
  • Stream<Integer> intStream = Arrays.Stream(nums).boxed(); si necesita la misma clase como la inferior.
• para cualquier clase de interfaz con Collection<Integer> (ex Vector<Integer>, List<Integer>.)
  • Stream<Integer> intStream = nums.stream();

Por último, para obtener un String[]:

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

Answer 12

Uso Eclipse CollectionsMutableIntList:

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

o el comercio de algunos legibilidad de la eficiencia 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: Soy un confirmador de Eclipse Colecciones