parse - set to array java

Convertir una matriz int en una matriz String

Question

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

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

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

¿Hay alguna forma de hacer esto sin un bucle for? Tengo un bucle for ahora para recoger los ints. Preferiría saltarme otro bucle for.

Answer 1

Preferiría saltarme otro bucle for.

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, interpretativo, comprobable o sólido. Pero "Prefiero evitarlo" simplemente no nos da nada útil para trabajar.

Answer 2

¿Por qué no simplemente convierte esos valores a Cadena dentro del original para el bucle, creando una matriz de Cadenas en lugar de una matriz int? Suponiendo que está reuniendo su entero inicial desde un punto de partida y agregándolo a cada iteración de bucle, la siguiente es una metodología simple para crear una matriz de cadenas en lugar de una matriz int. Si necesita arrays int y String con los mismos valores en ellos, créelos en el mismo bucle y termine con ellos.

yourInt = someNumber;

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

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

}

O, si necesitas 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. Para los bucles son fáciles de construir, no requieren casi gastos generales para ejecutarse, y son fáciles de seguir cuando se lee el código. ¡Elegancia en la sencillez!

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 aserciones de JUnit.

Lo siento, estoy siendo frívolo. Pero decir que no se puede usar un bucle for es una tontería, hay que recorrer la lista de alguna manera. Si va a llamar a un método de biblioteca para clasificarlo por usted (cf Collections.sort() ), será un bucle de alguna manera sobre los elementos.

Answer 4

Arrays.sort (números); var stringArray = (nums.toString ()). split ('',''). map (String);

Answer 5

Java 8 forma, 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);

Answer 6

Podemos resolver este problema usando expresiones regulares 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("");

Answer 7

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

Answer 8

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 9

Si utiliza un TreeSet, tengo una línea larga (bastante larga) para usted (asumiendo que los items son el 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<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]

EDITAR:

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

EDITAR de nuevo:

Números fijos y negativos de errores soportados, 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: elimine los espacios en blanco de mis dos últimas soluciones, espero que esté contento ahora :-)

Answer 10

Solución simple utilizando 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 otra) va a utilizar los bucles internamente, pero los elimina 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());

Answer 11

Usando Eclipse Collections 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 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 comendador de Eclipse Collections.

Answer 12

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

• Para int[]
  • IntStream intStream = Arrays.Stream(nums); o
  • Stream<Integer> intStream = Arrays.Stream(nums).boxed(); Si necesitas la misma clase que la de abajo.
• Para cualquier clase con interfaz Collection<Integer> (por ejemplo, Vector<Integer> , List<Integer> )
  • Stream<Integer> intStream = nums.stream();

Finalmente, para obtener una String[] :

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

Answer 13

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

Answer 14

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