Giới thiệu về Javatuples

1. Khái quát chung

Bộ tuple là một tập hợp của một số phần tử có thể có hoặc không liên quan đến nhau. Nói cách khác, bộ giá trị có thể được coi là đối tượng ẩn danh.

Ví dụ: [“RAM”, 16, “Astra”] là một bộ chứa ba phần tử.

Trong bài này, chúng ta sẽ tìm hiểu sơ qua về một thư viện thực sự đơn giản cho phép chúng ta làm việc với các cấu trúc dữ liệu dựa trên tuple, có tên là javatuples .

2. Các lớp Javatuples tích hợp

Thư viện này cung cấp cho chúng ta mười lớp khác nhau đáp ứng hầu hết các yêu cầu của chúng ta liên quan đến bộ giá trị:

  • Đơn vị
  • Đôi
  • Bộ ba
  • Bộ tứ
  • Bộ tứ
  • Sextet
  • Septet
  • Octet
  • Ennead
  • Thập kỷ

Ngoài các lớp ở trên, có hai lớp bổ sung, KeyValueLabelValue , cung cấp các chức năng tương tự như Pair , nhưng khác nhau về ngữ nghĩa.

Theo trang web chính thức, tất cả các lớp trong javatuples là loại an toàn và bất biến . Mỗi phòng trong số dụng cụ lớp tuple các Iterable , Serializable , và tương đương giao diện.

3. Thêm phụ thuộc Maven

Hãy thêm phần phụ thuộc Maven vào pom.xml của chúng tôi :

 org.javatuples javatuples 1.2 

Vui lòng kiểm tra kho lưu trữ Central Maven để biết phiên bản mới nhất.

4. Tạo Tuples

Tạo một tuple thực sự đơn giản. Chúng ta có thể sử dụng các hàm tạo tương ứng:

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

Ngoài ra còn có một cách ít dài dòng hơn một chút và thanh lịch về mặt ngữ nghĩa để tạo một bộ tuple:

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

Chúng ta cũng có thể tạo các bộ giá trị từ một Lặp lại :

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

Xin lưu ý rằng số lượng mục trong bộ sưu tập phải phù hợp với loại bộ tuple mà chúng tôi muốn tạo . Ví dụ: chúng tôi không thể tạo Quintet bằng cách sử dụng bộ sưu tập trên vì nó yêu cầu chính xác năm phần tử. Điều tương tự cũng đúng với bất kỳ lớp tuple nào khác có thứ tự cao hơn Quintet .

Tuy nhiên, chúng ta có thể tạo một bộ giá trị thấp hơn như Cặp hoặc Bộ ba bằng cách sử dụng bộ sưu tập ở trên, bằng cách chỉ định chỉ mục bắt đầu trong phương thức fromIterable () :

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

Đoạn mã trên sẽ dẫn đến việc tạo một Cặp chứa “ anne ” và “ alex ”.

Tuples cũng có thể được tạo thuận tiện từ bất kỳ mảng nào:

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

5. Nhận Giá trị từ Tuples

Mọi lớp trong javatuples đều có phương thức getValueX () để lấy các giá trị từ các bộ giá trị, trong đó X chỉ định thứ tự của phần tử bên trong bộ giá trị. Giống như các chỉ mục trong mảng, giá trị của X bắt đầu từ 0.

Hãy tạo một Bộ tứ mới và tìm nạp một số giá trị:

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

Như chúng ta có thể thấy, vị trí của " john " là 0, " 72,5 " là một, v.v.

Note that the getValueX() methods are type-safe. That means, no casting is required.

An alternative to this is the getValue(int pos) method. It takes a zero-based position of the element to be fetched. This method is not type-safe and requires explicit casting:

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

Please note that the classes KeyValue and LabelValue have their corresponding methods getKey()/getValue() and getLabel()/getValue().

6. Setting Values to Tuples

Similar to getValueX(), all classes in javatuples have setAtX() methods. Again, X is zero-based positions for the element that we want to set:

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

The important thing here is that the return type of setAtX() method is the tuple type itself. This is because the javatuples are immutable. Setting any new value will leave the original instance intact.

7. Adding and Removing Elements from Tuples

We can conveniently add new elements to the tuples. However, this will result in a new tuple of one order higher being created:

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"));

It is clear from the above example that adding one element to a Pair will create a new Triplet. Similarly, adding one element to a Triplet will create a new Quartet.

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

Trong bài viết này, chúng tôi đã khám phá thư viện javatuples và nhận thấy nó đơn giản. Nó cung cấp ngữ nghĩa trang nhã và thực sự dễ sử dụng.

Đảm bảo rằng bạn đã xem mã nguồn hoàn chỉnh cho bài viết này trên GitHub. Mã nguồn hoàn chỉnh chứa nhiều ví dụ hơn những ví dụ được đề cập ở đây. Sau khi đọc bài viết này, các ví dụ bổ sung phải đủ dễ hiểu.