Java 是否有一种方法可以代替两种方法？

有两种方法可以做完全相同的事情，只是对象类型不同。。。有没有一种方法可以只写一个方法，把它们组合成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;
        }

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

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

这将根据每个列表项颜色的不同程度消除列表中的重复数据

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

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

这将根据每个列表项颜色的不同程度来消除列表中的重复数据。

似乎汽车和计算机都有一个getColor方法。因此，将其拉入接口是有意义的：

interface Colored {
    Color getColor();
}

并使汽车和电脑都实现彩色化。 然后您可以将您的一个方法编写为

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;
    }

似乎汽车和计算机都有一个getColor方法。因此，将其拉入接口是有意义的：

interface Colored {
    Color getColor();
}

并使汽车和电脑都实现彩色化。 然后您可以将您的一个方法编写为

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;
    }

如果Car和Computer类尚未实现公共接口，并且您需要在不修改类的情况下执行此操作，则可以传递附加参数，即从列表元素中提取字符串的函数：

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;
}

请注意，您在循环体中调用了两次iterator.next。您可能希望将其存储在变量中：

T value = iterator.next();
if (!colorSet.isEmpty() && colorSet.contains(fn.apply(value))) {
  iterator.remove();
} else {
  colorSet.add(fn.apply(value));
}

实际上，您可以简单地存储字符串color=fn.applyiterator.next，然后用它代替fn.applyvalue

然后，通过利用Set.add的返回值，可以进一步简化循环：

如果Car和Computer类尚未实现公共接口，并且您需要在不修改类的情况下执行此操作，则可以传递附加参数，即从列表元素中提取字符串的函数：

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;
}

请注意，您在循环体中调用了两次iterator.next。您可能希望将其存储在变量中：

T value = iterator.next();
if (!colorSet.isEmpty() && colorSet.contains(fn.apply(value))) {
  iterator.remove();
} else {
  colorSet.add(fn.apply(value));
}

实际上，您可以简单地存储字符串color=fn.applyiterator.next，然后用它代替fn.applyvalue

然后，通过利用Set.add的返回值，可以进一步简化循环：

---

---

如果您想要的话，可以用一个方法编写整个应用程序。这并不意味着它改进了代码，thoughIntelliJ告诉dublicate这两种方法的发现：但是对象类型是不同的，所以我不知道如何组合它们。如果你的计算机和汽车有一个共同的基本类型，如接口，那么你可以对这两种方法使用相同的方法，你的方法有一个bug调用迭代器。在循环的同一个迭代中，下两次是错误的。@a.solak Car extensed Computer？？？？这毫无意义。如果您想要的话，您可以用一个方法编写整个应用程序。这并不意味着它改进了代码，thoughIntelliJ告诉dublicate这两种方法的发现：但是对象类型是不同的，所以我不知道如何组合它们。如果你的计算机和汽车有一个共同的基本类型，如接口，那么你可以对这两种方法使用相同的方法，你的方法有一个bug调用迭代器。在循环的同一个迭代中，下两次是错误的。@a.solak Car extensed Computer？？？？这完全没有道理。非常感谢，这就是我要找的！！！只有一件事，使用迭代器。接下来的2次给出了错误，所以我把它赋给了一个变量：非常感谢，这就是我要找的！！！只有一件事，使用iterator.next 2 times给出了错误，所以我把它赋给了一个变量：这是一个更简单的选择：它不是，因为它至少在两个方面做不到相同的事情。首先，这是在看实例的平等性，而不是颜色的平等性；没有任何迹象表明equals/hashCode被重写，也没有表明它们考虑了颜色。其次，OP的代码更新列表参数，而不是返回一个具有正确值的新列表。流中可以使用有状态过滤器来过滤重复的颜色。重新。关于更新列表参数的第二点-尽管您完全正确，但考虑到该方法返回自己的输入参数，没有什么可以阻止您重新分配列表。。。e、 g.列表=移除SameColorList；这可能已经是它的使用方式了，因为该方法不仅仅返回void。流中可以使用有状态过滤器，因为它需要一个无状态谓词。这适用于并行流-顺序流本质上是确定性的。给定OP要求返回一个列表的方法，该列表由每个给定颜色遇到的“第一个”项组成，并行性在这里是不存在的。如果他尝试并行for循环，他会遇到同样的问题，因为他所做的操作本质上依赖于排序。这是一个更简单的选择：它不是，因为它至少在两种方式上做不到相同的事情。首先，这是在考虑实例的平等性，而不是

---

颜色的均匀性；没有任何迹象表明equals/hashCode被重写，也没有表明它们考虑了颜色。其次，OP的代码更新列表参数，而不是返回一个具有正确值的新列表。流中可以使用有状态过滤器来过滤重复的颜色。重新。关于更新列表参数的第二点-尽管您完全正确，但考虑到该方法返回自己的输入参数，没有什么可以阻止您重新分配列表。。。e、 g.列表=移除SameColorList；这可能已经是它的使用方式了，因为该方法不仅仅返回void。流中可以使用有状态过滤器，因为它需要一个无状态谓词。这适用于并行流-顺序流本质上是确定性的。给定OP要求返回一个列表的方法，该列表由每个给定颜色遇到的“第一个”项组成，并行性在这里是不存在的。如果他尝试并行for循环，他会遇到同样的问题，因为他所做的操作本质上依赖于排序。