¿Hay una forma corta y dulce de generar unList<Integer>, o tal vez unInteger[] oint[], con valores secuenciales de algunosstart valor a unend ¿valor?

Es decir, algo más corto que, pero equivalente a1 el seguimiento:

<code>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;  
}
</code>

El uso de guayaba está bien.

Actualizar:

Análisis de rendimiento

Dado que esta pregunta ha recibido varias respuestas correctas, tanto con el uso de bibliotecas nativas de Java 8 como de terceros, pensé que probaría el rendimiento de todas las soluciones.

La primera prueba simplemente prueba creando una lista de 10 elementos.[1..10] utilizando los siguientes métodos:

classicArrayList: el código dado arriba en mi pregunta (y esencialmente lo mismo que la respuesta de Adarshr).eclipseColecciones: el código dado enLa respuesta de donald A continuación utilizando Eclipse Collections 8.0.rango de guayaba: el código dado enla respuesta de daveb abajo. Técnicamente, esto no crea unaList<Integer> sino más bien unContiguousSet<Integer> - pero ya que implementaIterable<Integer> en orden, principalmente funciona para mis propósitos.intStreamRange: el código dado enLa respuesta de vladimir abajo, que utilizaIntStream.rangeClosed() - Que se introdujo en Java 8.streamIterate: el código dado enLa respuesta de catalin debajo del cual también usaIntStream Funcionalidad introducida en Java 8.

Aquí están los resultados en kilo-operaciones por segundo (los números más altos son mejores), para todo lo anterior con listas de tamaño 10:

... y otra vez para listas de tamaño 10,000:

El último gráfico es correcto: las soluciones que no sean Eclipse y Guava son demasiado lentas para obtener una barra de píxeles. Las soluciones rápidas son de 10.000 a 20.000.veces Más rápido que el resto.

Lo que sucede aquí, por supuesto, es que las soluciones de guayaba y eclipse en realidad no materializan ningún tipo de lista de 10,000 elementos, simplemente son envoltorios de tamaño fijo alrededor del inicio y los puntos finales. Cada elemento se crea según sea necesario durante la iteración. Dado que en realidad no iteramos en esta prueba, el costo es diferido. Todas las otras soluciones en realidad materializan la lista completa en memoria y pagan un precio elevado en un punto de referencia de creación solamente.

Hagamos algo un poco más realista y también iteremos sobre todos los enteros, sumándolos. Así que en el caso de laIntStream.rangeClosed variante, el punto de referencia se ve como:

<code>@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;  
}
</code>

Aquí, las imágenes cambian mucho, aunque las soluciones que no se materializan siguen siendo las más rápidas. Aquí está la longitud = 10:

... y longitud = 10,000:

La larga iteración sobre muchos elementos empareja las cosas mucho, pero el eclipse y la guayaba siguen siendo más del doble de rápido incluso en la prueba de los 10.000 elementos.

Así que si ustedDe Verdad quiero unList<Integer>, las colecciones de eclipse parecen ser la mejor opción, pero, por supuesto, si utiliza las secuencias de una forma más nativa (por ejemplo, olvidando.boxed() y haciendo una reducción en el dominio primitivo) probablemente terminará más rápido que todas estas variantes.

1 Quizás con la excepción del manejo de errores, por ejemplo, siend < begin, o si el tamaño excede algunos límites de implementación o JVM (por ejemplo, matrices mayores que2^31-1.