Eclipse集合簡介

1.概述

Eclipse Collections是另一個針對Java的改進的收集框架。

簡而言之，它提供了優化的實現以及核心Java中找不到的其他數據結構和功能。

該庫提供了所有數據結構的可變和不變的實現。

2. Maven依賴

首先，將以下Maven依賴項添加到pom.xml中：

<dependency

 <groupId>org.eclipse.collections</groupId>

 <artifactId>eclipse-collections</artifactId>

 <version>8.2.0</version>

 </dependency>

我們可以在Maven Central Repository中找到該庫的最新版本。

3.大局

3.1。基本集合類型

Eclipse集合中的基本集合類型為：

ListIterable –一個有序的集合，該集合保持插入順序並允許重複的元素。子接口包括： MutableList ， FixedSizeList和ImmutableList 。最常見的ListIterable實現是FastList，它是MutableList的子類。
SetIterable –不允許重複元素的集合。它可以排序或不排序。子接口包括： SortedSetIterable和UnsortedSetIterable。最常見的未排序SetIterable實現是UnifiedSet
MapIterable –鍵/值對的集合。子接口包括MutableMap ， FixedSizeMap和ImmutableMap 。兩種常見的實現是UnifiedMap和MutableSortedMap 。儘管UnifiedMap不保留任何順序，但MutableSortedMap保留元素的自然順序
BiMap –鍵/值對的集合，可以在任一方向上進行迭代。 BiMap擴展了MapIterable接口
袋–無序收集，允許重複。子接口包括MutableBag和**FixedSizeBag 。最常見的實現是HashBag
StackIterable –保持“**後進**先出”順序的集合，以相反的插入順序遍曆元素。子接口包括MutableStack和ImmutableStack
MultiMap –鍵/值對的集合，每個鍵允許多個值

3.2。原始集合

該框架還提供了大量的原始集合;它們的實現以它們持有的類型命名。每種類型都有可變，不變，同步和不可修改的形式：

原始列表
原始集
原始堆棧
原始袋
原始地圖
間隔時間

有大量的原始圖形式，涵蓋了原始鍵或對象鍵以及原始值或對象值的所有可能組合。

快速說明– IntInterval是可以使用步長值迭代的整數範圍。

4.實例化集合

要將元素添加到ArrayList或HashSet ，我們通過調用no-arg構造函數實例化一個集合，然後逐個添加每個元素。

儘管我們仍然可以在Eclipse Collections中做到這一點，但是我們還可以實例化一個Collection，並在同一行中同時提供所有初始元素。

讓我們看看如何實例化FastList ：

MutableList<String> list = FastList.newListWith(

 "Porsche", "Volkswagen", "Toyota", "Mercedes", "Toyota");

類似地，我們可以實例化UnifiedSet並通過將元素傳遞給newSetWith（）靜態方法來向其中添加元素：

Set<String> comparison = UnifiedSet.newSetWith(

 "Porsche", "Volkswagen", "Toyota", "Mercedes");

這是我們如何實例化HashBag的方法：

MutableBag<String> bag = HashBag.newBagWith(

 "Porsche", "Volkswagen", "Toyota", "Porsche", "Mercedes");

實例化地圖並向其添加鍵和值對是相似的。唯一的區別是，我們將鍵和值對作為對接口的實現傳遞給newMapWith（）方法。

讓我們以UnifiedMap為例：

Pair<Integer, String> pair1 = Tuples.pair(1, "One");

 Pair<Integer, String> pair2 = Tuples.pair(2, "Two");

 Pair<Integer, String> pair3 = Tuples.pair(3, "Three");



 UnifiedMap<Integer, String> map = new UnifiedMap<>(pair1, pair2, pair3);

我們仍然可以使用Java Collections API方法：

UnifiedMap<Integer, String> map = new UnifiedMap<>();



 map.put(1, "one");

 map.put(2, "two");

 map.put(3, "three");

由於不可變集合不能被修改，因此它們沒有修改集合的方法的實現，例如add（）和remove（） 。

但是，不可修改的集合允許我們調用這些方法，但是如果這樣做，則會拋出UnsupportedOperationException 。

5.從集合中檢索元素

就像使用標準Lists一樣，可以通過其索引檢索Eclipse Collections Lists的元素：

list.get(0);

並且可以使用其鍵檢索Eclipse Collections映射的值：

map.get(0);

getFirst（）和getLast（）方法可分別用於檢索列表的第一個和最後一個元素。對於其他集合，它們返回迭代器將返回的第一個和最後一個元素。

map.getFirst();

 map.getLast();

max（）和min（）方法可用於基於自然順序獲取集合的最大值和最小值。

map.max();

 map.min();

6.遍歷一個集合

Eclipse集合提供了許多遍歷集合的方法。讓我們看看它們是什麼以及它們在實踐中如何工作。

6.1。集合過濾

選擇模式返回一個新集合，其中包含滿足邏輯條件的集合元素。它本質上是一個過濾操作。

這是一個例子：

@Test

 public void givenListwhenSelect_thenCorrect() {

 MutableList<Integer> greaterThanThirty = list

 .select(Predicates.greaterThan(30))

 .sortThis();



 Assertions.assertThat(greaterThanThirty)

 .containsExactly(31, 38, 41);

 }

使用簡單的lambda表達式可以完成相同的操作：

return list.select(i -> i > 30)

 .sortThis();

拒絕模式則相反。它返回不滿足邏輯條件的所有元素的集合。

讓我們來看一個例子：

@Test

 public void whenReject_thenCorrect() {

 MutableList<Integer> notGreaterThanThirty = list

 .reject(Predicates.greaterThan(30))

 .sortThis();



 Assertions.assertThat(notGreaterThanThirty)

 .containsExactlyElementsOf(this.expectedList);

 }

在這裡，我們拒絕所有大於30的元素。

**6.2。 collect（）方法**

collect方法返回一個新的collection，其元素是所提供的lambda表達式返回的結果–本質上，它是Stream API中map（）和collect（）的組合。

讓我們看看它的作用：

@Test

 public void whenCollect_thenCorrect() {

 Student student1 = new Student("John", "Hopkins");

 Student student2 = new Student("George", "Adams");



 MutableList<Student> students = FastList

 .newListWith(student1, student2);



 MutableList<String> lastNames = students

 .collect(Student::getLastName);



 Assertions.assertThat(lastNames)

 .containsExactly("Hopkins", "Adams");

 }

創建的集合lastNames包含從學生列表中收集的姓氏。

但是，如果返回的集合是一個集合的集合，而我們又不想維護嵌套的結構，該怎麼辦？

例如，如果每個學生都有多個地址，並且我們需要一個包含以字符串形式的地址的集合，而不是一個集合，則可以使用flatCollect（）方法。

這是一個例子：

@Test

 public void whenFlatCollect_thenCorrect() {

 MutableList<String> addresses = students

 .flatCollect(Student::getAddresses);



 Assertions.assertThat(addresses)

 .containsExactlyElementsOf(this.expectedAddresses);

 }

6.3。元素檢測

detect方法查找並返回滿足邏輯條件的第一個元素。

讓我們來看一個簡單的例子：

@Test

 public void whenDetect_thenCorrect() {

 Integer result = list.detect(Predicates.greaterThan(30));



 Assertions.assertThat(result)

 .isEqualTo(41);

 }

anySatisfy方法確定集合的任何元素是否滿足邏輯條件。

這是一個例子：

@Test

 public void whenAnySatisfiesCondition_thenCorrect() {

 boolean result = list.anySatisfy(Predicates.greaterThan(30));



 assertTrue(result);

 }

同樣， allSatisfy方法確定集合的所有元素是否都滿足邏輯條件。

讓我們看一個簡單的例子：

@Test

 public void whenAnySatisfiesCondition_thenCorrect() {

 boolean result = list.allSatisfy(Predicates.greaterThan(0));



 assertTrue(result);

 }

**6.4。 partition（）方法**

分區方法根據一個元素是否滿足邏輯條件，將一個元素分配到兩個集合之一。

讓我們來看一個例子：

@Test

 public void whenAnySatisfiesCondition_thenCorrect() {

 MutableList<Integer> numbers = list;

 PartitionMutableList<Integer> partitionedFolks = numbers

 .partition(i -> i > 30);




 MutableList<Integer> greaterThanThirty = partitionedFolks

 .getSelected()

 .sortThis();

 MutableList<Integer> smallerThanThirty = partitionedFolks

 .getRejected()

 .sortThis();



 Assertions.assertThat(smallerThanThirty)

 .containsExactly(1, 5, 8, 17, 23);

 Assertions.assertThat(greaterThanThirty)

 .containsExactly(31, 38, 41);

 }

6.5。延遲迭代

惰性迭代是一種優化模式，其中調用了一種迭代方法，但是將其實際執行推遲到另一後續方法要求其動作或返回值之前。

@Test

 public void whenLazyIteration_thenCorrect() {

 Student student1 = new Student("John", "Hopkins");

 Student student2 = new Student("George", "Adams");

 Student student3 = new Student("Jennifer", "Rodriguez");



 MutableList<Student> students = Lists.mutable

 .with(student1, student2, student3);

 LazyIterable<Student> lazyStudents = students.asLazy();

 LazyIterable<String> lastNames = lazyStudents

 .collect(Student::getLastName);



 Assertions.assertThat(lastNames)

 .containsAll(Lists.mutable.with("Hopkins", "Adams", "Rodriguez"));

 }

在這裡， lazyStudents對像在調用collect（）方法之前不會檢索學生列表的元素。

7.配對收集元素

zip（）方法通過將兩個集合的元素組合為對來返回一個新的集合。如果兩個集合中的任何一個較長，則其餘元素將被截斷。

讓我們看看如何使用它：

@Test

 public void whenZip_thenCorrect() {

 MutableList<String> numbers = Lists.mutable

 .with("1", "2", "3", "Ignored");

 MutableList<String> cars = Lists.mutable

 .with("Porsche", "Volvo", "Toyota");

 MutableList<Pair<String, String>> pairs = numbers.zip(cars);



 Assertions.assertThat(pairs)

 .containsExactlyElementsOf(this.expectedPairs);

 }

我們還可以使用zipWithIndex（）方法將集合的元素與其索引配對：

@Test

 public void whenZip_thenCorrect() {

 MutableList<String> cars = FastList

 .newListWith("Porsche", "Volvo", "Toyota");

 MutableList<Pair<String, Integer>> pairs = cars.zipWithIndex();



 Assertions.assertThat(pairs)

 .containsExactlyElementsOf(this.expectedPairs);

 }

8.轉換集合

Eclipse Collections提供了將容器類型轉換為另一種類型的簡單方法。這些方法是toList（） ， toSet（） ， toBag（）和toMap（）。

讓我們看看如何使用它們：

public static List convertToList() {

 UnifiedSet<String> cars = new UnifiedSet<>();



 cars.add("Toyota");

 cars.add("Mercedes");

 cars.add("Volkswagen");



 return cars.toList();

 }

讓我們運行測試：

@Test

 public void whenConvertContainerToAnother_thenCorrect() {

 MutableList<String> cars = (MutableList) ConvertContainerToAnother

 .convertToList();



 Assertions.assertThat(cars)

 .containsExactlyElementsOf(

 FastList.newListWith("Volkswagen", "Toyota", "Mercedes"));

 }

9.結論

在本教程中，我們快速瀏覽了Eclipse Collections及其提供的功能。

可以在GitHub上獲得本教程的完整實現。

Lists列表

Sets

Maps

Queues隊列

Convert Collections

Collection操作

Apache Commons集合

Guava系列

其他集合

1.概述

2. Maven依賴

3.大局

3.1。基本集合類型

3.2。原始集合

4.實例化集合

5.從集合中檢索元素

6.遍歷一個集合

6.1。集合過濾

6.2。 collect（）方法

6.3。元素檢測

6.4。 partition（）方法

6.5。延遲迭代

7.配對收集元素

8.轉換集合

9.結論

**6.2。 collect（）方法**

**6.4。 partition（）方法**