Pengantar Javatuple

1. Ikhtisar

Tupel adalah kumpulan beberapa elemen yang mungkin terkait atau tidak satu sama lain. Dengan kata lain, tupel dapat dianggap sebagai objek anonim.

Misalnya, ["RAM", 16, "Astra"] adalah tupel yang berisi tiga elemen.

Pada artikel ini, kita akan melihat sekilas perpustakaan yang sangat sederhana yang memungkinkan kita bekerja dengan struktur data berbasis tupel, bernama javatuples .

2. Kelas Javatuples bawaan

Library ini memberi kami sepuluh kelas berbeda yang akan mencukupi sebagian besar persyaratan terkait tupel:

  • Satuan
  • Pasangan
  • Tiga serangkai
  • Kuartet
  • Kwintet
  • Musik untuk enam orang
  • Septet
  • Oktet
  • Ennead
  • Dasawarsa

Selain kelas-kelas di atas, ada dua kelas tambahan, KeyValue dan LabelValue , yang menyediakan fungsionalitas yang mirip dengan Pair , tetapi berbeda dalam semantik.

Sesuai situs resmi, semua kelas di javatuple aman dan tidak dapat diubah . Setiap kelas tuple mengimplementasikan antarmuka Iterable , Serializable , dan Comparable .

3. Menambahkan Ketergantungan Maven

Mari tambahkan ketergantungan Maven ke pom.xml kita :

 org.javatuples javatuples 1.2 

Silakan periksa repositori Central Maven untuk versi terbaru.

4. Membuat Tupel

Membuat tupel sangat sederhana. Kita dapat menggunakan konstruktor yang sesuai:

Pair pair = new Pair("A pair", 55);

Ada juga cara yang tidak terlalu bertele-tele dan elegan secara semantik untuk membuat tupel:

Triplet triplet = Triplet.with("hello", 23, 1.2);

Kami juga dapat membuat tupel dari Iterable :

List listOfNames = Arrays.asList("john", "doe", "anne", "alex"); Quartet quartet = Quartet.fromCollection(collectionOfNames);

Harap dicatat bahwa jumlah item dalam koleksi harus sesuai dengan jenis tupel yang ingin kita buat . Misalnya, kita tidak dapat membuat Quintet menggunakan koleksi di atas karena membutuhkan tepat lima elemen. Hal yang sama juga berlaku untuk kelas tupel lain yang memiliki urutan lebih tinggi daripada Quintet .

Namun, kita bisa membuat tupel urutan rendah seperti Pair atau Triplet menggunakan koleksi di atas, dengan menentukan indeks awal dalam metode fromIterable () :

Pair pairFromList = Pair.fromIterable(listOfNames, 2);

Kode di atas akan menghasilkan Pair yang berisi " anne " dan " alex ".

Tupel juga dapat dibuat dengan mudah dari larik apa pun:

String[] names = new String[] {"john", "doe", "anne"}; Triplet triplet2 = Triplet.fromArray(names);

5. Mendapatkan Nilai dari Tuple

Setiap kelas di javatuples memiliki metode getValueX () untuk mendapatkan nilai dari tupel, di mana X menentukan urutan elemen di dalam tupel. Seperti indeks dalam array, nilai X dimulai dari nol.

Mari buat Kuartet baru dan ambil beberapa nilai:

Quartet quartet = Quartet.with("john", 72.5, 32, "1051 SW"); String name = quartet.getValue0(); Integer age = quartet.getValue2(); assertThat(name).isEqualTo("john"); assertThat(age).isEqualTo(32);

Seperti yang bisa kita lihat, posisi “ john ” adalah nol, “ 72,5 ” adalah satu, dan seterusnya.

Perhatikan bahwa metode getValueX () adalah tipe-aman. Artinya, tidak diperlukan casting.

Alternatif untuk ini adalah metode getValue (int pos) . Dibutuhkan posisi berbasis nol dari elemen yang akan diambil. Metode ini tidak aman untuk jenis dan membutuhkan transmisi eksplisit :

Quartet quartet = Quartet.with("john", 72.5, 32, "1051 SW"); String name = (String) quartet.getValue(0); Integer age = (Integer) quartet.getValue(2); assertThat(name).isEqualTo("john"); assertThat(age).isEqualTo(32);

Harap diperhatikan bahwa kelas KeyValue dan LabelValue memiliki metode yang sesuai getKey () / getValue () dan getLabel () / getValue () .

6. Mengatur Nilai ke Tuple

Mirip dengan getValueX () , semua kelas di javatuple memiliki metode setAtX () . Sekali lagi, X adalah posisi berbasis nol untuk elemen yang ingin kita atur:

Pair john = Pair.with("john", 32); Pair alex = john.setAt0("alex"); assertThat(john.toString()).isNotEqualTo(alex.toString());

Yang penting di sini adalah bahwa tipe kembalian metode setAtX () adalah tipe tupel itu sendiri. Ini karena javatuple tidak bisa diubah . Menyetel nilai baru apa pun akan membuat instance asli tetap utuh.

7. Menambah dan Menghapus Elemen dari Tuple

Kami dengan mudah dapat menambahkan elemen baru ke tupel. Namun, ini akan menghasilkan tupel baru dengan satu tatanan lebih tinggi yang dibuat:

Pair pair1 = Pair.with("john", 32); Triplet triplet1 = pair1.add("1051 SW"); assertThat(triplet1.contains("john")); assertThat(triplet1.contains(32)); assertThat(triplet1.contains("1051 SW"));

Jelas dari contoh di atas bahwa menambahkan satu elemen ke Pair akan membuat Triplet baru . Demikian pula, menambahkan satu elemen ke Triplet akan membuat Kuartet baru .

The example above also demonstrates the use of contains() method provided by all the classes in javatuples. This is a really handy method for verifying if the tuple contains a given value.

It is also possible to add one tuple to another using the add() method:

Pair pair1 = Pair.with("john", 32); Pair pair2 = Pair.with("alex", 45); Quartet quartet2 = pair1.add(pair2); assertThat(quartet2.containsAll(pair1)); assertThat(quartet2.containsAll(pair2));

Note the use of containsAll() method. It will return true if all the elements of pair1 are present in quartet2.

By default, the add() method adds the element as a last element of the tuple. However, it is possible to add the element at a given position using addAtX() method, where X is the zero-based position where we want to add the element:

Pair pair1 = Pair.with("john", 32); Triplet triplet2 = pair1.addAt1("1051 SW"); assertThat(triplet2.indexOf("john")).isEqualTo(0); assertThat(triplet2.indexOf("1051 SW")).isEqualTo(1); assertThat(triplet2.indexOf(32)).isEqualTo(2);

This example adds the String at position 1, which is then verified by the indexOf() method. Please note the difference in order of the types for the Pair and the Triplet after the call to addAt1() method call.

We can also add multiple elements using any of add() or addAtX() methods:

Pair pair1 = Pair.with("john", 32); Quartet quartet1 = pair1.add("alex", 45); assertThat(quartet1.containsAll("alex", "john", 32, 45));

In order to remove an element from the tuple, we can use the removeFromX() method. Again, X specifies the zero-based position of the element to be removed:

Pair pair1 = Pair.with("john", 32); Unit unit = pair1.removeFrom0(); assertThat(unit.contains(32));

8. Converting Tuples to List/Array

We have already seen how to convert a List to a tuple. Let's now see hot to convert a tuple to a List:

Quartet quartet = Quartet.with("john", 72.5, 32, "1051 SW"); List list = quartet.toList(); assertThat(list.size()).isEqualTo(4);

It is fairly simple. The only thing to note here is that we will always get a List, even if the tuple contains the same type of elements.

Finally, let's convert the tuple to an array:

Quartet quartet = Quartet.with("john", 72.5, 32, "1051 SW"); Object[] array = quartet.toArray(); assertThat(array.length).isEqualTo(4);

Clear enough, the toArray() method always returns an Object[].

9. Conclusion

Pada artikel ini, kami telah menjelajahi perpustakaan javatuples dan mengamati kesederhanaannya. Ini memberikan semantik yang elegan dan sangat mudah digunakan.

Pastikan Anda memeriksa kode sumber lengkap untuk artikel ini di GitHub. Kode sumber lengkap berisi lebih banyak contoh daripada yang dibahas di sini. Setelah membaca artikel ini, contoh tambahan seharusnya cukup mudah dipahami.