web-dev-qa-db-fra.com

Conversion d'un tableau int en un tableau String

J'ai donc cette "liste" d'ints. Il pourrait s'agir d'une Vector, int[], List<Integer>, peu importe. 

Mon objectif est cependant de trier les ints et d’obtenir un String[]. Comment la matrice int commence comme elle est en l'air.

ex: .__ Commencez par: {5,1,2,11,3}.__ Terminez par: String[] = {"1","2","3","5","11"}

Est-il possible de le faire sans une boucle for? J'ai une boucle pour maintenant pour collecter les ints. Je préférerais ne pas faire une autre boucle.

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

METTRE À JOUR:

Une version plus courte:

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

Puis-je utiliser une boucle while à la place?

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

Utilisation d'assertions JUnit.

Désolé, je suis désinvolte. Mais dire que vous ne pouvez pas utiliser une boucle for est idiot, vous devez iterate sur la liste d'une manière ou d'une autre. Si vous appelez une méthode de bibliothèque pour la trier à votre place (cf Collections.sort () ) - vous ferez une boucle sur de façon sur les éléments.

8
Noel M

Solution simple utilisant Goyave :

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

De toute évidence, cette solution (comme toute autre solution) utilisera des boucles en interne, mais elle l’extrait du code que vous devez lire. Vous pouvez également éviter de modifier l'ordre dans ints en passant le résultat de Ordering.natural().sortedCopy(ints) à transform au lieu d'utiliser Collections.sort en premier. De plus, la partie Lists.newArrayList n'est pas nécessaire si vous n'avez pas besoin d'ajouter de nouveaux éléments à la liste résultante.

La version abrégée de ce corps de méthode, avec les importations statiques:

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

Si vous utilisez un TreeSet, j’ai une (longue) ligne unique pour vous (en supposant que items est le TreeSet):

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

Code de test:

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

// insert above code here

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

Sortie:

[1, 2, 3, 5, 11]

MODIFIER:

OK, voici une version différente qui fonctionne directement avec le tableau int. Mais malheureusement, ce n'est pas un one-liner. Cependant, il garde les doublons et c'est probablement plus rapide

EDIT à nouveau:

Nombre de bogues fixes et négatifs pris en charge, comme demandé:

EDIT again : une seule passe regex et pas de 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));

Sortie:

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

Ou complètement sans regex (sauf split ()), mais avec une étape supplémentaire ajoutée:

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

Sortie:

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

Mise à jour: suppression des espaces de mes deux dernières solutions, j'espère que vous êtes heureux maintenant :-)

4
Sean Patrick Floyd

Utilisation de Java fonctionnel ,

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

Je préférerais ne pas en faire un autre pour boucle.

Cela est bête. C'est un désir stupide et une base stupide pour entreprendre un exercice de code. Si vous pouvez mieux exprimer les qualités que vous souhaitez attribuer à votre code, nous avons quelque chose à dire: il doit être facile à lire, à dire, ou performant, ou testable, ou robuste. Mais "je préférerais le sauter" ne nous donne simplement rien d’utile avec lequel travailler.

3
Carl Manaster

Que diriez-vous quelque chose comme ça:

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

Utilisation de Collections 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 échanger une certaine lisibilité pour une efficacité potentielle:

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

Remarque: je suis un partisan des collections Eclipse

1
Donald Raab

Java 8 way, pas de boucles du tout:

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

Vous pouvez utiliser Collections.sort(), puis parcourir la liste et collecter String.valueOf() chaque élément.

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

Pour un vecteur, vous obtiendrez d’abord une liste avec Collections.list(Enumeration e).

Pour un tableau, vous utiliseriez Arrays.sort() au lieu de Collections.sort().

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

0
gpeche

Pourquoi ne transposez-vous pas simplement ces valeurs en String dans la boucle for originale, en créant un tableau String plutôt qu'un tableau int? En supposant que vous collectiez votre entier initial à partir d'un point de départ et que vous le rajoutiez à chaque itération de boucle for, voici une méthodologie simple pour créer un tableau String plutôt qu'un tableau int. Si vous avez besoin des tableaux int et String contenant les mêmes valeurs, créez-les tous les deux dans la même boucle for et utilisez-les.

yourInt = someNumber;

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

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

}

Ou, si vous avez besoin des deux:

yourInt = someNumber;

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

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

}

Je suis d'accord avec tous les autres. Les boucles for sont faciles à construire, ne nécessitent presque pas de temps système et sont faciles à suivre lors de la lecture de code. L'élégance dans la simplicité!

0
elfinkind

Nous pouvons résoudre ce problème en utilisant une expression régulière comme suit:

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