3.编写一个泛型方法，用于对一个 List 中的元素进行过滤，只保留满足指定条件的元素。 public static <T> List<T> filter(List<T> list, Predicate<T> predicate) ;

可以使用 Java 8 的 Stream API 来实现这个泛型方法，代码如下：

public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
return list.stream().filter(predicate).collect(Collectors.toList());
}

这个方法接受一个 List 和一个 Predicate，返回一个新的 List，其中只包含满足 Predicate 条件的元素。使用 Stream API 的 filter 方法可以很方便地实现这个功能。

相关问题

使用冒泡排序编写两个泛型方法

好的，以下是使用冒泡排序实现的两个泛型方法：

1. 对数组进行排序

public static <T extends Comparable<T>> void bubbleSort(T[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j].compareTo(arr[j + 1]) > 0) {
                T temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

此方法接收一个泛型数组，并使用冒泡排序对其进行排序。

2. 对列表进行排序

public static <T extends Comparable<T>> void bubbleSort(List<T> list) {
    int n = list.size();
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (list.get(j).compareTo(list.get(j + 1)) > 0) {
                T temp = list.get(j);
                list.set(j, list.get(j + 1));
                list.set(j + 1, temp);
            }
        }
    }
}

此方法接收一个泛型列表，并使用冒泡排序对其进行排序。注意，这里使用了 `list.get()` 和 `list.set()` 方法来获取和设置列表中的元素。

19.4（泛型线性搜索）为线性搜索实现以下泛型方法。 public static <E extends Comparáble<E>> int 1inearSearch(E[] list, E key)

19.4版本的泛型线性搜索是一个通用的方法，它接受一个实现了`Comparable`接口的元素数组`E[]`和一个同样类型的键值`E key`作为输入。这个方法的目标是在给定的列表中查找指定的键值，并返回键值在数组中的索引位置，如果键值存在；如果没有找到，则返回`-1`表示未找到。

以下是该泛型方法的基本实现：

public static <E extends Comparable<E>> int linearSearch(E[] list, E key) {
    for (int i = 0; i < list.length; i++) {
        if (list[i].equals(key)) { // 使用Comparable接口的equals()方法比较
            return i;
        }
    }
    return -1; // 如果遍历完整个列表都没有找到，返回-1
}

在这个方法中，`Comparable<E>`使得`list[i]`可以自动进行自相比较，因为数组元素都是同一种类型并且实现了`Comparable`接口。如果列表中有相同的键值，方法会立即返回对应的索引；如果没有找到，则遍历结束后返回 `-1`。