十二、集合操作

1. FluentIterable

FluentIterable 流迭代器早于JDK8的stream产生，提了了一些集合类的过滤、转换等相关操作。在JDK8之前使用比较多，JDK8之后推荐使用JDK的stream相关操作。FluentIterable的相关操作可以作为了解。

package org.example.model.guava;

import com.google.common.base.Optional;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableList;
import org.assertj.core.util.Lists;
import org.junit.Test;

import java.util.ArrayList;

import static org.assertj.core.api.Assertions.assertThat;

public class FluentIterableTest {
    @Test
    public void test1() {
        ArrayList<String> strings = Lists.newArrayList("A", "B", "C", "DDD");
        FluentIterable<String> fit = FluentIterable.from(strings);
        assertThat(fit.size()).isEqualTo(4); // size操作不建议使用，可以需要遍历计算长度

        // filter
        FluentIterable<String> filter = fit.filter(e -> e != null && e.length() > 2);
        assertThat(filter.size()).isEqualTo(1);
        assertThat(strings).size().isEqualTo(4); // filter操作不会影响原始列表
        assertThat(fit.size()).isEqualTo(4); // filter为新对象，不影响旧的fit
        assertThat(fit.contains("A")).isTrue();


        // 使用append添加元素，产生新的FluentIterable
        FluentIterable<String> append = fit.append("E");
        assertThat(append.size()).isEqualTo(5);
        assertThat(append.contains("E")).isTrue();
        assertThat(fit.size()).isEqualTo(4); // 不影响旧的fit
        assertThat(strings).size().isEqualTo(4); // 不影响原始list
    }

    @Test
    public void test2() {
        ArrayList<String> strings = Lists.newArrayList("A", "B", "C", "DDD");
        FluentIterable<String> fit = FluentIterable.from(strings);
        assertThat(fit.size()).isEqualTo(4); // size操作不建议使用，可以需要遍历计算长度

        assertThat(fit.allMatch(e -> e.equals("A"))).isFalse();
        assertThat(fit.allMatch(e -> e.equals("B"))).isFalse();

        Optional<String> firstMatch = fit.firstMatch(e -> e.equals("B"));
        assertThat(firstMatch.isPresent()).isTrue(); // 注意这里guava的Optional

        Optional<String> first = fit.first();
        assertThat(first.isPresent()).isTrue(); // 注意这里guava的Optional

        Optional<String> last = fit.last();
        assertThat(last.isPresent()).isTrue(); // 注意这里guava的Optional

        FluentIterable<String> limit = fit.limit(3);
        assertThat(fit.size()).isEqualTo(4); // limit会创建新的FluentIterable
        limit.forEach(System.out::print); // ABC

        // toList，toMap转换为list和map
        ImmutableList<String> list = fit.toList();

        ArrayList<String> list2 = Lists.newArrayList("F");
        fit.copyInto(list2); // 将数据拷贝到list2
        System.out.println(list2); // [F, A, B, C, DDD]

        // 转换
        System.out.println(fit.transform(String::length).toList()); // [1, 1, 1, 3]
    }
}

2. Lists

import com.google.common.collect.Lists;
import org.junit.Test;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * 功能描述
 *
 * @author q00811349
 * @since 2023-09-12
 */
public class ListsTest {
    @Test
    public void test1() {
        // 笛卡尔乘积
        List<List<String>> lists = Lists.cartesianProduct(Lists.newArrayList("1", "2"), Lists.newArrayList("A", "B"));
        System.out.println(lists); // [[1, A], [1, B], [2, A], [2, B]]

        // 转换
        ArrayList<String> strings = Lists.newArrayList("A", "B", "C");
        List<String> transform = Lists.transform(strings, String::toLowerCase); // 入参不能为空
        System.out.println(transform); // [a, b, c]

        // 反转
        System.out.println(Lists.reverse(strings)); // [C, B, A]

        // 拆分遍历
        System.out.println(Lists.partition(strings, 2)); // [[A, B], [C]]

        // 创建一个LinkedList, 支持创建空的和使用迭代器创建，不支持使用给定元素创建
        LinkedList<String> linkedList = Lists.newLinkedList(strings);
        System.out.println(linkedList); //  [A, B, C]
        
        // 创建copyOnWriteArrayList, 高并发读多写少场景使用
        CopyOnWriteArrayList<String> copyOnWriteArrayList = Lists.newCopyOnWriteArrayList(linkedList);
        System.out.println(copyOnWriteArrayList); //  [A, B, C]
    }
}