特殊外壳最后一个元素的最佳循环惯用语

Question

在进行简单的文本处理和打印语句时，我多次遇到这种情况，其中我循环遍历集合，并且我想对最后一个元素进行特殊处理（例如，除了最后一个情况之外，每个普通元素都将用逗号分隔）。

是否有一些最佳实践习惯用法或优雅的形式不需要重复代码或将 if, else 推入循环中。

例如，我有一个字符串列表，我想在逗号分隔的列表中打印这些字符串。 （ do while 解决方案已经假设列表有 2 个或更多元素，否则它会与更正确的条件循环一样糟糕）。

例如 List = ("dog", "cat", "bat")

我想打印 "[dog, cat, bat]"

我提出了 2 种方法

1. 带条件的 For 循环

   public static String forLoopConditional(String[] items) {
   
   字符串 itemOutput = "[";
   
   for (int i = 0; i < items.length; i++) {
       // 检查我们是否不在最后一个元素
       if (i < (items.length - 1)) {
           itemOutput += items[i] + ", ";
       } 别的 {
           // 最后一个元素
           itemOutput += items[i];
       }
   }
   itemOutput += "]";
   
   返回项目输出；
    }
   

2. do while 循环启动循环

   public static String doWhileLoopPrime(String[] items) {
   字符串 itemOutput = "[";
   整数 i = 0;
   
   itemOutput += items[i++];
   if (i < (items.length)) {
       做 {
           itemOutput += ", " + items[i++];
       while (i < items.length);
   }
   itemOutput += "]";
   
   返回项目输出；
   }
   

   测试人员类别：

   public static void main(String[] args) {
       String[] items = { "狗", "猫", "蝙蝠" };
   
       System.out.println(forLoopConditional(items));
       System.out.println(doWhileLoopPrime(items));
   
   }
   

在 Java AbstractCollection 类中，它具有以下实现（有点冗长，因为它包含所有边缘情况错误检查，但还不错）。

public String toString() {
    Iterator<E> i = iterator();
if (! i.hasNext())
    return "[]";

StringBuilder sb = new StringBuilder();
sb.append('[');
for (;;) {
    E e = i.next();
    sb.append(e == this ? "(this Collection)" : e);
    if (! i.hasNext())
    return sb.append(']').toString();
    sb.append(", ");
}
}

Answer 1

我通常这样写：

static String commaSeparated(String[] items) {
    StringBuilder sb = new StringBuilder();
    String sep = "";
    for (String item: items) {
        sb.append(sep);
        sb.append(item);
        sep = ",";
    }
    return sb.toString();
}

Answer 2

这些答案中有很多 for 循环，但我发现迭代器和 while 循环读取起来更容易。例如：

Iterator<String> itemIterator = Arrays.asList(items).iterator();
if (itemIterator.hasNext()) {
  // special-case first item.  in this case, no comma
  while (itemIterator.hasNext()) {
    // process the rest
  }
}

这是 Joiner 在 Google 集合中，我发现它非常可读。

Answer 3

string value = "[" + StringUtils.join( items, ',' ) + "]";

Answer 4

我通常的做法是测试索引变量是否为零，例如：

var result = "[ ";
for (var i = 0; i < list.length; ++i) {
    if (i != 0) result += ", ";
    result += list[i];
}
result += " ]";

但是，当然，只有当我们谈论没有某些 Array.join(", ") 方法的语言时才会这样。 ;-)

Answer 5

我认为将第一个元素视为特殊情况更容易，因为更容易知道迭代是否是第一个而不是最后一个。不需要任何复杂或昂贵的逻辑就可以知道某件事是否是第一次进行。

public static String prettyPrint(String[] items) {
    String itemOutput = "[";
    boolean first = true;

    for (int i = 0; i < items.length; i++) {
        if (!first) {
            itemOutput += ", ";
        }

        itemOutput += items[i];
        first = false;
    }

    itemOutput += "]";
    return itemOutput;
}

Answer 6

我会用你的第二个例子，即。处理循环外的特殊情况，写得更简单一点：

String itemOutput = "[";

if (items.length > 0) {
    itemOutput += items[0];

    for (int i = 1; i < items.length; i++) {
        itemOutput += ", " + items[i];
    }
}

itemOutput += "]";

Answer 7

Java 8 解决方案，以防有人正在寻找它：

String res = Arrays.stream(items).reduce((t, u) -> t + "," + u).get();

Answer 8

我喜欢对第一项使用标志。

 ArrayList<String> list = new ArrayList()<String>{{
       add("dog");
       add("cat");
       add("bat");
    }};
    String output = "[";
    boolean first = true;
    for(String word: list){
      if(!first) output += ", ";
      output+= word;
      first = false;
    }
    output += "]";

Answer 9

由于您的情况只是处理文本，因此您不需要循环内的条件。 AC 示例：

char* items[] = {"dog", "cat", "bat"};
char* output[STRING_LENGTH] = {0};
char* pStr = &output[1];
int   i;

output[0] = '[';
for (i=0; i < (sizeof(items) / sizeof(char*)); ++i) {
    sprintf(pStr,"%s,",items[i]);
    pStr = &output[0] + strlen(output);
}
output[strlen(output)-1] = ']';

不要添加条件以避免生成尾随逗号，而是继续生成它（以保持循环简单且无条件）并在末尾简单地覆盖它。很多时候，我发现像任何其他循环迭代一样生成特殊情况，然后在最后手动替换它会更清楚（尽管如果“替换它”代码超过几行，这种方法实际上会变得更难读）。

Answer 10

...

String[] items = { "dog", "cat", "bat" };
String res = "[";

for (String s : items) {
   res += (res.length == 1 ? "" : ", ") + s;
}
res += "]";

左右是相当可读的。当然，您可以将条件放在单独的 if 子句中。它的惯用之处（至少我认为是这样）是它使用 foreach 循环并且不使用复杂的循环头。

此外，没有重复的逻辑（即，只有一个地方将 items 中的项目实际附加到输出字符串 - 在现实世界的应用程序中，这可能复杂而冗长的格式化操作，所以我不想重复代码）。

Answer 11

在这种情况下，您实质上是使用某些分隔符字符串连接字符串列表。你也许可以自己写一些东西来做到这一点。然后你会得到类似的结果：

String[] items = { "dog", "cat", "bat" };
String result = "[" + joinListOfStrings(items, ", ") + "]"

如果

public static String joinListOfStrings(String[] items, String sep) {
    StringBuffer result;
    for (int i=0; i<items.length; i++) {
        result.append(items[i]);
        if (i < items.length-1) buffer.append(sep);
    }
    return result.toString();
}

你有一个 Collection 而不是 String[] 你也可以使用迭代器和 hasNext()方法来检查这是否是最后一个。

Answer 12

如果您像这样动态构建字符串，则不应使用 += 运算符。
StringBuilder 类对于重复的动态字符串连接效果更好。

public String commaSeparate(String[] items, String delim){
    StringBuilder bob = new StringBuilder();
    for(int i=0;i<items.length;i++){
        bob.append(items[i]);
        if(i+1<items.length){
           bob.append(delim);
        }
    }
    return bob.toString();
}

然后调用是这样的

String[] items = {"one","two","three"};
StringBuilder bob = new StringBuilder();
bob.append("[");
bob.append(commaSeperate(items,","));
bob.append("]");
System.out.print(bob.toString());

Answer 13

一般来说，我最喜欢的是多层出口。更改

for ( s1; exit-condition; s2 ) {
    doForAll();
    if ( !modified-exit-condition ) 
        doForAllButLast();
}

为

for ( s1;; s2 ) {
    doForAll();
if ( modified-exit-condition ) break;
    doForAllButLast();
}

It 消除了任何重复代码或冗余检查。

你的例子：

for (int i = 0;; i++) {
    itemOutput.append(items[i]);
if ( i == items.length - 1) break;
    itemOutput.append(", ");
}

它在某些方面比其他方面更有效。对于这个具体的例子，我不太喜欢这个。

当然，对于退出条件取决于 doForAll() 中发生的情况而不仅仅是 s2 的情况，情况会变得非常棘手。使用Iterator就是这样的情况。

这是一篇论文 来自无耻地向他的学生推广它的教授:-)。请阅读第 5 节，了解您所讨论的内容。

Answer 14

我认为这个问题有两个答案：任何语言中解决这个问题的最佳习惯用法，以及java中解决这个问题的最佳习惯用法。我还认为这个问题的目的不是将字符串连接在一起的任务，而是一般的模式，所以它并没有真正帮助显示可以做到这一点的库函数。

首先，用 [] 包围字符串和创建用逗号分隔的字符串的操作是两个单独的操作，并且理想情况下是两个单独的函数。

对于任何语言，我认为递归和模式匹配的组合效果最好。例如，在haskell中我会这样做：

join [] = ""
join [x] = x
join (x:xs) = concat [x, ",", join xs]

surround before after str = concat [before, str, after]

yourFunc = surround "[" "]" . join

-- example usage: yourFunc ["dog", "cat"] will output "[dog,cat]"

这样写的好处是它清楚地列举了函数将面临的不同情况，以及它将如何处理。

另一种非常好的方法是使用累加器类型函数。例如：

join [] = ""
join strings = foldr1 (\a b -> concat [a, ",", b]) strings 

这也可以用其他语言完成，例如 c#：

public static string Join(List<string> strings)
{
    if (!strings.Any()) return string.Empty;
    return strings.Aggregate((acc, val) => acc + "," + val);
}

在这种情况下效率不是很高，但在其他情况下可能很有用（或者效率可能并不重要）。

不幸的是，java 不能使用这两种方法。因此，在这种情况下，我认为最好的方法是在函数顶部检查异常情况（0 或 1 个元素），然后使用 for 循环来处理超过 1 个元素的情况：

public static String join(String[] items) {
    if (items.length == 0) return "";
    if (items.length == 1) return items[0];

    StringBuilder result = new StringBuilder();
    for(int i = 0; i < items.length - 1; i++) {
        result.append(items[i]);
        result.append(",");
    }
    result.append(items[items.length - 1]);
    return result.toString();
}

该函数清楚地表明两种边缘情况（0 或 1 个元素）中会发生什么。然后，它对除最后一个元素之外的所有元素使用循环，最后添加最后一个元素而不使用逗号。在开头处理非逗号元素的相反方法也很容易做到。

请注意， if (items.length == 1) return items[0]; 行实际上并不是必需的，但我认为它使函数的作用更容易一目了然。

（请注意，如果有人想要有关 haskell/c# 函数的更多解释，请询问，我会将其添加进去）

Answer 15

它可以使用 Java 8 lambda 和 Collectors.joining() 来实现 -

List<String> items = Arrays.asList("dog", "cat", "bat");
String result = items.stream().collect(Collectors.joining(", ", "[", "]"));
System.out.println(result);

Answer 16

我通常会写这样的for循环：

public static String forLoopConditional(String[] items) {
    StringBuilder builder = new StringBuilder();         

    builder.append("[");                                 

    for (int i = 0; i < items.length - 1; i++) {         
        builder.append(items[i] + ", ");                 
    }                                                    

    if (items.length > 0) {                              
        builder.append(items[items.length - 1]);         
    }                                                    

    builder.append("]");                                 

    return builder.toString();                           
}       

Answer 17

如果您只是在寻找像这样的逗号分隔列表：“[The, Cat, in, the, Hat]”，甚至不要浪费时间编写自己的方法。只需使用 List.toString:

List<String> strings = Arrays.asList("The", "Cat", "in", "the", "Hat);

System.out.println(strings.toString());

假设 List 的泛型类型有一个带有您想要显示的值的 toString，只需调用 List.toString:

public class Dog {
    private String name;

    public Dog(String name){
         this.name = name;
    }

    public String toString(){
        return name;
    }
}

然后您可以执行以下操作：

List<Dog> dogs = Arrays.asList(new Dog("Frank"), new Dog("Hal"));
System.out.println(dogs);

您将得到：
[弗兰克，哈尔]

Answer 18

第三种选择如下，

StringBuilder output = new StringBuilder();
for (int i = 0; i < items.length - 1; i++) {
    output.append(items[i]);
    output.append(",");
}
if (items.length > 0) output.append(items[items.length - 1]);

但最好是使用类似 join() 的方法。对于Java，有一个 String.join 在第三方库中，这样你的代码就变成：

StringUtils.join(items,',');

FWIW，join() 方法（第 3232 行起）确实使用循环内的 if ：

public static String join(Object[] array, char separator, int startIndex, int endIndex)     {
        if (array == null) {
            return null;
        }
        int bufSize = (endIndex - startIndex);
        if (bufSize <= 0) {
            return EMPTY;
        }

        bufSize *= ((array[startIndex] == null ? 16 : array[startIndex].toString().length()) + 1);
        StringBuilder buf = new StringBuilder(bufSize);

        for (int i = startIndex; i < endIndex; i++) {
            if (i > startIndex) {
                buf.append(separator);
            }
            if (array[i] != null) {
                buf.append(array[i]);
            }
        }
        return buf.toString();
    }