Bagaimana saya bisa menghasilkan daftar atau larik bilangan bulat berurutan di Java?

Apakah ada cara yang singkat dan menarik untuk menghasilkan a List<Integer>, atau mungkin an Integer[]atau int[], dengan nilai berurutan dari beberapa startnilai ke endnilai?

Artinya, sesuatu yang lebih pendek dari, tetapi setara dengan ¹ berikut ini:

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

Penggunaan jambu biji boleh saja.

Memperbarui:

Analisis Kinerja

Karena pertanyaan ini telah menerima beberapa jawaban bagus, baik menggunakan Java 8 asli dan pustaka pihak ketiga, saya pikir saya akan menguji kinerja semua solusi.

Tes pertama hanya menguji pembuatan daftar 10 elemen [1..10]menggunakan metode berikut:

• classicArrayList : kode yang diberikan di atas dalam pertanyaan saya (dan pada dasarnya sama dengan jawaban adarshr).
• eclipseCollections : kode yang diberikan dalam jawaban Donald di bawah ini menggunakan Eclipse Collections 8.0.
• guavaRange : kode yang diberikan dalam jawaban daveb di bawah ini. Secara teknis, ini tidak membuat List<Integer>melainkan a ContiguousSet<Integer>- tetapi karena diterapkan Iterable<Integer>secara berurutan, sebagian besar berfungsi untuk tujuan saya.
• intStreamRange : kode yang diberikan dalam jawaban Vladimir di bawah ini, yang menggunakan IntStream.rangeClosed()- yang diperkenalkan di Java 8.
• streamIterate : kode yang diberikan dalam jawaban Catalin di bawah ini yang juga menggunakan IntStreamfungsionalitas yang diperkenalkan di Java 8.

Berikut adalah hasil dalam kilo-operasi per detik (angka yang lebih tinggi lebih baik), untuk semua di atas dengan daftar ukuran 10:

... dan sekali lagi untuk daftar ukuran 10.000:

Bagan terakhir itu benar - solusi selain Eclipse dan Guava terlalu lambat bahkan untuk mendapatkan satu batang piksel! Solusi cepatnya 10.000 hingga 20.000 kali lebih cepat daripada yang lain.

Apa yang terjadi di sini, tentu saja, adalah bahwa solusi jambu biji dan gerhana tidak benar-benar mewujudkan daftar 10.000 elemen apa pun - mereka hanya pembungkus berukuran tetap di sekitar titik awal dan akhir. Setiap elemen dibuat sesuai kebutuhan selama iterasi. Karena kami tidak benar-benar mengulang dalam pengujian ini, biayanya ditangguhkan. Semua solusi lain benar-benar mewujudkan daftar lengkap dalam memori dan membayar mahal dalam tolok ukur khusus kreasi.

Mari kita lakukan sesuatu yang sedikit lebih realistis dan juga mengulangi semua bilangan bulat, menjumlahkannya. Jadi dalam kasus IntStream.rangeClosedvarian, tolok ukurnya terlihat seperti:

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

Di sini, gambar banyak berubah, meskipun solusi yang tidak terwujud masih yang tercepat. Berikut panjangnya = 10:

... dan panjang = 10.000:

Iterasi panjang pada banyak elemen meratakan banyak hal, tetapi gerhana dan jambu biji tetap lebih dari dua kali lebih cepat bahkan pada uji 10.000 elemen.

Jadi jika Anda benar - benar menginginkan List<Integer>, koleksi gerhana tampaknya pilihan terbaik - tetapi tentu saja jika Anda menggunakan aliran dengan cara yang lebih asli (misalnya, melupakan .boxed()dan melakukan pengurangan dalam domain primitif) Anda mungkin akan berakhir lebih cepat daripada semua ini. varian.

¹ Mungkin dengan pengecualian penanganan kesalahan, misalnya jika end< begin, atau jika ukurannya melebihi beberapa implementasi atau batas JVM (misalnya, array lebih besar dari 2^31-1.

Dengan Java 8 itu sangat sederhana sehingga tidak memerlukan metode terpisah lagi:

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

Nah, liner yang satu ini mungkin memenuhi syarat (menggunakan Guava Ranges )

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

Ini tidak membuat List<Integer>, tetapi ContiguousSetmenawarkan banyak fungsionalitas yang sama, khususnya penerapan Iterable<Integer>yang memungkinkan foreachimplementasi dengan cara yang sama seperti List<Integer>.

Di versi lama (sebelum Guava 14) Anda bisa menggunakan ini:

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

Keduanya menghasilkan:

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

Versi Java 8 satu baris berikut akan menghasilkan [1, 2, 3 ... 10]. Argumen pertama iterateadalah nr pertama dalam barisan, dan argumen pertama limitadalah bilangan terakhir.

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

Anda dapat menggunakan Intervalkelas dari Koleksi Eclipse .

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

The Intervalkelas malas, sehingga tidak menyimpan semua nilai-nilai.

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

Metode Anda akan dapat diterapkan sebagai berikut:

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

Jika Anda ingin menghindari tinju int sebagai Integer, tetapi tetap menginginkan struktur daftar sebagai hasilnya, Anda dapat menggunakan IntListwith IntIntervalfrom Eclipse Collections.

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

IntListmemiliki metode sum(), min(), minIfEmpty(), max(), maxIfEmpty(), average()dan median()tersedia pada antarmuka.

Pembaruan untuk kejelasan: 11/27/2017

An Intervaladalah a List<Integer>, tetapi malas dan tidak dapat diubah. Ini sangat berguna untuk menghasilkan data pengujian, terutama jika Anda berurusan dengan banyak koleksi. Jika mau, Anda dapat dengan mudah menyalin interval ke List, Setatau Bagsebagai berikut:

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

An IntIntervaladalah ImmutableIntListyang meluas IntList. Ini juga memiliki metode konverter.

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

An Intervaldan an IntIntervaltidak memiliki equalskontrak yang sama .

Pembaruan untuk Koleksi Eclipse 9.0

Sekarang Anda dapat membuat koleksi primitif dari aliran primitif. Ada withAlldan ofAllmetode tergantung pada preferensi Anda. Jika Anda penasaran, saya jelaskan mengapa kita memiliki keduanya di sini . Metode ini ada untuk Int / Long / Double List, Sets, Bags dan Stacks yang dapat berubah dan tidak berubah.

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

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

Catatan: Saya seorang pelaku untuk Koleksi Eclipse

Ini adalah waktu terpendek yang saya dapat menggunakan 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;  
}

Anda bisa menggunakan Guava Ranges

Anda bisa mendapatkan SortedSetdengan menggunakan

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

Ini adalah waktu terpendek yang bisa saya temukan.

Versi daftar

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 Array

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

Yang ini mungkin berhasil untuk Anda ....

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