-3

我有一个 Long 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;
}
4

1 回答 1

2

即使没有一行代码，很明显你用toString()的就行了，像这样：

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

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

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

此代码将数组中的 Long 元素连接到一个字符串，由单个空格分隔。不是一个班轮吗？不它不是。它很冗长。并且立即可读。

更新以在不同的行中获取年份，只需' '将'\n'.

为什么我对 Ruchira 投了反对票？他的解决方案是否返回不正确的结果？不，它返回完全相同。那我为什么这么牛逼呢？

  • 最重要的是：他的解决方案绝对不容易阅读。正则表达式是一个非常强大的工具，但与正确的代码相比，阅读和理解正则表达式是一项挑战，即使是这么简单。永远善待你的同事并编写可读的代码。另外，如果我需要建房子，我不想建2个房子，然后拆掉一个得到结果......
  • 重要的媒介：使用 List.toString()。这将代码与一个实现的确切行为联系起来。从长远来看，这是非常糟糕的做法。

TL;DR这基本上只是为了我自己的娱乐：

  • 最不重要的（记住 Knuth！）：他的解决方案很慢。好的，不是 4 个长实例，但序列化和应用正则表达式的成本更高。不是很重要（帖子末尾有完整的 SSCCE。）。

所有运行都有 1000000 次先前生成的随机 Long 在 range 中的转换，每个批次之间都有[0;9999]一个System.gc()建议和 a Thread.sleep(1000)，执行时-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);

  }
}
于 2013-08-15T11:34:38.803 回答