Java中的整数的短序列和甜序列 [英] Short and sweet sequence of integers in Java

问题描述

生成 List< Integer> 或者可能是一个 Integer 或 int ，从一些开始值到结束值的顺序值。

，但等效于 ¹ ：

  void List< Integer> makeSequence（int begin，int end）{
 List< Integer> ret = new ArrayList<>（end-begin + 1）; 
 for（int i = begin; i <= end; i ++）{
 ret.add（i）; 
} 
 return ret; 
} 
  

...但它逃避了我。使用番石榴或commons- *很好。

效能分析

由于这个问题已收到几个好的答案，都使用本机Java 8和第三方库，我想我将测试所有解决方案的性能。

第一个测试简单的测试创建一个10元素的列表 [1..10] 使用以下方法：

• classicArrayList ：
  
  
  

  ...再次对于大小为10,000的列表：

  
  
  

  a href =https://i.stack.imgur.com/zdxOz.png =nofollow noreferrer>

  
  
  

  最后一张图表是正确的 - 除了Eclipse和Guava以外的解决方案太慢，甚至得不到一个像素吧！快速解决方案比其他解决方案快10,000到20,000次

  。
  
  
  

  这里发生的事情当然是，番石榴和eclipse解决方案实际上没有实现任何种类的10,000元素列表 - 它们只是固定大小的包装在开始和端点。在迭代期间根据需要创建每个元素。因为我们实际上不在这个测试中迭代，所以成本被延迟。所有其他解决方案实际上实现了内存中的完整列表，并在仅创建基准中付出了沉重的代价。

  
  
  

  让我们做一些更逼真的事情，所有的整数，对它们求和。因此，在 IntStream.rangeClosed 变体的情况下，基准看起来像：

    @Benchmark 
   public int intStreamRange（）{
   List< Integer> ret = IntStream.rangeClosed（begin，end）.boxed（）。collect（Collectors.toList（））; 
   
   int total = 0; 
   for（int i：ret）{
   total + = i; 
  } 
   return total; 
  } 
    

  这里，图片变化很大，最快的。长度= 10：

  
  
  
  
  
  

  ... and length = 10,000：

  
  
  
  
  
  

  对许多元素的长期迭代使事情变得很多，但即使在10,000元素测试中，eclipse和番石榴仍然保持两倍以上。

  
  
  

  因此，如果你真的想要一个 List< Integer> ，eclipse集合看起来像是最好的选择 - 更原生的方式（例如，忘记 .boxed（）并在原语域中减少），你可能会比所有这些变体更快。

  
  
  

  ---

  
  
  

  ¹ 也许除了错误处理之外，例如， end < begin ，或者如果大小超过某个实现或JVM限制（例如，大于 2 ^ 31-1 的数组）。

  解决方案

  对于Java 8，它非常简单，所以它甚至不需要单独的方法：

    List< Integer> range = IntStream.rangeClosed（start，end）
   .boxed（）。collect（Collectors.toList b $ b  

  
  

  There must be a short and sweet way to generate a List<Integer>, or perhaps an array of Integer or int, with sequential values from some start value to an end value.

  That is, something shorter than, but equivalent to¹:

  void List<Integer> makeSequence(int begin, int end) {
    List<Integer> ret = new ArrayList<>(end - begin + 1);
    for (int i=begin; i<=end; i++) {
      ret.add(i);
    }
    return ret;  
  }
  

  ... but it's evading me. Use of guava or commons-* is fine.

  Performance Analysis

  Since this question has received several good answers, both using native Java 8 and third party libraries, I thought I'd test the performance of all the solutions.

  The first test simply tests creating a list of 10 elements [1..10] using the following methods:

  • classicArrayList: the code given above in my question (and essentially the same as adarshr's answer).
  • eclipseCollections: the code given in Donald's answer below using Eclipse Collections 8.0.
  • guavaRange: the code given in daveb's answer below. Technically, this doesn't create a List<Integer> but rather a ContiguousSet<Integer> - but since it implements Iterable<Integer> in-order, it mostly works for my purposes.
  • intStreamRange: the code given in Vladimir's answer below, which uses IntStream.rangeClosed() - which was introduced in Java 8.
  • streamIterate: the code given in Catalin's answer below which also uses IntStream functionality introduced in Java 8.

  Here are the results in kilo-operations per second (higher numbers are better), for all the above with lists of size 10:

  ... and again for lists of size 10,000:

  That last chart is correct - the solutions other than Eclipse and Guava are too slow to even get a single pixel bar! The fast solutions are 10,000 to 20,000 times faster than the rest.

  What's going on here, of course, is that the guava and eclipse solutions don't actually materialize any kind of 10,000 element list - they are simply fixed-size wrappers around the start and endpoints. Each element is created as needed during iteration. Since we don't actually iterate in this test, the cost is deferred. All of the other solutions actually materialize the full list in memory and pay a heavy price in a creation-only benchmark.

  Let's do something a bit more realistic and also iterate over all the integers, summing them. So in the case of the IntStream.rangeClosed variant, the benchmark looks like:

  @Benchmark
  public int intStreamRange() {
      List<Integer> ret = IntStream.rangeClosed(begin, end).boxed().collect(Collectors.toList());  
  
      int total = 0;
      for (int i : ret) {
          total += i;
      }
      return total;  
  }
  

  Here, the pictures changes a lot, although the non-materializing solutions are still the fastest. Here's length=10:

  ... and length = 10,000:

  The long iteration over many elements evens things up a lot, but eclipse and guava remain more than twice as fast even on the 10,000 element test.

  So if you really want a List<Integer>, eclipse collections seems like the best choice - but of course if you use streams in a more native way (e.g., forgetting .boxed() and doing a reduction in the primitive domain) you'll probably end up faster than all these variants.

  ---

  ¹ Perhaps with the exception of error handling, e.g., if end < begin, or if the size exceeds some implementation or JVM limits (e.g., arrays larger than 2^31-1.

  解决方案

  With Java 8 it is so simple so it doesn't even need separate method anymore:

  List<Integer> range = IntStream.rangeClosed(start, end)
      .boxed().collect(Collectors.toList());
  

  这篇关于Java中的整数的短序列和甜序列的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！