集合操作中的元素比较器设计

在集合操作中，元素比较器是一个关键组件，用于确定两个或多个元素之间的关系。以下是一个元素比较器的设计示例，该示例适用于多种数据类型和集合操作场景：

1. 比较器接口

首先，定义一个比较器接口，该接口包含用于比较元素的方法。

public interface ElementComparator<T> {
    int compare(T o1, T o2);
}

2. 基本比较器实现

为常见数据类型提供基本的比较器实现。

数字比较器

public class NumericComparator implements ElementComparator<Number> {
    @Override
    public int compare(Number n1, Number n2) {
        if (n1 instanceof Integer && n2 instanceof Integer) {
            return Integer.compare(n1.intValue(), n2.intValue());
        } else if (n1 instanceof Double || n2 instanceof Double) {
            return Double.compare(n1.doubleValue(), n2.doubleValue());
        } else if (n1 instanceof Float || n2 instanceof Float) {
            return Float.compare(n1.floatValue(), n2.floatValue());
        } else if (n1 instanceof Long || n2 instanceof Long) {
            return Long.compare(n1.longValue(), n2.longValue());
        }
        throw new IllegalArgumentException("Unsupported number type");
    }
}

字符串比较器

public class StringComparator implements ElementComparator<String> {
    @Override
    public int compare(String s1, String s2) {
        return s1.compareTo(s2);
    }
}

日期比较器

import java.util.Date;

public class DateComparator implements ElementComparator<Date> {
    @Override
    public int compare(Date d1, Date d2) {
        return d1.compareTo(d2);
    }
}

3. 自定义对象比较器

对于自定义对象，可以实现 ElementComparator 接口并提供具体的比较逻辑。

public class CustomObjectComparator<T> implements ElementComparator<T> {
    private final Comparator<T> comparator;

    public CustomObjectComparator(Comparator<T> comparator) {
        this.comparator = comparator;
    }

    @Override
    public int compare(T o1, T o2) {
        return comparator.compare(o1, o2);
    }
}

4. 集合操作示例

使用上述比较器进行集合操作。

示例：查找重复元素

import java.util.*;

public class DuplicateFinder {
    public static <T> List<T> findDuplicates(Collection<T> collection, ElementComparator<T> comparator) {
        Map<T, Integer> frequencyMap = new HashMap<>();
        for (T element : collection) {
            frequencyMap.put(element, frequencyMap.getOrDefault(element, 0) + 1);
        }
        List<T> duplicates = new ArrayList<>();
        for (Map.Entry<T, Integer> entry : frequencyMap.entrySet()) {
            if (entry.getValue() > 1) {
                duplicates.add(entry.getKey());
            }
        }
        return duplicates;
    }

    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 2, 3, 6, 7, 8, 9, 9);
        ElementComparator<Integer> numberComparator = new NumericComparator();
        List<Integer> duplicates = findDuplicates(numbers, numberComparator);
        System.out.println("Duplicates: " + duplicates);
    }
}

5. 总结

通过上述设计，可以灵活地为不同类型的元素实现比较器，并在集合操作中使用这些比较器。这种设计不仅提高了代码的可重用性，还增强了系统的扩展性。