Saya ingin membuat daftar opsi untuk tujuan pengujian. Pada awalnya, saya melakukan ini:

ArrayList<String> places = new ArrayList<String>();
places.add("Buenos Aires");
places.add("Córdoba");
places.add("La Plata");

Lalu, saya refactored kode sebagai berikut:

ArrayList<String> places = new ArrayList<String>(
    Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

Apakah ada cara yang lebih baik untuk melakukan ini?

Sebenarnya, mungkin cara "terbaik" untuk menginisialisasi ArrayListadalah metode yang Anda tulis, karena tidak perlu membuat yang baru Listdengan cara apa pun:

ArrayList<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");

Tangkapannya adalah bahwa ada sedikit pengetikan yang diperlukan untuk merujuk pada listinstance itu.

Ada beberapa alternatif, seperti membuat kelas dalam anonim dengan inisialisasi instance (juga dikenal sebagai "inisialisasi penjepit ganda"):

ArrayList<String> list = new ArrayList<String>() {{
    add("A");
    add("B");
    add("C");
}};

Namun, saya tidak terlalu menyukai metode itu karena apa yang Anda dapatkan pada akhirnya adalah subkelas ArrayListyang memiliki instance initializer, dan kelas itu dibuat hanya untuk membuat satu objek - yang sepertinya sedikit berlebihan bagi saya.

Apa yang akan lebih baik adalah jika proposal Literals Pengumpulan untuk Project Coin diterima (itu dijadwalkan akan diperkenalkan di Jawa 7, tetapi kemungkinan besar tidak akan menjadi bagian dari Java 8.):

List<String> list = ["A", "B", "C"];

Sayangnya itu tidak akan membantu Anda di sini, karena ini akan menginisialisasi yang kekal Listalih-alih sebuah ArrayList, dan lebih jauh lagi, itu belum tersedia, jika memang pernah ada.

Akan lebih mudah jika Anda hanya mendeklarasikannya sebagai List- apakah harus menjadi ArrayList?

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

Atau jika Anda hanya memiliki satu elemen:

List<String> places = Collections.singletonList("Buenos Aires");

Ini berarti yang placestidak dapat diubah (mencoba mengubahnya akan menyebabkan UnsupportedOperationExceptionpengecualian dilemparkan).

Untuk membuat daftar yang dapat diubah yang merupakan beton, ArrayListAnda dapat membuat ArrayListdari daftar yang tidak dapat diubah:

ArrayList<String> places = new ArrayList<>(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

Jawabannya sederhana

Di Java 9 atau lebih baru, setelah List.of()ditambahkan:

List<String> strings = List.of("foo", "bar", "baz");

Dengan Java 10 atau lebih baru, ini dapat disingkat dengan varkata kunci.

var strings = List.of("foo", "bar", "baz");

Ini akan memberi Anda kekal List , jadi itu tidak bisa diubah.
Apa yang Anda inginkan dalam banyak kasus di mana Anda melakukan pra-pengisian.

Java 8 atau sebelumnya:

List<String> strings = Arrays.asList("foo", "bar", "baz");

Ini akan memberi Anda Listdidukung oleh array, sehingga tidak dapat mengubah panjang.
Tapi Anda bisa menelepon List.set, jadi masih bisa berubah .

Anda dapat membuat Arrays.asListlebih pendek dengan impor statis:

List<String> strings = asList("foo", "bar", "baz");

Impor statis:

import static java.util.Arrays.asList;  

Yang disarankan oleh setiap IDE modern dan otomatis untuk Anda
Misalnya di IntelliJ IDEA Anda menekan Alt+Enterdan memilih Static import method....

Namun, saya tidak menyarankan untuk memperpendek List.ofmetode of, karena itu menjadi membingungkan.
List.ofsudah cukup pendek dan membaca dengan baik.

Menggunakan Streams

Kenapa harus jadi List?
Dengan Java 8 atau lebih baru Anda dapat menggunakan Streamyang lebih fleksibel:

Stream<String> strings = Stream.of("foo", "bar", "baz");

Anda dapat menggabungkan Stream:

Stream<String> strings = Stream.concat(Stream.of("foo", "bar"),
                                       Stream.of("baz", "qux"));

Atau Anda dapat beralih dari a Streamke List:

import static java.util.stream.Collectors.toList;

List<String> strings = Stream.of("foo", "bar", "baz").collect(toList());

Tetapi lebih disukai, gunakan saja Streamtanpa mengumpulkannya untuk List.

Jika Anda benar - benar membutuhkanjava.util.ArrayList

(Anda mungkin tidak.)
Mengutip JEP 269 (penekanan milik saya):

Ada satu set kecil kasus penggunaan untuk menginisialisasi contoh koleksi yang dapat diubah dengan seperangkat nilai yang telah ditentukan. Biasanya lebih disukai untuk memiliki nilai-nilai yang telah ditetapkan dalam koleksi yang tidak dapat diubah, dan kemudian menginisialisasi koleksi yang dapat diubah melalui copy constructor.

Jika Anda ingin keduanya menjadi pra-populasi ArrayList dan menambahkannya setelah itu (mengapa?), Gunakan

ArrayList<String> strings = new ArrayList<>(List.of("foo", "bar"));
strings.add("baz");

atau di Java 8 atau sebelumnya:

ArrayList<String> strings = new ArrayList<>(asList("foo", "bar"));
strings.add("baz");

atau menggunakan Stream:

import static java.util.stream.Collectors.toCollection;

ArrayList<String> strings = Stream.of("foo", "bar")
                             .collect(toCollection(ArrayList::new));
strings.add("baz");

Tapi sekali lagi, lebih baik menggunakan Streamlangsung daripada mengumpulkannya untuk List.

Program untuk antarmuka, bukan implementasi

Anda mengatakan telah mendeklarasikan daftar sebagai ArrayListdalam kode Anda, tetapi Anda hanya boleh melakukannya jika Anda menggunakan beberapa anggota ArrayListyang tidak ada dalam List.

Yang kemungkinan besar tidak Anda lakukan.

Biasanya Anda hanya harus mendeklarasikan variabel dengan antarmuka yang paling umum yang Anda akan digunakan (misalnya Iterable, Collectionatau List), dan menginisialisasi mereka dengan pelaksanaan tertentu (misalnya ArrayList, LinkedListatau Arrays.asList()).

Kalau tidak, Anda membatasi kode Anda ke jenis tertentu, dan akan lebih sulit untuk mengubah kapan pun Anda mau.

Misalnya, jika Anda melewati sebuah ArrayListke void method(...):

// Iterable if you just need iteration, for (String s : strings):
void method(Iterable<String> strings) { 
    for (String s : strings) { ... } 
}

// Collection if you also need .size(), .isEmpty(), or .stream():
void method(Collection<String> strings) {
    if (!strings.isEmpty()) { strings.stream()... }
}

// List if you also need .get(index):
void method(List<String> strings) {
    strings.get(...)
}

// Don't declare a specific list implementation
// unless you're sure you need it:
void method(ArrayList<String> strings) {
    ??? // You don't want to limit yourself to just ArrayList
}

Contoh lain akan selalu menyatakan variabel InputStreammeskipun biasanya a FileInputStreamatau a BufferedInputStream, karena suatu hari nanti Anda atau orang lain akan ingin menggunakan beberapa jenis lain InputStream.

Jika Anda memerlukan daftar sederhana ukuran 1:

List<String> strings = new ArrayList<String>(Collections.singletonList("A"));

Jika Anda memerlukan daftar beberapa objek:

List<String> strings = new ArrayList<String>();
Collections.addAll(strings,"A","B","C","D");

Dengan Jambu Anda dapat menulis:

ArrayList<String> places = Lists.newArrayList("Buenos Aires", "Córdoba", "La Plata");

Di Jambu ada juga konstruktor statis berguna lainnya. Anda dapat membacanya di sini .

Literal kumpulan tidak berhasil masuk ke Java 8, tetapi dimungkinkan untuk menggunakan API Stream untuk menginisialisasi daftar dalam satu baris yang agak panjang:

List<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toList());

Jika Anda perlu memastikan bahwa Anda Listadalah ArrayList:

ArrayList<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toCollection(ArrayList::new));

Dengan java-9dan di atas, seperti yang disarankan dalam JEP 269: Convenience Factory Methods for Collections , ini dapat dicapai dengan menggunakan literal koleksi sekarang dengan -

List<String> list = List.of("A", "B", "C");

Set<String> set = Set.of("A", "B", "C");

Pendekatan serupa juga berlaku untuk Map-

Map<String, String> map = Map.of("k1", "v1", "k2", "v2", "k3", "v3")

yang mirip dengan proposal Collection Literals seperti yang dinyatakan oleh @coobird. Lebih lanjut diklarifikasi dalam JEP juga -

Alternatif

Perubahan bahasa telah dipertimbangkan beberapa kali, dan ditolak:

Proposal Koin Proyek, 29 Maret 2009

Proposal Koin Proyek, 30 Maret 2009

Diskusi JEP 186 tentang lambda-dev, Januari-Maret 2014

Proposal bahasa dikesampingkan sebagai preferensi terhadap proposal berbasis perpustakaan seperti yang dirangkum dalam pesan ini .

Terkait: Apa gunanya Metode Convenience Factory yang terlalu banyak untuk Koleksi di Jawa 9

import com.google.common.collect.ImmutableList;

....

List<String> places = ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");

Anda dapat membuat metode pabrik:

public static ArrayList<String> createArrayList(String ... elements) {
  ArrayList<String> list = new ArrayList<String>();
  for (String element : elements) {
    list.add(element);
  }
  return list;
}

....

ArrayList<String> places = createArrayList(
  "São Paulo", "Rio de Janeiro", "Brasília");

Tapi itu tidak jauh lebih baik daripada refactoring pertama Anda.

Untuk fleksibilitas yang lebih besar, ini dapat bersifat umum

public static <T> ArrayList<T> createArrayList(T ... elements) {
  ArrayList<T> list = new ArrayList<T>();
  for (T element : elements) {
    list.add(element);
  }
  return list;
}

Di Java 9 kita dapat dengan mudah menginisialisasi ArrayListdalam satu baris:

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

atau

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));

Pendekatan baru Java 9 ini memiliki banyak keunggulan dibandingkan yang sebelumnya:

1. Efisiensi Ruang
2. Kekekalan
3. Aman untuk Thread

Lihat posting ini untuk lebih jelasnya -> Apa perbedaan antara List.of dan Arrays.asList?

Tentang cara paling ringkas untuk melakukan ini adalah:

Double array[] = { 1.0, 2.0, 3.0};
List<Double> list = Arrays.asList(array);

Cukup gunakan kode di bawah ini sebagai berikut.

List<String> list = new ArrayList<String>() {{
            add("A");
            add("B");
            add("C");
}};

Dengan Eclipse Collections Anda dapat menulis yang berikut ini:

List<String> list = Lists.mutable.with("Buenos Aires", "Córdoba", "La Plata");

Anda juga bisa lebih spesifik tentang jenis dan apakah mereka bisa berubah atau tidak berubah.

MutableList<String> mList = Lists.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableList<String> iList = Lists.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Anda juga dapat melakukan hal yang sama dengan Set dan Tas:

Set<String> set = Sets.mutable.with("Buenos Aires", "Córdoba", "La Plata");
MutableSet<String> mSet = Sets.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet<String> iSet = Sets.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Bag<String> bag = Bags.mutable.with("Buenos Aires", "Córdoba", "La Plata");
MutableBag<String> mBag = Bags.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableBag<String> iBag = Bags.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Catatan: Saya pengendara untuk Eclipse Collections.

Ini cara lain:

List<String> values = Stream.of("One", "Two").collect(Collectors.toList());

(Seharusnya komentar, tapi terlalu panjang, balasan begitu baru) Seperti yang disebutkan orang lain, Arrays.asListmetode ini berukuran tetap, tetapi itu bukan satu-satunya masalah. Itu juga tidak menangani warisan dengan sangat baik. Misalnya, Anda memiliki yang berikut:

class A{}
class B extends A{}

public List<A> getAList(){
    return Arrays.asList(new B());
}

Hasil di atas dalam kesalahan kompiler, karena List<B>(yang dikembalikan oleh Arrays.asList) bukan subkelas List<A>, meskipun Anda bisa menambahkan Objek tipe B ke List<A>objek. Untuk menyiasati ini, Anda perlu melakukan sesuatu seperti:

new ArrayList<A>(Arrays.<A>asList(b1, b2, b3))

Ini mungkin cara terbaik untuk melakukan ini, esp. jika Anda memerlukan daftar tanpa batas atau perlu menggunakan warisan.

Anda dapat menggunakan pernyataan di bawah ini:

Cuplikan Kode:

String [] arr = {"Sharlock", "Homes", "Watson"};

List<String> names = Arrays.asList(arr);

Seperti yang Tom katakan :

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

Tetapi karena Anda mengeluh ingin ArrayList, Anda harus terlebih dahulu tahu bahwa ArrayList adalah subkelas Daftar dan Anda bisa menambahkan baris ini:

ArrayList<String> myPlaces = new ArrayList(places);

Meskipun, itu mungkin membuat Anda mengeluh tentang 'kinerja'.

Dalam hal itu tidak masuk akal bagi saya, mengapa, karena daftar Anda sudah ditentukan sebelumnya tidak didefinisikan sebagai array (karena ukurannya diketahui pada saat inisialisasi). Dan jika itu pilihan bagi Anda:

String[] places = {"Buenos Aires", "Córdoba", "La Plata"};

Jika Anda tidak peduli dengan perbedaan kinerja kecil maka Anda juga dapat menyalin array ke ArrayList dengan sangat sederhana:

ArrayList<String> myPlaces = new ArrayList(Arrays.asList(places));

Oke, tetapi di masa depan Anda perlu sedikit lebih dari sekadar nama tempat, Anda juga memerlukan kode negara. Dengan anggapan ini masih merupakan daftar yang telah ditentukan yang tidak akan pernah berubah selama waktu berjalan, maka pantas untuk menggunakan suatu enumset, yang akan membutuhkan kompilasi ulang jika daftar tersebut perlu diubah di masa mendatang.

enum Places {BUENOS_AIRES, CORDOBA, LA_PLATA}

akan menjadi:

enum Places {
    BUENOS_AIRES("Buenos Aires",123),
    CORDOBA("Córdoba",456),
    LA_PLATA("La Plata",789);

    String name;
    int code;
    Places(String name, int code) {
      this.name=name;
      this.code=code;
    }
}

Enum's memiliki valuesmetode statis yang mengembalikan array yang berisi semua nilai enum dalam urutan yang dideklarasikan, misalnya:

for (Places p:Places.values()) {
    System.out.printf("The place %s has code %d%n",
                  p.name, p.code);
}

Dalam hal ini saya kira Anda tidak perlu ArrayList Anda.

PS Randyaa mendemonstrasikan cara bagus lain menggunakan metode utilitas statis Collections.addAll .

Java 9 memiliki metode berikut untuk membuat daftar yang tidak dapat diubah :

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

yang mudah diadaptasi untuk membuat daftar yang bisa berubah, jika diperlukan:

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));

Metode serupa tersedia untuk Setdan Map.

List<String> names = Arrays.asList("2","@2234","21","11");

Ya dengan bantuan Array Anda dapat menginisialisasi daftar array dalam satu baris,

List<String> strlist= Arrays.asList("aaa", "bbb", "ccc");

Anda dapat menggunakan StickyListdari Cactoos :

List<String> names = new StickyList<>(
  "Scott Fitzgerald", "Fyodor Dostoyevsky"
);

Coba dengan baris kode ini:

Collections.singletonList(provider)

Di Jawa, Anda tidak bisa melakukannya

ArrayList<String> places = new ArrayList<String>( Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

Seperti yang telah ditunjukkan, Anda harus melakukan inisialisasi penjepit ganda:

List<String> places = new ArrayList<String>() {{ add("x"); add("y"); }};

Tetapi ini mungkin memaksa Anda untuk menambahkan anotasi @SuppressWarnings("serial")atau membuat UUID serial yang menjengkelkan. Juga sebagian besar pembuat kode akan membuka itu menjadi beberapa pernyataan / baris.

Atau Anda bisa melakukannya

List<String> places = Arrays.asList(new String[] {"x", "y" });

tapi kemudian Anda mungkin ingin melakukan @SuppressWarnings("unchecked").

Juga menurut javadoc Anda harus dapat melakukan ini:

List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

Tapi saya tidak bisa membuatnya untuk dikompilasi dengan JDK 1.6.

Collections.singletonList(messageBody)

Jika Anda perlu memiliki daftar satu item !

Koleksi adalah dari paket java.util .

Cara terbaik untuk melakukannya:

package main_package;

import java.util.ArrayList;


public class Stackkkk {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<Object>();
        add(list, "1", "2", "3", "4", "5", "6");
        System.out.println("I added " + list.size() + " element in one line");
    }

    public static void add(ArrayList<Object> list,Object...objects){
        for(Object object:objects)
            list.add(object);
    }
}

Cukup buat fungsi yang dapat memiliki elemen sebanyak yang Anda inginkan dan panggil untuk menambahkannya dalam satu baris.

Berikut ini kode dari AbacusUtil

// ArrayList
List<String> list = N.asList("Buenos Aires", "Córdoba", "La Plata");
// HashSet
Set<String> set = N.asSet("Buenos Aires", "Córdoba", "La Plata");
// HashMap
Map<String, Integer> map = N.asMap("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// Or for Immutable List/Set/Map
ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// The most efficient way, which is similar with Arrays.asList(...) in JDK. 
// but returns a flexible-size list backed by the specified array.
List<String> set = Array.asList("Buenos Aires", "Córdoba", "La Plata");

Deklarasi ： Saya pengembang AbacusUtil.

Bagi saya Arrays.asList () adalah yang terbaik dan nyaman. Saya selalu suka menginisialisasi seperti itu. Jika Anda seorang pemula dalam Koleksi Java maka saya ingin Anda merujuk inisialisasi ArrayList

Mengapa tidak membuat fungsi utilitas sederhana yang melakukan ini?

static <A> ArrayList<A> ll(A... a) {
  ArrayList l = new ArrayList(a.length);
  for (A x : a) l.add(x);
  return l;
}

" ll" singkatan dari "daftar literal".

ArrayList<String> places = ll("Buenos Aires", "Córdoba", "La Plata");

Menariknya tidak ada satu-liner dengan metode kelebihan beban lainnya Stream::collect terdaftar

ArrayList<String> places = Stream.of( "Buenos Aires", "Córdoba", "La Plata" ).collect( ArrayList::new, ArrayList::add, ArrayList::addAll );

Sebenarnya, dimungkinkan untuk melakukannya dalam satu baris:

Arrays.asList(new MyClass[] {new MyClass("arg1"), new MyClass("arg2")})