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 –一個有序的集合,該集合保持插入順序並允許重複的元素。子接口包括: MutableListFixedSizeListImmutableList 。最常見的ListIterable實現是FastList,它是MutableList的子類。
  • SetIterable –不允許重複元素的集合。它可以排序或不排序。子接口包括: SortedSetIterableUnsortedSetIterable。最常見的未排序SetIterable實現是UnifiedSet
  • MapIterable –鍵/值對的集合。子接口包括MutableMapFixedSizeMapImmutableMap 。兩種常見的實現是UnifiedMapMutableSortedMap 。儘管UnifiedMap不保留任何順序,但MutableSortedMap保留元素的自然順序
  • BiMap –鍵/值對的集合,可以在任一方向上進行迭代。 BiMap擴展了MapIterable接口
  • –無序收集,允許重複。子接口包括MutableBag和**FixedSizeBag 。最常見的實現是HashBag
  • StackIterable –保持“**後進**先出”順序的集合,以相反的插入順序遍曆元素。子接口包括MutableStackImmutableStack
  • MultiMap –鍵/值對的集合,每個鍵允許多個值

3.2。原始集合

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

  • 原始列表
  • 原始
  • 原始堆棧
  • 原始
  • 原始地圖
  • 間隔時間

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

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

4.實例化集合

要將元素添加到ArrayListHashSet ,我們通過調用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上獲得本教程的完整實現。

0 條評論,你可以發表評論,我們會進行改進
Comment author placeholder