Question

因此，该程序试图采用如下命令行参数：

S 4 1 2 3 4 4

args[0]是数组类型

args[1]是数组长度

args[2...]是数组中的值

args[length-1]是将在线性搜索中使用的密钥

public class whatTheFoo{

    @SuppressWarnings({ "unchecked", "rawtypes" })
    public static <E> void main(String[] args) {

        for(int i=0;i<args.length;i++)System.out.print(args[i]);
        System.out.println();

        int arraySize = Integer.parseInt(args[1]);
        E[] array = (E[])new Object[arraySize];
        E key = null;

        if (args[0].matches("I|i")) {
            for (int i = 2; i < args.length-1; i++) {
                array[i-2]=(E)new Integer(args[i]);
                System.out.println(array[i-2]);
            }
            key = (E) new Integer(args[args.length-1]);
            System.out.println("Key is: " + key);
        } 

    ...

        if(linearSearch(array, key)<0)
            System.out.println("Didnt find it");
        else 
            System.out.println("Found it at index: "+(linearSearch(array, key)-1));
    }

    public static <E> int linearSearch(E[]array,E key) {
        int index=-1;
        for(int i=0;i<array.length;i++) {
            if(array[i].equals(key)){
                index = (int) array[i];
            }
        }
        return index;
    }
}

这有效，但当我将linearSearch方法更改为：

时

public static <E extends Comparable<E>> int linearSearch(E[]array,E key)

我收到错误消息：

The method linearSearch(E[], E extends Comparable<E>) in the type Prog7b is not applicable for the arguments (E[], E)

但如果我将main更改为：

public static <E extends Comparable<E>> void main(String[] args) {

我明白了：

 Exception in thread "main" I412344java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Comparable;
at whatTheFoo.main(whatTheFoo.java:10)

该方法已被引导包括在方法中：

<E extends Comparable<E>>.

我哪里错了？谢谢阅读。

-------------------------------------------------------------------

对于那些可能很好奇的人来说，这是所有帮助的最终结果。再次感谢！

public class Prog7b {

//  @SuppressWarnings({ "unchecked", "rawtypes" })
    public static void main(String[] args) {

        if (args[0].matches("I|i")) {
            Integer[] array = new Integer[Integer.parseInt(args[1])];
            for (int i = 2; i < args.length - 1; i++) {
                array[i - 2] = new Integer(args[i]);
            }
            Integer key = new Integer(args[args.length - 1]);
            if (linearSearch(array, key) < 0) {
                System.out.println("Didnt find it");
            } else
                System.out.println("Found it at index: " + (linearSearch(array, key) - 1));
            System.out.println("The max of the array is: " + max(array));
            print(array);
        } else if (args[0].matches("S|s")) {
            String[] array = new String[Integer.parseInt(args[1])];
            for (int i = 2; i < args.length - 1; i++) {
                array[i - 2] = new String(args[i]);
            }
            String key = new String(args[args.length - 1]);
            if (linearSearch(array, key) < 0) {
                System.out.println("Didnt find it");
            } else
                System.out.println("Found it at index: " + (linearSearch(array, key) - 1));
            System.out.println("The max of the array is: " + max(array));
            print(array);
        } else {
            Double[] array = new Double[Integer.parseInt(args[1])];
            for (int i = 2; i < args.length - 1; i++) {
                array[i - 2] = new Double(args[i]);
            }
            Double key = new Double(args[args.length - 1]);
            if (linearSearch(array, key) < 0) {
                System.out.println("Didnt find it");
            } else
                System.out.println("Found it at index: " + (linearSearch(array, key) - 1));
            System.out.println("The max of the array is: " + max(array));
            print(array);
        }
    }

    public static <E extends Comparable<E>> int linearSearch(E[] array, E key) {
        int index = 0;
        for (int i = 0; i < array.length; i++) {
            index++;
            if (array[i].equals(key)) {
                return index;
            }
        }
        return -1;
    }

    public static <E extends Comparable<E>> E max(E[] list) {
        E max = list[0];
        for (int i = 1; i < list.length; i++) {
            if (max.compareTo(list[i]) < 0) {
                max = list[i];
            }
        }
        return max;
    }

    private static <E> void print(E[] list) {
        System.out.print("[");
        for (int i = 0; i < list.length - 1; i++)
            System.out.print(list[i] + ", ");
        System.out.print(list[list.length - 1] + "]\n");
    }
}

Answer 1

我认为main不应该是通用的。（方法声明中的<E>部分声明了一个类型变量，这使它变得通用。）如果main真的应该是通用的，那么你需要和老师谈谈，因为他们做了一些奇怪的事情我们无法猜测它。

泛型是一个仅编译时的概念。基本上这个想法是你有一些代码实际上对特定类型有些不可知，但仍然需要某种关于它的抽象信息。

例如，假设我们有一些方法可以检查对象是否为空：

Object requireNonNull(Object obj) {
    if (obj == null) {
        throw new NullPointerException();
    } else {
        return obj;
    }
}

这很好。我们可以将任何类型的对象传递给该方法。（Integer，String，无论如何。）但是，如果我们想直接指定返回值呢？

我们希望能够做到这一点：

String mightBeNull = ...;
String definatelyNotNull = requireNonNull(mightBeNull);

这使我们的验证码更整洁。（也许不是检查null，我们的验证实际上大约有10行，我们不想一直重复它。）

嗯，就目前而言，我们不能，因为我们在尝试将Object分配给String时会遇到编译时错误。

泛型让我们这样做：

<T> T requireNonNull(T obj) {
    if (obj == null) {
        throw new NullPointerException();
    } else {
        return obj;
    }
}

类型参数<T>表示我们声明了一种临时类型。我们不关心它实际上是什么，但我们可以说该方法返回我们传递给它的任何东西。无论obj类型是什么，我们称之为requireNonNull，该方法都会将该类型返回给调用者。

现在我们可以这样做：

String  s = requireNonNull("");
Integer i = requireNonNull(10);
Float   f = requireNonNull(2f);

等等。

requireNonNull实际上是一种真正的方法，就是它的工作原理。

关键是，泛型允许您编写非通用代码调用的非常通用的API。

对于你的作业，看起来你应该写一个带有有界类型参数linearSearch的泛型方法<E extends Comparable<E>>（本质上意味着你传递给linearSearch的任何数组类型，它必须是Comparable）的某个子类型。然后，您可能应该在main中传递不同类型的数组，例如Integer[]，String[]等。您的main方法不是通用的。对于if...else if要求的每种类型，您只有一个args[0]链。

Java：<e extends =“”comparative =“”<e =“”>＆gt;

1 个答案: