अल्पविरामों से जावा में एक सूची <String> में शामिल होने और "और"

Question

एक सूची

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

मैं एक विधि है यह देखते हुए

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

जो, एल के लिए, पैदा करता है "एक, दो, और तीन" । मेरा प्रश्न है, वहाँ एक विधि मानक (अपाचे-कॉमन्स) है कि एक ही ?, जैसे

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

स्पष्ट करने के लिए करता है। मेरी समस्या इस विधि को काम करने के लिए नहीं मिल रही है। यह वैसे ही काम करता है जैसा मैं चाहता हूं, यह परीक्षण किया गया है और सब ठीक है। मेरी समस्या यह है कि मुझे कुछ अपाचे-कॉमन्स-जैसे मॉड्यूल नहीं मिल सका जो ऐसी कार्यक्षमता लागू करता है। जो मुझे आश्चर्यचकित करता है, क्योंकि मैं इसकी आवश्यकता के लिए पहली नहीं हो सकता।

लेकिन तब शायद हर किसी बस

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

Answer 1

मैं इस उद्देश्य के लिए गूगल संग्रह का उपयोग कर की तरह काम किया है। स्वच्छ और बहुत उपयोगी:

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

कोड इस तरह बार-बार लिखा गया है और यदि आप अपने विशिष्ट कार्यान्वयन तर्क को लागू करने को मुक्त कर दिया जाना चाहिए।

आप Maven उपयोग करते हैं, निर्भरता इसके साथ:

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

यह अन्य अद्भुत शांत का एक समूह भी सुविधाओं है!

संपादित करें: पूर्णता के लिए, यह "एक, दो, और तीन" सूची का उत्पादन करेगा।

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

मैं किसी भी अपाचे स्ट्रिंग योजक कि शामिल हो गए स्ट्रिंग में and जोड़ने का समर्थन कर सकते हैं पता नहीं है।

यहाँ एक अपरीक्षित कोड है कि तुम क्या पूछा क्या करेंगे है:

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

क्या से join के बारे में: org.apache.commons.lang.StringUtils

उदाहरण:

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

करवाने के लिए "और" या ", और "आप अंतिम अल्पविराम को प्रतिस्थापित कर सकते हैं।

Answer 4

अन्य उत्तर "अंतिम अल्पविराम को बदलने" के बारे में बात करते हैं, जो कि अंतिम अवधि में अल्पविराम के मामले में सुरक्षित नहीं है।

एक पुस्तकालय का उपयोग करने के बजाय, आप बस 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); 
} 

इस कोड को सभी बढ़त मामलों से निपटने का live demo देखें।

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

जावा 8 के साथ, आप joiners साथ धाराओं का उपयोग कर सकते हैं:

---

FYI करें, यहाँ एक अधिक पठनीय दो लाइनर है।

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

जावा 8 में आप निम्नलिखित की तरह String.join() उपयोग कर सकते हैं:

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

Answer 7

अंग्रेजी में व्याकरण उत्पादन का उत्पादन करने के लिए 3 मामलों जब स्ट्रिंग की एक सूची श्रृंखलाबद्ध विचार करने के लिए देखते हैं:

1. "ए"

2. "ए और बी"

3. "ए, बी, और सी

यह नीचे की तरह मानक जावा या अमरूद का उपयोग कर पूरा किया जा सकता। समाधान मूल रूप से वही हैं और केवल वरीयता तक जो आप उपयोग करना चाहते हैं।

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

}