String与任意数据类型的转换

Question

我有一堆数据，值都是以字符串形式保存的，但同时保存的他们各自属于什么数据类型，如：
name:a;value:"5";type:int
name:b;value:"6.0";type:double
name:c;value:"7.6";type:float
....
现在要用程序把这些数据转成他们各自真实类型的数据保存到一个Object的数组里，怎么转换？
现在有一种比较挫的办法：
Object o;
if(x.type.equals("int"))
   o = Integer.valueOf(x.value);
else if(x.type.equals("double"))
   o = Double.valueOf(x.value);
....
但这种判定方式不喜欢，能让java程序自动从基本数据类型获得对应的包装器吗？我知道这个在java中是自动转的，现在要在程序中做怎么做啊？
分不多，帮帮忙，谢谢:)

Answer 1

应该没有现成的转换方式，可以自行实现，分两步走：
1、建立映射Map<String, String>，int -> Integer
2、利用反射执行valueOf参考反射代码：
String type = "java.lang.Integer";
String value = "100";
Object result = Class.forName(type).getMethod("valueOf", String.class).invoke(null, value);
System.out.println(result);

Answer 2

可以考虑用Map来保存类型
for example
import java.lang.reflect.*;
import java.util.*;
public class csdn {
    public static void main(String[] args) throws Throwable {
        class UserData {
            String name;
            String value;
            String type;
            public UserData(String name, String value, String type) {
                this.name = name;
                this.value = value;
                this.type = type;
            }
        };
        UserData[] ud = new UserData[] {
            new UserData("a", "5", "int"),
            new UserData("b", "6.0", "double"),
            new UserData("c", "7.0", "float"),
        };
        Map<String, Class> map = new HashMap<String, Class>();
        map.put("int", Integer.class);
        map.put("double", Double.class);
        map.put("float", Float.class);        for (UserData u : ud) {
            Class<?> c = map.get(u.type);
            Method m = c.getDeclaredMethod("valueOf", new Class[]{String.class});
            Object o = m.invoke(null, new Object[]{u.value});
            System.out.println(o);
        }
    }
}

Answer 3

要保存int到Integer之类的映射，当然可以解决问题，但我就是觉得这样不好看，资料上说java会做自动封装的操作，就是一个定义一个int类型的变量，java会自动把它转换为Integer的，我是想如果在自己的代码里加入这个，不就可以不用映射直接做吗？或者它的机制就是1楼所说的机制？

Answer 4

首先你要清除自动装箱-拆箱机制
那是编译期系统自动做的转换，没有所谓的通过某个途径去调用
也就是
Integer i = 5;这样的语句，系统自动转换为Integer i = Integer.valueOf(5)语句而进行编译比如public class test {
    public static void main(String[] args) {
        Integer i = 5; //语句1
        Integer j = Integer.valueOf(5); //语句2
    }
}
javac test.java --编译
javap -verbose test --反编译
可以看到执行指令
E:\chin\test>javap -verbose test
Compiled from "test.java"
public class test extends java.lang.Object
  SourceFile: "test.java"
  minor version: 0
  major version: 50
  Constant pool:
const #1 = Method       #4.#13; //  java/lang/Object."<init>":()V
const #2 = Method       #14.#15;        //  java/lang/Integer.valueOf:(I)Ljava/l
ang/Integer;
const #3 = class        #16;    //  test
const #4 = class        #17;    //  java/lang/Object
const #5 = Asciz        <init>;
const #6 = Asciz        ()V;
const #7 = Asciz        Code;
const #8 = Asciz        LineNumberTable;
const #9 = Asciz        main;
const #10 = Asciz       ([Ljava/lang/String;)V;
const #11 = Asciz       SourceFile;
const #12 = Asciz       test.java;
const #13 = NameAndType #5:#6;//  "<init>":()V
const #14 = class       #18;    //  java/lang/Integer
const #15 = NameAndType #19:#20;//  valueOf:(I)Ljava/lang/Integer;
const #16 = Asciz       test;
const #17 = Asciz       java/lang/Object;
const #18 = Asciz       java/lang/Integer;
const #19 = Asciz       valueOf;
const #20 = Asciz       (I)Ljava/lang/Integer;;{
public test();
  Code:
   Stack=1, Locals=1, Args_size=1
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return
  LineNumberTable:
   line 1: 0
public static void main(java.lang.String[]);
  Code:
   Stack=1, Locals=3, Args_size=1
   0:   iconst_5
   1:   invokestatic    #2; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Int
eger;
   4:   astore_1
   5:   iconst_5
   6:   invokestatic    #2; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Int
eger;
   9:   astore_2
   10:  return
  LineNumberTable:
   line 3: 0
   line 4: 5
   line 5: 10
}红色部分是第一条语句的编译结果，蓝色部分是第二条语句的编译结果
二者是一样的，也就是Integer i = 5;被自动转换为Integer j = Integer.valueOf(5);而编译
这一过程可能在语法分析中就已经作了替换，然后才进行编译的，从而达到装箱-拆箱的目的
所以你的问题没法直接利用这一机制，而你正是要自己实现类似这样的机制，所以需要自己对字符串进行解析，这样自然就可以采用反射，然而基本类型无法从反射中获取有用信息，如
import java.lang.reflect.*;
public class test {
    public static void main(String[] args) throws Throwable {
        Class<?> c = int.class;
        for (Field f : c.getDeclaredFields()) { //获取字段信息
            System.out.println(f);
        }
        for (Method m : c.getDeclaredMethods()) { //获取方法信息
            System.out.println(m);
        }
        for (Constructor co : c.getDeclaredConstructors()) { //获取构造器信息
            System.out.println(co);
        }
        //结果什么都没有，无法从反射中获取有用信息
    }
}
所以可以采用int-Integer映射，否则就只能像你原来用if else去判断

Answer 5

谢谢各位的热心回答，看来只能用if-else或者map来做了。分不多，就看着分给大家了，