Iscrizione a un elenco <String> in Java con virgole e "e"

Question

Dato un elenco

List<String> l = new ArrayList<String>(); 
l.add("one"); 
l.add("two"); 
l.add("three"); 

Ho un metodo

String join(List<String> messages) { 
     if (messages.isEmpty()) return ""; 
     if (messages.size() == 1) return messages.get(0); 
     String message = ""; 
     message = StringUtils.join(messages.subList(0, messages.size() -2), ", "); 
     message = message + (messages.size() > 2 ? ", " : "") + StringUtils.join(messages.subList(messages.size() -2, messages.size()), ", and "); 
     return message; 
    } 

che, per l, produce "uno, due e tre" . La mia domanda è: esiste un metodo standard (apache-commons), che fa la stessa cosa ?, per esempio

WhatEverUtils.join(l, ", ", ", and "); 

Per chiarire. Il mio problema non è quello di far funzionare questo metodo. Funziona esattamente come lo voglio io, è testato e va tutto bene. Il mio problema è che non sono riuscito a trovare alcun modulo apache-commons-like che implementa tale funzionalità. Il che mi sorprende, dal momento che non posso essere il primo a aver bisogno di questo.

Ma allora forse tutti gli altri hanno appena fatto

StringUtils.join(l, ", ").replaceAll(lastCommaRegex, ", and"); 

Answer 1

Mi piace usare le collezioni di Google per questo scopo. Neat e molto utile:

Joiner.on(",").join(myList) 

Questo tipo di codice è stato scritto più volte e si dovrebbe piuttosto essere liberati attuare la logica specifica implementazione.

Se si utilizza Maven, con la presente la dipendenza:

<dependency> 
    <groupId>com.google.collections</groupId> 
    <artifactId>google-collections</artifactId> 
    <version>1.0</version> 
</dependency> 

E 'un sacco di altre caratteristiche fredde meravigliosa troppo!

MODIFICA: Per motivi di completezza, questo produrrà la lista "uno, due e tre".

List<String> originalList = Arrays.asList("one", "two", "three"); 
Joiner.on(", ").join(originalList.subList(0, originalList.size() - 1)) 
    .concat(", and ").concat(originalList.get(originalList.size() - 1)); 

Answer 2

Io non conosco nessun falegname Apache String in grado di supportare l'aggiunta and nella stringa unito.

Ecco un codice non testato che farà quello che hai chiesto:

public static String join(String separator, List<String> mList, boolean includeAndInText) { 
    StringBuilder sb = new StringBuilder(); 
    int count = 0; 

    for (String m: mList) { 
     if (includeAndInText && (count + 1 != mList.size())) { 
      sb.append (" and "); 
     } 

     sb.append(m); 
     count++; 
     if (count < mList.size()) { 
      sp.append(separator); 
     }  
    } 

    return sb.toString(); 
} 

Answer 3

Che dire join da: org.apache.commons.lang.StringUtils

Esempio:

StringUtils.join(new String[] { "one", "two", "three" }, ", "); // one, two, three 

di avere "e" o", e "puoi semplicemente sostituire l'ultima virgola.

Answer 4

Altre risposte parlano di "sostituzione dell'ultima virgola", che non è sicuro se l'ultimo termine contiene una virgola.

Invece di usare una libreria, si può semplicemente utilizzare una (seppur lunga) riga di codice JDK:

public static String join(List<String> msgs) { 
    return msgs == null || msgs.size() == 0 ? "" : msgs.size() == 1 ? msgs.get(0) : msgs.subList(0, msgs.size() - 1).toString().replaceAll("^.|.$", "") + " and " + msgs.get(msgs.size() - 1); 
} 

Consulta l'live demo di questa gestione di tutti i casi limite di codice.

---

Cordiali saluti, ecco una più leggibile due-liner:

public static String join(List<String> msgs) { 
    int size = msgs == null ? 0 : msgs.size(); 
    return size == 0 ? "" : size == 1 ? msgs.get(0) : msgs.subList(0, --size).toString().replaceAll("^.|.$", "") + " and " + msgs.get(size); 
} 

Answer 5

con Java 8, è possibile utilizzare i flussi con falegnami.

Collection<String> strings; 
... 
String commaDelimited = strings.stream().collect(Collectors.joining(",")); 
// use strings.parallelStream() instead, if you think 
// there are gains to be had by doing fork/join 

Answer 6

In Java 8 è possibile utilizzare String.join() come segue:

Collection<String> elements = ....; 
String result = String.join(", ", elements); 

Answer 7

per produrre un output grammaticale in inglese ci sono 3 casi da considerare quando si concatenare un elenco di stringhe:

1. "A"

2. "A e B"

3. "A, B, e C.

Ciò può essere realizzato utilizzando standard di Java o Guava come qui di seguito. Le soluzioni sono fondamentalmente le stesse e preferiscono solo ciò che si desidera utilizzare.

import com.google.common.base.Joiner; 
import com.google.common.collect.ImmutableList; 

import org.junit.Test; 

import java.util.List; 

import static org.junit.Assert.assertEquals; 

public class JoinListTest { 

    @Test 
    public void test_join() { 
     // create cases (don't need to use ImmutableList builder from guava) 
     final List<String> case1 = new ImmutableList.Builder<String>().add("A").build(); 
     final List<String> case2 = new ImmutableList.Builder<String>().add("A", "B").build(); 
     final List<String> case3 = new ImmutableList.Builder<String>().add("A", "B", "C").build(); 
     // test with standard java 
     assertEquals("A", joinListGrammaticallyWithJava(case1)); 
     assertEquals("A and B", joinListGrammaticallyWithJava(case2)); 
     assertEquals("A, B, and C", joinListGrammaticallyWithJava(case3)); 
     // test with guava 
     assertEquals("A", joinListGrammaticallyWithGuava(case1)); 
     assertEquals("A and B", joinListGrammaticallyWithGuava(case2)); 
     assertEquals("A, B, and C", joinListGrammaticallyWithGuava(case3)); 
    } 

    private String joinListGrammaticallyWithJava(final List<String> list) { 
     return list.size() > 1 
       ? String.join(", ", list.subList(0, list.size() - 1)) 
        .concat(String.format("%s and ", list.size() > 2 ? "," : "")) 
        .concat(list.get(list.size() - 1)) 
       : list.get(0); 
    } 

    private String joinListGrammaticallyWithGuava(final List<String> list) { 
     return list.size() > 1 
       ? Joiner.on(", ").join(list.subList(0, list.size() - 1)) 
        .concat(String.format("%s and ", list.size() > 2 ? "," : "")) 
        .concat(list.get(list.size() - 1)) 
       : list.get(0); 
    } 

}