removeIf 方法设计理念及泛型界限限定

🕗 发布于 2024-07-22 08:08 java

ArrayList 中的 removeIf 方法是 Java 8 中引入的集合操作方法之一。它使用了 Predicate 接口作为参数，以便根据指定的条件移除集合中的元素。以下是对 removeIf 方法入参设计的详细解释：

`Predicate` 接口

Predicate 是一个函数式接口，定义了一个 test 方法，用于接收一个参数并返回一个布尔值。它的签名如下：

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

Predicate 接口通常用于对输入参数进行条件测试。结合 removeIf 方法，这个接口被用来判断集合中的元素是否应该被移除。

`removeIf` 方法的签名

在 ArrayList 类中，removeIf 方法的签名如下：

public boolean removeIf(Predicate<? super E> filter)

其中，E 是集合的泛型类型参数，而 Predicate<? super E> 表示可以接受 E 类型或其父类型的参数。

设计理由

灵活性：使用 Predicate<? super E> 作为参数，使得 removeIf 方法可以接受针对元素类型及其父类型的条件。这种设计提供了更大的灵活性。例如，如果有一个 ArrayList<Number>，可以传入 Predicate<Object>，因为 Object 是 Number 的父类型。
函数式编程： Java 8 引入了函数式编程的概念，允许使用 lambda 表达式和方法引用。这使得编写条件测试的代码变得更加简洁和直观。例如，可以使用 lambda 表达式来移除所有负数：
```
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, -2, 3, -4, 5));
list.removeIf(n -> n < 0);
```
类型安全：泛型确保了 Predicate 的参数类型与集合元素类型一致，从而在编译时提供类型安全。这样可以避免传递错误类型的条件测试，导致运行时错误。

`removeIf` 方法的实现

removeIf 方法的内部实现使用了迭代器来遍历集合，并应用 Predicate 进行条件测试。以下是简化的实现：

public boolean removeIf(Predicate<? super E> filter) {
    Objects.requireNonNull(filter);
    boolean removed = false;
    final Iterator<E> each = iterator();
    while (each.hasNext()) {
        if (filter.test(each.next())) {
            each.remove();
            removed = true;
        }
    }
    return removed;
}

在这个实现中：

检查 filter 是否为 null。
使用迭代器遍历集合。
对每个元素应用 Predicate 进行测试。
如果 Predicate 返回 true，则移除该元素。

使用示例

以下是一些使用 removeIf 方法的示例：

移除负数

ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(1, -2, 3, -4, 5));
numbers.removeIf(n -> n < 0);
System.out.println(numbers); // 输出：[1, 3, 5]

移除空字符串

ArrayList<String> strings = new ArrayList<>(Arrays.asList("apple", "", "banana", " ", "cherry"));
strings.removeIf(String::isEmpty);
System.out.println(strings); // 输出：[apple,  , banana, cherry]

细品一下 removeIf() 方法入参设计

在 ArrayList 的 removeIf 方法中，使用 Predicate<? super E> 而不是 Predicate<E> 是为了增加方法的灵活性和通用性。具体来说，这与 Java 泛型的协变和逆变有关。以下是详细的解释：

泛型的协变和逆变

协变（Covariance）：允许使用某种类型及其子类型。用 <? extends E> 表示。
逆变（Contravariance）：允许使用某种类型及其超类型。用 <? super E> 表示。
不变（Invariance）：只能使用某种特定类型。用 <E> 表示。

在 removeIf 方法中，Predicate<? super E> 表示这个 Predicate 可以接受类型 E 或 E 的任何超类型。这是一种逆变，用于增加灵活性。

为什么使用 `<? super E>` 而不是 `<E>`

灵活性：使用 <? super E> 可以让 Predicate 接受类型 E 或 E 的父类型的对象，从而增加了方法的灵活性。例如，如果 E 是 Integer，那么 Predicate<? super Integer> 可以接受 Integer 及其父类 Number 和 Object 的 Predicate。

这意味着你可以传入更多种类的 Predicate，而不仅仅是严格匹配 E 的 Predicate。例如：
```
List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
Predicate<Object> isEven = obj -> obj instanceof Integer && (Integer) obj % 2 == 0;
list.removeIf(isEven); // 使用 Predicate<Object> 也可以
```
兼容性：假设你有一个处理父类 Number 的 Predicate，比如：
```
Predicate<Number> isPositive = num -> num.doubleValue() > 0;
```
这个 Predicate 可以传递给 ArrayList<Integer> 的 removeIf 方法，因为 Number 是 Integer 的超类型。如果 removeIf 方法只接受 Predicate<E>，那么你只能传入 Predicate<Integer>。
类型安全：使用 <? super E> 仍然确保了类型安全，因为在调用 removeIf 方法时，传入的 Predicate 需要能够处理类型 E。例如，对于 ArrayList<Integer>，传入的 Predicate 需要能够处理 Integer 及其超类型。

注意： ? 无界通配符主要用于不关心元素类型的操作，基本都是公共类操作。

例子

使用 `Predicate<E>`

如果 removeIf 只接受 Predicate<E>，那么只能传入 Predicate<Integer>：

List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
Predicate<Integer> isEven = n -> n % 2 == 0;
list.removeIf(isEven); // 正常工作

但是不能传入 Predicate<Number>：

Predicate<Number> isPositive = num -> num.doubleValue() > 0;
// list.removeIf(isPositive); // 编译错误

使用 `Predicate<? super E>`

使用 Predicate<? super E>，可以传入 Predicate<Integer> 或 Predicate<Number>：

List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
Predicate<Integer> isEven = n -> n % 2 == 0;
Predicate<Number> isPositive = num -> num.doubleValue() > 0;
list.removeIf(isEven); // 正常工作
list.removeIf(isPositive); // 也能正常工作

简而言之：

ArrayList 中 removeIf 方法使用 Predicate<? super E> 而不是 Predicate<E> 是为了增加方法的灵活性和通用性。通过允许传入类型 E 或其超类型的 Predicate，removeIf 方法变得更加通用和灵活，同时仍然保持类型安全。这样的设计使得在处理集合元素时，可以应用更多种类的条件，增加了代码的可重用性和灵活性。

再举例说明逆变的用法

逆变（Contravariance）在 Java 泛型中通过下界通配符（<? super T>）来实现。下界通配符允许使用某个类型及其父类型，这对于需要向集合中添加元素或处理泛型对象的写操作特别有用。以下是一些具体的例子来说明逆变的用法。

1. 使用逆变来添加元素到集合中

逆变可以确保能够向集合中添加类型 T 或 T 的子类型的元素。

例子 1：向集合中添加元素

import java.util.List;
import java.util.ArrayList;

public class CollectionUtils {
    public static void addAnimals(List<? super Dog> list) {
        list.add(new Dog());
        list.add(new Puppy());
        // list.add(new Animal()); // 编译错误，Animal 不是 Dog 的子类
    }

    public static void main(String[] args) {
        List<Animal> animalList = new ArrayList<>();
        addAnimals(animalList);

        for (Object obj : animalList) {
            System.out.println(obj.getClass().getSimpleName());
        }
    }
}

class Animal {}
class Dog extends Animal {}
class Puppy extends Dog {}

在这个例子中，addAnimals 方法接受一个 List<? super Dog> 类型的参数，这意味着它可以接受 Dog 类型及其超类型（如 Animal 和 Object）的列表，并向其中添加 Dog 及其子类型（如 Puppy）的元素。

2. 处理通用的数据结构

逆变可以用于处理具有多种元素类型的数据结构，比如在比较器中。

例子 2：使用逆变来编写通用比较器

import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class SortingUtils {
    public static <T> void sortList(List<T> list, Comparator<? super T> comparator) {
        Collections.sort(list, comparator);
    }

    public static void main(String[] args) {
        List<Integer> intList = new ArrayList<>();
        intList.add(3);
        intList.add(1);
        intList.add(4);
        intList.add(1);
        intList.add(5);
        
        Comparator<Number> numberComparator = (Number n1, Number n2) -> Double.compare(n1.doubleValue(), n2.doubleValue());
        sortList(intList, numberComparator);

        System.out.println(intList); // 输出: [1, 1, 3, 4, 5]
    }
}

在这个例子中，sortList 方法接受一个 Comparator<? super T> 类型的参数，这意味着它可以接受 T 类型及其超类型的比较器，从而使得比较器更加通用和灵活。

3. 使用逆变来编写通用的消费操作

逆变也可以用于消费操作，例如在处理不同类型的消费者时。

例子 3：使用逆变来编写通用的消费者

import java.util.List;
import java.util.ArrayList;
import java.util.function.Consumer;

public class ConsumerUtils {
    public static <T> void processElements(List<T> list, Consumer<? super T> consumer) {
        for (T element : list) {
            consumer.accept(element);
        }
    }

    public static void main(String[] args) {
        List<Dog> dogList = new ArrayList<>();
        dogList.add(new Dog());
        dogList.add(new Puppy());

        Consumer<Animal> animalConsumer = animal -> System.out.println(animal.getClass().getSimpleName());
        processElements(dogList, animalConsumer); // 输出: Dog Puppy
    }
}

class Animal {}
class Dog extends Animal {}
class Puppy extends Dog {}

在这个例子中，processElements 方法接受一个 Consumer<? super T> 类型的参数，这意味着它可以接受 T 类型及其超类型的消费者，从而使得消费者更加通用和灵活。

总结(添加、通用/公用、消费类型参数使用逆变)

逆变通过下界通配符（<? super T>）允许使用某个类型 T 及其父类型，主要用于写操作。使用逆变可以：

添加元素：确保可以向集合中添加类型 T 及其子类型的元素。
通用操作：处理具有多种元素类型的数据结构，使得操作更加灵活和通用。
消费操作：处理不同类型的消费者，使得消费者更加通用和灵活。

通过这些例子，可以看到逆变在编写通用和灵活的代码中发挥了重要作用，确保类型安全的同时增加了代码的灵活性。

原文地址：https://blog.csdn.net/qq_35971258/article/details/140592710

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：预测性营销与开源AI智能名片商城系统的融合创新：探索数据驱动的营销新纪元
下一篇：免费缺陷管理工具深度评测与使用心得

Java项目:校园宿舍管理系统(优质版)(Springboot3+Maven+Mybatis Plus+Vue3+ Element Plus+Mysql)
Springboot3+Maven+Mybatis Plus+Vue3+ Element Plus+Mysql 开发的前后端分离的校园宿舍管理系统。
阅读更多2024-11-16
IntelliJ IDEA新建项目或导入未识别为maven解决
1.首先，我的情况是我新建了一个springboot项目，然后选择类型是Maven但是建立后不是maven项目。当然，前提是你的maven已经在idea上做好配置了。2.打开项目后，从File --》
阅读更多2024-11-16
Gin HTML 模板渲染
Gin HTML模板入门
阅读更多2024-11-16
未来的车网互动如何重塑我们的城市生活
设想一下，在一个寒冷的冬日，你的车辆通过车网互动得知前方桥梁可能结冰，它会自动降低速度，并提醒你注意驾驶安全。公众的参与同样重要，只有当越来越多的车辆加入到车网互动系统中，才能真正发挥其潜力，提高整个
阅读更多2024-11-16
人工智能技术的应用前景及其对生活和工作方式的影响
人工智能技术的应用前景广阔，它不仅在医疗、企业和日常生活中带来了显著的变化，还将继续推动社会的创新和发展。面对 AI 技术带来的机遇和挑战，我们需要共同努力，确保技术的发展能够造福人类社会，创造一个更
阅读更多2024-11-16
《AI技术，让生活更简单》
想象一下，你回到家，灯自动亮了，空调调到你喜欢的温度，冰箱告诉你牛奶快没了，甚至还能帮你预约超市送货。这不是科幻电影，这就是AI技术正在做的事情。
阅读更多2024-11-16
sychronized锁
sychronized 关键字能成为锁的原因，是因为它提供了**内置锁（Intrinsic Lock）**机制，用于线程同步，确保同一时刻只有一个线程能够访问被标记为 synchronized 的代码
阅读更多2024-11-16
SpringBoot 2.2.10 无法执行Test单元测试
同样的Idea版本，现有的项目却可以执行，按照C老师的提示增加对junit5的引用支持，依然没有，StackOverflow上也是提示增加依赖，依赖加完之后执行报错一个 EnginListener N
阅读更多2024-11-16
springMVC 全局异常统一处理
进⾏异常处理，具有集成简单、有良好的扩展性、对已有代码没有⼊侵性等优点，但该⽅法仅能获取到异常信息，若在出现异常时，对需要获取除异常以外的数据的情况不适⽤。Unchecked Exception，⽽
阅读更多2024-11-16
thinkphp6配置多应用项目及多域名访问路由app配置
ThinkPHP 多应用模式初探
阅读更多2024-11-16