¿Cómo puedo generar una lista o matriz de enteros secuenciales en Java?

¿Hay una manera corta y dulce de generar un List<Integer>, o tal vez un Integer[]o int[], con valores secuenciales de algún startvalor a un endvalor?

Es decir, algo más corto que, pero equivalente a ^1, lo siguiente:

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

El uso de la guayaba está bien.

Actualizar:

Análisis de rendimiento

Dado que esta pregunta ha recibido varias buenas respuestas, utilizando tanto Java 8 nativas como bibliotecas de terceros, pensé en probar el rendimiento de todas las soluciones.

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

• classicArrayList : el código dado anteriormente en mi pregunta (y esencialmente el mismo que la respuesta de adarshr).
• eclipseCollections : el código dado en la respuesta de Donald a continuación usando Eclipse Collections 8.0.
• guavaRange : el código dado en la respuesta de daveb a continuación. Técnicamente, esto no crea un List<Integer>sino más bien un ContiguousSet<Integer>, pero como se implementa Iterable<Integer>en orden, funciona principalmente para mis propósitos.
• intStreamRange : el código proporcionado en la respuesta de Vladimir a continuación, que utiliza IntStream.rangeClosed(), que se introdujo en Java 8.
• streamIterate : el código proporcionado en la respuesta de Catalin a continuación, que también utiliza la IntStreamfuncionalidad 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 nuevamente para listas de tamaño 10,000:

Ese último gráfico es correcto: las soluciones que no sean Eclipse y Guava son demasiado lentas para incluso obtener una sola barra de píxeles. Las soluciones rápidas son 10,000 a 20,000 veces más rápidas que el resto.

Lo que está sucediendo 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. Como no realizamos iteraciones en esta prueba, el costo se difiere. Todas las otras soluciones en realidad materializan la lista completa en la memoria y pagan un alto precio en un punto de referencia de solo creación.

Hagamos algo un poco más realista y también iteremos sobre todos los enteros, resumiéndolos. Entonces, en el caso de la IntStream.rangeClosedvariante, el punto de referencia se ve así:

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

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 iguala las cosas mucho, pero el eclipse y la guayaba permanecen más del doble de rápido incluso en la prueba de 10,000 elementos.

Entonces, si realmente desea una List<Integer>, las colecciones de eclipse parecen ser la mejor opción, pero, por supuesto, si usa secuencias de una manera más nativa (por ejemplo, olvidando .boxed()y haciendo una reducción en el dominio primitivo), probablemente terminará más rápido que todos estos variantes

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

Con Java 8 es tan simple que ya ni siquiera necesita un método separado:

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

Bueno, este trazador de líneas podría calificar (usa gamas de guayaba )

ContiguousSet<Integer> integerList = ContiguousSet.create(Range.closedOpen(0, 10), DiscreteDomain.integers());
System.out.println(integerList);

Esto no crea una List<Integer>, pero ContiguousSetofrece la misma funcionalidad, en particular la implementación Iterable<Integer>que permite la foreachimplementación de la misma manera que List<Integer>.

En versiones anteriores (en algún lugar antes de Guava 14) podría usar esto:

ImmutableList<Integer> integerList = Ranges.closedOpen(0, 10).asSet(DiscreteDomains.integers()).asList();
System.out.println(integerList);

Ambos producen:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

La siguiente versión de Java 8 de una línea generará [1, 2, 3 ... 10]. El primer argumento de iteratees el primer nr de la secuencia, y el primer argumento de limites el último número.

List<Integer> numbers = Stream.iterate(1, n -> n + 1)
                              .limit(10)
                              .collect(Collectors.toList());

Puede usar la Intervalclase de Eclipse Collections .

List<Integer> range = Interval.oneTo(10);
range.forEach(System.out::print);  // prints 12345678910

La Intervalclase es perezosa, por lo que no almacena todos los valores.

LazyIterable<Integer> range = Interval.oneTo(10);
System.out.println(range.makeString(",")); // prints 1,2,3,4,5,6,7,8,9,10

Su método podría implementarse de la siguiente manera:

public List<Integer> makeSequence(int begin, int end) {
    return Interval.fromTo(begin, end);
}

Si desea evitar las entradas de boxeo como enteros, pero aún así desea una estructura de lista como resultado, puede usarlo IntListcon IntIntervalEclipse Collections.

public IntList makeSequence(int begin, int end) {
    return IntInterval.fromTo(begin, end);
}

IntListtiene los métodos sum(), min(), minIfEmpty(), max(), maxIfEmpty(), average()y median()disponible en la interfaz.

Actualización para mayor claridad: 27/11/2017

An Intervales a List<Integer>, pero es vago e inmutable. Es extremadamente útil para generar datos de prueba, especialmente si manejas mucho las colecciones. Si lo desea, puede copiar fácilmente un intervalo en a List, Seto de la Bagsiguiente manera:

Interval integers = Interval.oneTo(10);
Set<Integer> set = integers.toSet();
List<Integer> list = integers.toList();
Bag<Integer> bag = integers.toBag();

Un IntIntervales un ImmutableIntListque se extiende IntList. También tiene métodos de conversión.

IntInterval ints = IntInterval.oneTo(10);
IntSet set = ints.toSet();
IntList list = ints.toList();
IntBag bag = ints.toBag();

An Intervaly an IntIntervalno tienen el mismo equalscontrato.

Actualización para Eclipse Collections 9.0

Ahora puede crear colecciones primitivas a partir de flujos primitivos. Existen withAlly ofAllmétodos según su preferencia. Si tienes curiosidad, te explico por qué tenemos ambos aquí . Estos métodos existen para listas, conjuntos, bolsas y pilas Int / Long / Double mutables e inmutables.

Assert.assertEquals(
        IntInterval.oneTo(10),
        IntLists.mutable.withAll(IntStream.rangeClosed(1, 10)));

Assert.assertEquals(
        IntInterval.oneTo(10),
        IntLists.immutable.withAll(IntStream.rangeClosed(1, 10)));

Nota: Soy un committer para Eclipse Collections

Esto es lo más corto que pude obtener usando Core Java.

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

Podrías usar gamas de guayaba

Puedes obtener un SortedSetusando

ImmutableSortedSet<Integer> set = Ranges.open(1, 5).asSet(DiscreteDomains.integers());
// set contains [2, 3, 4]

Esto es lo más corto que pude encontrar.

Lista de versiones

public List<Integer> makeSequence(int begin, int end)
{
    List<Integer> ret = new ArrayList<Integer>(++end - begin);

    for (; begin < end; )
        ret.add(begin++);

    return ret;
}

Versión de matriz

public int[] makeSequence(int begin, int end)
{
    if(end < begin)
        return null;

    int[] ret = new int[++end - begin];
    for (int i=0; begin < end; )
        ret[i++] = begin++;
    return ret;
}

Este podría funcionar para ti ...

void List<Integer> makeSequence(int begin, int end) {

  AtomicInteger ai=new AtomicInteger(begin);
  List<Integer> ret = new ArrayList(end-begin+1);

  while ( end-->begin) {

    ret.add(ai.getAndIncrement());

  }
  return ret;  
}