3
votes

Java: Joining String from List dans l'ordre inverse

J'ai List list = Arrays.asList ("A", "B", "C");
Je veux joindre toutes les chaînes à l'intérieur de la liste avec le délimiteur , dans l'ordre inverse:

String joinedString = "";
List<String> list = Arrays.asList("A", "B", "C");
for (int i = list.size() - 1; i >= 0; i--) {
     String string = list.get(i);
     joinedString = joinedString + string + ",";
}
//to remove ',' from the last string
if(joinedString.length() > 0) {
    joinedString = joinedString.substring(0, joinedString.length() - 1);
}

//Output    
C,B,A

quelle est la meilleure approche pour y parvenir?
actuellement j'utilise la boucle d'index:

//result
String joinedString = "C,B,A";

java string reverse arraylist

3 commentaires

Si cela fonctionne, c'est généralement assez bon.

c'est ça? mais pourrais-je mieux y parvenir sans utiliser la boucle d'index?

Vous pourriez trouver Comment obtenir une vue de liste sur une liste en Java? utile si vous ne souhaitez pas modifier la liste d'origine.

7 Réponses :

2
votes

Le plus simple est d'utiliser Collections # reverse et String # join .

List<String> list = Arrays.asList("A", "B", "C");
Collections.reverse(list);
String joinedString = String.join(",", list);

3 commentaires

Heureusement, OP a utilisé Arrays.asList (...) et non List.of (...) , car cette solution ne fonctionnerait pas autrement.

Impossible de trouver List.of par Google. Vous avez un lien vers la documentation? @Andreas

Ajouté dans Java 9: List.of (E ...) --- Ou ce lien pour voir toutes les surcharges .

0
votes

Une autre façon, en utilisant Comparator.

List<String> list = Arrays.asList("A", "B", "C");
list.sort(Comparator.reverseOrder());
String joinedString = String.join(",", list);

2 commentaires

OP ne veut pas de valeur triée , juste l'inverse de l'ordre actuel. Le fait que l'exemple présenté ait des valeurs dans l'ordre croissant est arbitraire.

c'est une exagération. il suffit de l'inverser

5
votes

Si vous ne souhaitez pas modifier la liste en appelant Collections.reverse (List > list) dessus, parcourez la liste à l'envers.

Si vous ne savez pas le type de liste, utilisez un ListIterator code > pour parcourir la liste à rebours sans perte de performances, par exemple un normal i = 0; Une boucle sur une LinkedList fonctionnerait autrement mal.

Pour joindre les valeurs séparées par des virgules, utilisez un StringJoiner (Java 8 +). p >

List<String> list = Arrays.asList("A", "B", "C");

StringJoiner joiner = new StringJoiner(",");
for (ListIterator<String> iter = list.listIterator(list.size()); iter.hasPrevious(); )
    joiner.add(iter.previous());
String result = joiner.toString();

System.out.println(result); // print: C,B,A

3 commentaires

stackoverflow. com / questions / 322715 /…

la même IDEA utilisant des flux: String result = Stream.iterate (list.listIterator (list.size ()), it -> it) /*.takeWhile(ListIterator::hasPrevious) // java 9+ * /. limit (list.size ()) / * solution de contournement java 8 * / .map (ListIterator :: previous) .collect (Collectors.joining (","));

@AndreyLavrukhin C'est une logique de flux extrêmement mauvaise, car vous violez le contrat de map () lorsque vous appelez previous () , car ce n'est pas un fonction sans état . Pour le faire correctement, consultez Comment convertir un itérateur en flux?

1
votes

Utilisation d'un fournisseur

reverse = list.stream().map(l->supplier.get()).collect(Collectors.joining(","));

0 commentaires

0
votes

Une méthode utilise StringBuilder

    StringBuilder sb = new StringBuilder();
    List<String> strs = Arrays.asList("A", "b", "c","d");
    for (int i = 0; i < strs.size(); i++) {
        sb.append(strs.get(i));
        if (i != strs.size() - 1) {
            sb.append(",");
        }
    }
    System.out.println(sb.reverse().toString());

0 commentaires

1
votes

Voici une solution utilisant Java 8:

Collections.reverse(list);

//res contains the desired string
String res = list.stream().collect(Collectors.joining(","));

0 commentaires

1
votes

Il peut être utile de se joindre comme collecteur:

    List<String> list = Arrays.asList("A", "B", "C");
    String result = list.stream()
                .collect(joiningReversed(",", "", ""));
    System.out.println(result);

et l'utiliser dans les flux:

    public static Collector<CharSequence, ?, String> joiningReversed(CharSequence delimiter, CharSequence prefix, CharSequence suffix) {
    return Collector.of(StringBuilder::new,
            (sb, item) -> {
                if (sb.length() != 0) {
                    sb.insert(0, delimiter);
                }
                sb.insert(0, item);
            },
            (a, b) -> {
                throw new UnsupportedOperationException();
            },
            sb -> sb.insert(0, prefix).append(suffix).toString());
    }

1 commentaires

Remarque: cela fonctionne pour n'importe quel flux séquentiel, même de longueur indéterminée.