Conversión de una matriz int a una matriz String

Entonces tengo esta “lista” de Ints. Podría ser un Vector , int[] , List , lo que sea.

Mi objective, sin embargo, es ordenar las entradas y terminar con una String[] . Cómo comienza la matriz int como está en el air.

Ej .: Comience con: {5,1,2,11,3} Finalice con: String[] = {"1","2","3","5","11"}

¿Hay alguna forma de hacerlo sin un bucle for? Tengo un bucle for ahora para recostackr los enteros. Preferiría omitir hacer otro ciclo for.

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

ACTUALIZAR:

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

Use un Stream que esté disponible desde Java 8. Para obtener una instancia de Stream con “lista” de ints:

  • Para int[]
    • IntStream intStream = Arrays.Stream(nums); o
    • Stream intStream = Arrays.Stream(nums).boxed(); si necesita la misma clase que la inferior.
  • Para cualquier clase con la interfaz Collection (por ejemplo, Vector , List )
    • Stream intStream = nums.stream();

Finalmente, para obtener un String[] :

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

¿Puedo usar un ciclo 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 las aserciones JUnit.

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

Solución simple usando guayaba :

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

Obviamente, esta solución (como cualquier otra) va a usar bucles internamente, pero la saca del código que tiene que leer. También puede evitar cambiar el orden en ints pasando el resultado de Ordering.natural().sortedCopy(ints) para transform lugar de usar Collections.sort primero. 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 de método, con importaciones estáticas:

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

Si usa un TreeSet, tengo un (un poco largo) un-liner para usted (asumiendo que los items son los 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 prueba:

 Set items = new TreeSet(Arrays.asList(5, 1, 2, 11, 3)); // insert above code here System.out.println(Arrays.toString(arr)); 

Salida:

 [1, 2, 3, 5, 11] 

EDITAR:

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

EDITAR de nuevo:

Se corrigieron los números fijos y negativos admitidos, según lo solicitado:

EDITAR una vez más : solo un pase de expresiones regulares y sin recorte

  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 expresiones regulares (aparte de split ()), pero con un paso más agregado:

 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: espacios en blanco eliminados de mis dos últimas soluciones, espero que estés contento ahora 🙂

Preferiría omitir hacer otro ciclo for.

Eso es tonto. Es un deseo tonto y una base tonta para emprender un ejercicio de código. Si puede express 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.

Usando Java funcional ,

 import fj.data.List; import static fj.data.List.*; import static fj.pre.Show.*; . . . final List xs = list(5,1,2,11,3); final List ys = xs.sort(Ord.intOrd).map( new F() { @Override public String f(final Integer i) { return String.valueOf(i); } } ); listShow(stringShow).println(ys); 

Qué tal algo como esto:

 List stringList = new ArrayList(); List list = new ArrayList(Arrays.asList(5,1,2,11,3)); Collections.sort(list); Iterator iterator = list.iterator(); while(iterator.hasNext()) { stringList.add(iterator.next().toString()); } System.out.println(stringList); 

Usando las colecciones de 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); 

O intercambiando alguna legibilidad por 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 committer para las colecciones de Eclipse

Puede usar Collections.sort() y luego iterar sobre la lista y recostackr 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 obtendría una Lista con Collections.list(Enumeration e) .

Para una matriz, usaría Arrays.sort() lugar de Collections.sort() .

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

¿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 bien, si necesita ambos:

 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!

Java 8 vías, sin bucles en absoluto:

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

Podemos resolver este problema usando la expresión regular de la siguiente manera:

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

Arrays.sort (nums); var stringArray = (nums.toString ()). split (‘,’). map (String);