Question

我目前正在尝试从书中学习如何使用泛型。在本章中，它说要获取一段数据T并将其转换为整数。我在Eclipse中尝试不同的东西，但似乎没有人允许这样做。你怎么能执行以下任务：

LinkedList<T> arr = new LinkedList<T>();

Float fl = 8.74273123948;
arr.add(fl);

然后在另一个班级：

public int findValue(Node node)
{
  T data = node.data;
  int value = Number.valueOf(data);  
  return value;
}

我尝试在其他一些事情中使用.valueOf()和(int)，似乎没有什么可以满足Java。本书坚持保持方法通用，以防使用浮点数或双精度数而不是字符串或整数。

编辑：对于可能有类似问题的其他人。从对这个问题的所有评论和接受的答案中收集：

对数据使用.toString（），然后根据需要将其解析为您需要的任何数据类型。

Answer 1

嗯，这是一本奇怪的书。我会试着根据我的知识告诉你它的要点。

泛型是一种构造，它允许您编译时检查您尝试在特定集合，方法或类中使用的类型是否实际上知道该特定事物运行所必需的功能。< / p>

例如，您需要在模板中使用名为SearchParameter的接口确定的函数，但只能将<T>参数视为对象。或者，在您的情况下，更好的示例可能是名为IntegerConvert的自定义界面，如下所示：

public interface IntegerConvert
{
    Integer returnAsInteger();
}

你可以有一个这样的课：

public class MyData implements IntegerConvert
{
    private String data;

    public MyData(String data)
    {
        this.data = data;
    }

    @Override
    public Integer returnAsInteger()
    {
        return Integer.parseInt(data); //throws ParseException if it doesn't work
    }
}

然后你可以得到这样的列表：

List<IntegerConvert> listOfConvertibles = new ArrayList<IntegerConvert>();

或者如果你想在未来更加通用，

List<? extends IntegerConvert> listOfConvertibles = new ArrayList<IntegerConvert>();

然后你可以做

listOfConvertibles.add("25");
listOfConvertibles.add("40");
listOfConvertibles.add("35");
for(IntegerConvert ic : listOfConvertibles)
{
    System.out.println("" + ic.returnAsInteger());
}

虽然这是一个过于复杂的例子，但我想。一个更简单的例子如下：

public class Node<E>
{
    private E data;

    public Node(E e)
    {
        this.data = e;
    }

    public E getData()
    {
        return data;
    }

    public void setData(E e)
    {
        data = e;
    }

    public void print()
    {
        System.out.println(data.toString());
    }
}

public class MyClass
{
    public void doSomething()
    {
        List<Node<Float>> listOfFloatNodes = new ArrayList<Node<Float>>();
        listOfFloatNodes.add(new Node<Float>(new Float(8.7472742f)));
        listOfFloatNodes.add(new Node<Float>(new Float(5.56842742f)));
        listOfFloatNodes.add(new Node<Float>(new Float(6.5467742f)));
        MyOtherClass moc = new MyOtherClass();
        moc.useNodeList(listOfFloatNodes);
    }
}

public class MyOtherClass
{
    public <E> void useNodeList(List<Node<E>> list)
    {
         for(Node<E> node : list)
         {
             printNode(node);
         }
    }

    public <E> void printNode(Node<E> node)
    {
         node.print();
    }
}

public class MainClass
{
    public static void main(String[] args)
    {
        MyClass myClass = new MyClass();
        myClass.doSomething();
    }
}

如果您有任何问题，请发表评论。

Answer 2

尝试观察以下示例：

public static void main(String[] args) {
    test0("13");
    test0(new Integer(13));
    test1();
    System.out.println(findValue(new Node("10")));
}

private static <T> void test0(T a) {
    LinkedList<T> arr = new LinkedList<T>();
    arr.add((T) a);
    System.out.println(arr.getFirst());
}

private static <T> void test1() {
    LinkedList<T> arr = new LinkedList<T>();
    arr.add((T) new Integer(13));
    System.out.println(arr.getFirst());
}

public static <T> int findValue(Node node) {
    T data = (T) node.data;
    int value = Integer.valueOf(data.toString());
    return value;
}

Node是：

    public class Node {

    //this should be private
        public String data;

        public Node(String data) {
            this.data = data;
        }

    //use getter below to access private data
    public String getData() {
            return data;
        }

  }

所有这一切都是可能的，因为允许从已知类型到T的未经检查的强制转换（当然还有警告），编译器会认为你要进行投射。

Answer 3

尽管答案密切相关，但并未完全回答。我有一个问题，但没有找到答案。然后我找到了解决方案并认为我会分享：

我试图将通用值转换为基本类型：

<TYPE> boolean equal(TYPE val, Class<?> type) {
    if (float.class == type) {            
        float val2 = (float) val; // incompatible types: TYPE cannot be converted to float
        float val3 = (float) (Object) val; // works
        ...

长话短说：第一个版本不起作用，第二个版本不起作用。相当讨厌。

Java泛型并转换为基本类型

3 个答案: