是否有一个现有的Java实用程序方法可以联接“0”上的字符串列表&引用；及；“和”；？

我正在寻找一些东西来增强apache commons join（）函数的功能，基本上这将实现makePrettyList（）的功能

公共字符串makePrettyList（列表项）{
String list=org.apache.commons.lang.StringUtils.join（items，“，”）；
int finalComma=list.lastIndexOf（“，”）；
返回list.substring（0，finalComma）+”和“+list.substring（finalComma+1，list.length（））；
}

---

makePrettyList（[“Alpha”、“Beta”、“Omega”]）-->“Alpha、Beta和Omega”

如果您不打算使用第三方库，则需要编写自己的实用程序

public List<String> makePrettyList(List<String> items) {
    StringBuilder builder = new StringBuilder();

    for (int i = 0; i < items.size(); i++) { 
        if (i > 0) {
            builder.append(" ");

            if (i == items.size() - 1) {
                builder.append("and ");
            }
            else {
                builder.append(", ");
            }
        }

        builder.append(items.get(i));
    }

    return builder.toString();
}

公共列表makePrettyList（列表项）{
StringBuilder=新的StringBuilder（）；
对于（inti=0；i0）{
生成器。追加（“”）；
if（i==items.size（）-1）{
建造商。附加（“和”）；
}
否则{
生成器。追加（“，”）；
}
}
builder.append（items.get（i））；
}
返回builder.toString（）；
}

[没有优雅地处理尾随和前导的空值/清空。现在效果更好。]

我的观点是，使用Google Guava（不是官方的Java，而是一套非常好的软件包）。我之所以提供它，是因为您似乎考虑过使用Joiner，但后来拒绝了它。既然您曾经开放使用Joiner，也许您想再看一次：

package testCode;

import java.util.List;

import com.google.common.base.Joiner;
import com.google.common.base.Predicate;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;

public class TestClass {

    Joiner joinComma = Joiner.on(", ");
    Joiner joinAndForTwo = Joiner.on(" and ");
    Joiner joinAndForMoreThanTwo = Joiner.on(", and ");

    public String joinWithAnd(List<String> elements) {
        ImmutableList<String> elementsNoNullsOrEmpties = new ImmutableList.Builder<String>()
                .addAll(Iterables.filter(elements, new Predicate<String>() {
                    @Override
                    public boolean apply(String arg0) {
                        return !Strings.isNullOrEmpty(arg0);
                    }
                })).build();

        if (elementsNoNullsOrEmpties.size() == 0) {
            return null;
        } else if (elementsNoNullsOrEmpties.size() == 1) {
            return Iterables.getOnlyElement(elementsNoNullsOrEmpties);
        } else if (elementsNoNullsOrEmpties.size() == 2) {
            return joinAndForTwo.join(elementsNoNullsOrEmpties);
        } else {
            final List<String> leadingElements = elementsNoNullsOrEmpties
                    .subList(0, elementsNoNullsOrEmpties.size() - 1);
            final String trailingElement = elementsNoNullsOrEmpties
                    .get(elementsNoNullsOrEmpties.size() - 1);
            return joinAndForMoreThanTwo.join(joinComma.join(leadingElements),
                    trailingElement);
        }
    }
}

包测试代码；
导入java.util.List；
导入com.google.common.base.Joiner；
导入com.google.common.base.Predicate；
导入com.google.common.base.Strings；
导入com.google.common.collect.ImmutableList；
导入com.google.common.collect.Iterables；
公共类TestClass{
Joiner Joine逗号=Joiner.on（“，”）；
Joiner Joiner和Fortwo=Joiner.on（“和”）；
Joiner Joiner and Formorethan=Joiner.on（“，and”）；
公共字符串joinWithAnd（列表元素）{
ImmutableList ElementsNonullsorPenttles=新建ImmutableList.Builder（）
.addAll（Iterables.filter（元素，新谓词（）{
@凌驾
公共布尔应用（字符串arg0）{
return！Strings.isNullOrEmpty（arg0）；
}
})).build（）；
if（elementsNonullsorEmptings.size（）==0）{
返回null；
}else if（elementsnonNullsor清空.size（）==1）{
返回Iterables.getOnlyElement（elementsNoNull或清空）；
}else if（elementsnonNullsorEmptings.size（）==2）{
return join和fortwo.join（elementsnonNull或清空）；
}否则{
最终列表leadingElements=ElementsNoNull或清空
.subList（0，elementsnowullsor清空.size（）-1）；
最终字符串trailingElement=ElementsNonullsorEmpts
.get（elementsnonNullsor清空.size（）-1）；
返回join和formorethan.join（joinComma.join（leadingElements），
拖带；
}
}
}

和测试驾驶员：

package testCode;

import java.util.List;

import com.google.common.collect.Lists;

public class TestMain {

    static List<String> test1 = Lists.newArrayList();
    static List<String> test2 = Lists.newArrayList("");
    static List<String> test3 = Lists.newArrayList("a");
    static List<String> test4 = Lists.newArrayList("a", "b");
    static List<String> test5 = Lists.newArrayList("a", "b", "c", "d");
    static List<String> test6 = Lists.newArrayList("a", "b", "c", null, "d");
    static List<String> test7 = Lists.newArrayList("a", "b", "c", null);
    static List<String> test8 = Lists.newArrayList("a", "b", "", "", null, "c",
            null);
    static List<String> test9 = Lists.newArrayList("", "a", "b", "c", null);
    static List<String> test10 = Lists.newArrayList(null, "a", "b", "c", null);

    public static void main(String[] args) {
        TestClass testClass = new TestClass();

        System.out.println(testClass.joinWithAnd(test1));
        System.out.println(testClass.joinWithAnd(test2));
        System.out.println(testClass.joinWithAnd(test3));
        System.out.println(testClass.joinWithAnd(test4));
        System.out.println(testClass.joinWithAnd(test5));
        System.out.println(testClass.joinWithAnd(test6));
        System.out.println(testClass.joinWithAnd(test7));
        System.out.println(testClass.joinWithAnd(test8));
        System.out.println(testClass.joinWithAnd(test9));
        System.out.println(testClass.joinWithAnd(test10));
    }
}

包测试代码；
导入java.util.List；
导入com.google.common.collect.list；
公共类TestMain{
静态列表test1=Lists.newArrayList（）；
静态列表test2=Lists.newArrayList（“”）；
静态列表test3=Lists.newArrayList（“a”）；
静态列表test4=Lists.newArrayList（“a”、“b”）；
静态列表test5=Lists.newArrayList（“a”、“b”、“c”、“d”）；
静态列表test6=Lists.newArrayList（“a”、“b”、“c”、null、“d”）；
静态列表test7=Lists.newArrayList（“a”、“b”、“c”、null）；
静态列表test8=Lists.newArrayList（“a”、“b”、“u”、“null”、“c”，
无效）；
静态列表test9=Lists.newArrayList（“，”a“，”b“，”c“，”null）；
静态列表test10=Lists.newArrayList（null，“a”，“b”，“c”，null）；
公共静态void main（字符串[]args）{
TestClass TestClass=新的TestClass（）；
System.out.println（testClass.joinWithAnd（test1））；
System.out.println（testClass.joinWithAnd（test2））；
System.out.println（testClass.joinWithAnd（test3））；
System.out.println（testClass.joinWithAnd（test4））；
System.out.println（testClass.joinWithAnd（test5））；
System.out.println（testClass.joinWithAnd（test6））；
System.out.println（testClass.joinWithAnd（test7））；
System.out.println（testClass.joinWithAnd（test8））；
System.out.println（testClass.joinWithAnd（test9））；
System.out.println（testClass.joinWithAnd（test10））；
}
}

以及输出：

空
空
a
a和b
a、 b、c和d
a、 b、c和d
a、 b和c
a、 b和c
a、 b和c
a、 b和c

我喜欢这个，因为它不做任何字符串拼接。它对所提供的字符串列表进行分区，然后使用基于字符串元素数量的规则将它们正确地粘在一起，而无需返回并在事实之后反写“and”。我还处理出现在字符串列表开头、结尾或中间的空/空的各种边缘情况。可能是保证不会发生这种情况，因此可以简化此解决方案

---

[我的与你的有点不同，当我有两个元素时，我不会在第一个元素后和“and”之前加逗号，而对于三个或更多的元素，在“and”之前加逗号。这是一种风格。很容易调整到你喜欢的逗号应该如何工作。]这里有一个很好的方法，可以在需要的地方装饰/自定义

列表的实例

import java.util.*;

public class ListUtils
{
    public static void main(final String[] args)
    {
        final List<String> sl = new ArrayList<String>()
        {
            public String toString()
            {
                final StringBuilder sb = new StringBuilder(this.size() * 512);
                final ListIterator<String> li = this.listIterator();
                while (li.hasNext())
                {
                    if (li.nextIndex() == this.size() - 1)
                    {
                        sb.append("and ").append(li.next());
                    }
                    else if (li.nextIndex() == this.size() - 2)
                    {
                        sb.append(li.next()).append(" ");
                    }
                    else
                    {
                        sb.append(li.next()).append(", ");
                    }
                }
                return sb.toString();
            }
        };

        // Test the output  
        sl.add("Alpha");
        sl.add("Beta");
        sl.add("Omega");
        System.out.println(sl.toString());
    }
}

您可以将这种构造的创建放在
公共静态
工厂方法中，并在需要时生成它们。
如果您正在寻找Sun JDK的一部分，它并不存在，Apache Commons是获取此实用程序的常用方法之一（除了自己重新实现它之外）。这是相关的，@蝎子I哈
import java.util.*;

public class ListUtils
{
    public static void main(final String[] args)
    {
        final List<String> sl = new ArrayList<String>()
        {
            public String toString()
            {
                final StringBuilder sb = new StringBuilder(this.size() * 512);
                final ListIterator<String> li = this.listIterator();
                while (li.hasNext())
                {
                    if (li.nextIndex() == this.size() - 1)
                    {
                        sb.append("and ").append(li.next());
                    }
                    else if (li.nextIndex() == this.size() - 2)
                    {
                        sb.append(li.next()).append(" ");
                    }
                    else
                    {
                        sb.append(li.next()).append(", ");
                    }
                }
                return sb.toString();
            }
        };

        // Test the output  
        sl.add("Alpha");
        sl.add("Beta");
        sl.add("Omega");
        System.out.println(sl.toString());
    }
}

Alpha, Beta and Omega