Question

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = Integer.parseInt(scanner.nextLine());
        Box<String> box = null;
        List<Box> boxes = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            box = new Box<>(scanner.nextLine());
            boxes.add(box);
        }
        box = new Box<>(scanner.nextLine());
        Box.count(boxes, box);
    }

我在这里创建框，我将它们传递给框类

中的静态方法

public class Box<T> {
    private T name;

    public Box(T name) {
        this.name = name;
    }

    public static <E> int count(List<E> list, E compeer) {
        int counter = 0;
        for (E el : list) {
            if (el.compearTo(compeer) < 0) { // ofc it doesnt works compearTo is red caus i am not extending Comperable
                counter++;
            }
        }
        return counter;
    }
}

在盒子计数方法中，我必须计算有多少元素是＆＃34;更低＆＃34;然后是方法的第二个参数，但是我无法在那里进行任何操作...我知道Generic类型必须扩展Comperable <E extends Comparable>才能实现，但是如果我在<E extends Comparable>中输入Box.count {1}}方法然后我不能传递参数。

Answer 1

但如果我在Box.count方法中输入<E extends Comparable>，那么我就无法传递参数。

您无法传递参数的原因是Box未实现Comparable。

您应该做的是在Box类中添加泛型约束：

class Box<T extends Comparable<T>> { ... }

此外，您的count方法有点太泛型。如果将compeer的类型更改为Box<T>并将list更改为List<Box<T>>，则可能更有意义。

方法签名现在如下所示：

public static <T extends Comparable<T>> int count(List<Box<T>> list, Box<T> compeer) {

你可以实现这样的方法：

return (int)list.stream().
    filter(x -> x.name.compareTo(compeer.name) < 0).count();

Answer 2

Box不需要是泛型类，因为您只根据对静态方法的调用而不是根据类使用特定类型。
指定它是误导你在Box构造函数中传递一个字符串，所以提供一个String参数似乎更精细。

在盒子计数方法中，我必须计算有多少元素是“更低” 然后是方法的第二个参数。

然后在静态方法中使用E类型声明继承Comparable，以便能够比较List之间的每个元素。
Box也应该实现Comparable，这很好。

所以你可以用这种方式比较元素。如果传递的元素高于当前迭代元素，则递增计数器：

 if (compeer.compareTo(currentElement)>1){
    counter++;
 }

它可以给出：

public class Box implements Comparable<Box> {

    private String name;

    public Box(String name) {
        this.name = name;
    }

    @Override
    public int compareTo(Box o) {
          /// your rule to compare Box elements
    }

    public static <E extends Comparable<E>> int count(List<E> list, E compeer) {
        int counter = 0;

        if (compeer==null){
            return 0;
        }
        for (E currentElement : list){
            if (compeer.compareTo(currentElement)==1){
               counter++;
            }
        }
        return counter;
    }
}

将集合中的泛型类型与相同类型的java进行比较

2 个答案: