Question

有两种方法，它们的功能完全相同，只是对象类型不同...有没有一种方法可以只用一种方法编写这种方法，并将它们组合为1。

方法1：

private List<Car> removeSameColor(List<Car> list) {
        Set<String> colorSet = new HashSet<>();
        Iterator<Car> iterator = list.iterator();
        while (iterator.hasNext()) {
            if(!colorSet .isEmpty() && colorSet .contains(iterator.next().getColor())) {
                iterator.remove();
            }
            else{
                colorSet.add(iterator.next().getColor());
            }
        }
        return list;
    }

这是第二种方法：

   private List<Computer> removeSameColor2(List<Computer> list) {
            Set<String> colorSet = new HashSet<>();
            Iterator<Computer> iterator = list.iterator();
            while (iterator.hasNext()) {
                if(!colorSet .isEmpty() && colorSet .contains(iterator.next().getColor())) {
                    iterator.remove();
                }
                else{
                    colorSet.add(iterator.next().getColor());
                }
            }
            return list;
        }

Answer 1

如果Car和Computer类尚未实现公共接口，并且您需要在不修改类的情况下执行此操作，则可以传递一个附加参数，即提取{来自列表元素的{1}}：

String

并像这样调用：

private <T> List<T> removeSameColor(List<T> list, Function<? super T, String> fn) {
    Set<String> colorSet = new HashSet<>();
    Iterator<T> iterator = list.iterator();
    while (iterator.hasNext()) {
        if(!colorSet .isEmpty() && colorSet .contains(fn.apply(iterator.next()))) {
            iterator.remove();
        }
        else{
            colorSet.add(fn.apply(iterator.next()));
        }
    }
    return list;
}

请注意，您在循环正文中两次调用removeSameColor(listOfCars, Car::getColour); removeSameColor(listOfComputers, Computer::getColour);。您可能希望将其存储在变量中：

iterator.next()

实际上，您可以简单地存储T value = iterator.next(); if (!colorSet.isEmpty() && colorSet.contains(fn.apply(value))) { iterator.remove(); } else { colorSet.add(fn.apply(value)); }，然后用它代替String color = fn.apply(iterator.next())。

然后您可以利用fn.apply(value)的返回值来进一步简化循环：

Set.add

Answer 2

private <T extends HasColor> List<T> removeSameColor(List<T> list) {
        Set<String> colorSet = new HashSet<>();
        Iterator<T> iterator = list.iterator();
        while (iterator.hasNext()) {
            if(!colorSet .isEmpty() && colorSet .contains(iterator.next().getColor())) {
                iterator.remove();
            }
            else{
                colorSet.add(iterator.next().getColor());
            }
        }
        return list;
    }

然后使Computer和Car都实现一个新接口HasColor：

interface HasColor {
    String getColor();
}

如果您使用的是Java 8或更高版本，则有一个更简单的选择：

Set<String> seen = ConcurrentHashMap.newKeySet();
return list.stream()
    .filter(t -> seen.add(t.getColor()))
    .collect(Collectors.toList());

这将根据每个列表项颜色的不同性对列表进行重复数据删除。

Answer 3

似乎Car和Computer都有getColor()方法。因此，将其拉入接口很有意义：

interface Colored {
    Color getColor();
}

并使Car和Computer都实现Colored。然后，您可以将一种方法编写为

private <T extends Colored> List<T> removeSameColor(List<T> list) {
        Set<String> colorSet = new HashSet<>();
        Iterator<T> iterator = list.iterator();
        while (iterator.hasNext()) {
            if(!colorSet .isEmpty() && colorSet .contains(iterator.next().getColor())) {
                iterator.remove();
            }
            else{
                colorSet.add(iterator.next().getColor());
            }
        }
        return list;
    }

有一种方法可以用一种方法来代替两种方法吗？

3 个答案: