Java 从长数组列表中拆分逗号

我有一个很长的ArrayList，它包含

[1982,1984,1986]

如何分隔逗号并将年份作为字符串？像这样：

1982年 1984 1986年

这是我目前的代码：

private String yearValue(MyProject myProjects){
    List<Long> myList = new ArrayList<>();

    List<MyValues> values = myProject.getProjects().getYearvalues();

    String year = "";

    for (MyValue value : values){
        Long key = (long)value.getYearvalues();
        if(!myList.contains(key)){
            myList.add(key);
        }
        year = myList.toString();
    }
    return year;
}

---

即使没有一行代码，也可以在列表中使用toString，如下所示：

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

不要为此使用ArrayList类的toString。使用正确的格式：

StringBuilder sb = new StringBuilder();
for(Long l:myList) {
    if(sb.length()>0) {
        sb.append(' '); // this is the separator between the items. '\n' will result in line breaks
    }
    sb.append(l);
}
String myString=sb.toString();

此代码将数组中的长元素连接为一个字符串，由单个空格分隔。这不是一艘班轮吗？不，不是。这是冗长的。而且可以立即阅读

更新以在单独的行中获取年份，只需将“”替换为“\n”

我为什么投鲁希拉的票？他的解决方案是否返回错误的结果？不，它返回的结果完全相同。那我为什么这么喜欢运动

最重要的是：他的解决方案绝对不容易阅读。Regex是一个非常强大的工具，但是与正确的代码相比，阅读和理解regexp是一个挑战，即使是这么简单。总是善待你的同事，写可读的代码。另外，如果我需要建造一座房子，我不想建造两座房子，然后拆掉一座来得到结果。。。 中等：使用List.toString。这将代码与一个实现的确切行为联系起来。从长远来看，这是非常糟糕的做法。 TL；博士，这基本上只是我自己的娱乐：

最不重要的是记住克努斯！：他的解决方案很慢。好的，不适用于4个长实例，但是序列化和应用regexp的成本更高。后文末尾的完整SSCCE不太重要。。 所有运行都有1000000次之前生成的[0；9999]范围内的随机长度转换，每个批之间有一个System.gc建议和一个Thread.sleep1000，确保使用-Xmx4096m-Xms4096m执行。当然，第一次跑步不应该被考虑在内

Method       STRING_BUILDER:    78 ms Method         REGEX_STRING:   312 ms Method           REGEX_LONG:   265 ms Method REGEX_STRING_PRECOMP:   249 ms 
Method       STRING_BUILDER:    47 ms Method         REGEX_STRING:   234 ms Method           REGEX_LONG:   202 ms Method REGEX_STRING_PRECOMP:   234 ms 
Method       STRING_BUILDER:    46 ms Method         REGEX_STRING:   234 ms Method           REGEX_LONG:   219 ms Method REGEX_STRING_PRECOMP:   218 ms 
Method       STRING_BUILDER:    47 ms Method         REGEX_STRING:   219 ms Method           REGEX_LONG:   187 ms Method REGEX_STRING_PRECOMP:   203 ms 
Method       STRING_BUILDER:    47 ms Method         REGEX_STRING:   218 ms Method           REGEX_LONG:   187 ms Method REGEX_STRING_PRECOMP:   172 ms 

代码，对于那些足够无聊的人：

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;


public class A {
  private static final String REGEX_PATTERN_STRING = "\\[|\\]|\\,";

  private static final int ITERATIONS = 1000000;

  private static final Pattern PRECOMPILED_PATTERN = Pattern.compile(REGEX_PATTERN_STRING);
  public static void main(String[] args) throws InterruptedException {

    //first warmup, then real tests
    for(int i=0;i<5;i++) {
      List<Long> randomLongs = getRandomLongs(ITERATIONS, 9999);
      List<String> randomLongsInStrings = convertToStringList(randomLongs);

      StringBuilder resultLine = new StringBuilder();
      List<String> returns = new ArrayList<String>(Methods.values().length);

      for(Methods m : Methods.values()) {
        long time=System.currentTimeMillis();
        returns.add(m.convert(randomLongs, randomLongsInStrings));
        time=System.currentTimeMillis()-time;
        resultLine.append(String.format("Method %20s: %5d ms ", m.name(), time));
      }

      //check to be the same
      for(int returnCheck=1;returnCheck<returns.size();returnCheck++) {
        if(!returns.get(returnCheck-1).equals(returns.get(returnCheck))) {
          throw new IllegalStateException("Error, mismatch!");
        }
      }

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

      System.gc(); // suggest for GC to happen
      Thread.sleep(1000); // allow JVM to do GC if it needs to
    }

  }


  private static List<Long> getRandomLongs(int howMany, int magnitude) {
    List<Long> longList = new ArrayList<Long>();
    for(int i=0;i<howMany;i++) {
      longList.add(Math.round(Math.random()*magnitude));
    }
    return longList;
  }

  private static <T> List<String> convertToStringList(List<T> inputList) {
    List<String> stringList = new ArrayList<String>();
    for(T inputElement:inputList) {
      stringList.add(inputElement.toString());
    }
    return stringList;
  }

  private enum Methods {

    STRING_BUILDER {
      @Override
      public String convert(List<Long> longList, List<String> stringList) {
        StringBuilder sb = new StringBuilder();
        for(Long l:longList) {
            if(sb.length()>0) {
                sb.append(' ');
            }
            sb.append(l);
        }
        return sb.toString();
      }

    },
    REGEX_STRING{

      @Override
      public String convert(List<Long> longList, List<String> stringList) {
        return longList.toString().replaceAll(REGEX_PATTERN_STRING,"");
      }

    },
    REGEX_LONG{

      @Override
      public String convert(List<Long> longList, List<String> stringList) {
        return stringList.toString().replaceAll(REGEX_PATTERN_STRING,"");
      }

    },
    REGEX_STRING_PRECOMP {

      @Override
      public String convert(List<Long> longList, List<String> stringList) {
        return PRECOMPILED_PATTERN.matcher(stringList.toString()).replaceAll("");
      }

    };

    public abstract String convert(List<Long> longList, List<String> stringList);

  }
}

---

您可以从编写代码开始。您尝试过什么吗？@MS_SP。这不是字符串，而是列表。是的，我尝试过类似将列表转换为字符串这样的操作：List myList=new ArrayList；字符串温度=；温度=myList.toString；然后尝试循环遍历字符串，但我没有得到正确的结果。可能对Meta有一个问题：如果没有代码，但99.999%清楚OP做了什么，如何做，以及如何失败，它是否仍然算作没有努力？然而包含实际代码肯定会有助于回答问题…感谢您的信息：我将尝试并让您知道我将非常感谢downvoter告诉我我的错误：请分享原因。与其在每次迭代中检查长度，您只需在最后测试sb.length>1即可sb.deleteCharAtsb.length-1。这将始终删除最后一个逗号（如果有）。不过解释得很好：@allprog或我可以使用一个名为isFirst的布尔值，这比我原来的要快。有时构建需要花费相当多的时间——而且我没有收到原型制造商的回复，所以我可以在构建时的几个休息时间内编写一个基准测试套件……当然，不同之处可能是在>2GHz的情况下有几百个CPU周期。。。可以忽略不计的：