Java 将具有两种类型的数组转换为HashMap、TreeMap、LinkedHashMap

创建阵列：

{int，String}，{String，String}，{int，long}，{String，boolean}，{String，double}，{int，class Car}，{String，class Car}

转换为HashMap、TreeMap、LinkedHashMap

这是一辆高级轿车：

public class Car implements Comparable{

    int id;
    String car_name;
    String number;

    public Car(int id, String car_name, String number) {
        this.id = id;
        this.car_name = car_name;
        this.number = number;
    }

    @Override
    public String toString() {
        return "Car{" +
                "id='" + id + '\'' +
                ", car_name='" + car_name + '\'' +
                ", number='" + number + '\'' +
                '}';
    }
}

这是我的代码：

public class Main {

    private static HashMap<Integer,String> toHM(Object[][] a){
        HashMap<Integer,String> h = new HashMap<>();

        for (Object[] o : a){
            h.put((Integer) o[0], (String) o[1]);
        }
        return h;
    }

    private static HashMap<Integer,String> toLHM(Object[][] a){
        HashMap<Integer,String> h = new LinkedHashMap<>();

        for (Object[] o : a){
            h.put((Integer) o[0], (String) o[1]);
        }
        return h;
    }

    private static TreeMap<Integer,String> toTM(Object[][] a){
        TreeMap<Integer,String> h = new TreeMap<>();

        for (Object[] o : a){
            h.put((Integer) o[0], (String) o[1]);
        }
        return h;
    }



    public static void main(String[] args) {

        Object[][] a = new Object[2][2];
        a[0][0] = 1;
        a[0][1] = "test";
        a[1][0] = 2;
        a[1][1] = "other test";

       HashMap<Integer,String> aHM = toHM(a);
       HashMap<Integer,String> aLHH = toLHM(a);
       TreeMap<Integer,String> aTM = toTM(a);

    }
}

公共类主{
私有静态HashMap toHM（对象[][]a）{
HashMap h=新的HashMap（）；
对于（对象[]o:a）{
h、 put（（整数）o[0]，（字符串）o[1]）；
}
返回h；
}
私有静态HashMap toLHM（对象[][]a）{
HashMap h=新LinkedHashMap（）；
对于（对象[]o:a）{
h、 put（（整数）o[0]，（字符串）o[1]）；
}
返回h；
}
私有静态树映射toTM（对象[][]a）{
TreeMap h=新的TreeMap（）；
对于（对象[]o:a）{
h、 put（（整数）o[0]，（字符串）o[1]）；
}
返回h；
}
公共静态void main（字符串[]args）{
对象[][]a=新对象[2][2]；
a[0][0]=1；
[0][1]=“测试”；
a[1][0]=2；
a[1][1]=“其他测试”；
HashMap aHM=toHM（a）；
HashMap aLHH=toLHM（a）；
树映射aTM=toTM（a）；
}
}

这代码正确吗？阿美，在代码中使用泛型更好吗？ 我知道如何解决这个问题吗

根据标准，您应该始终对接口进行编码。我的意思是，引用应该是一个接口，对象应该是实现

正如我看到的，你在所有三个方法中都有相同的主体，我不能有一个返回映射的方法。您可以添加一个参数并将其指定给引用

调用函数可以捕获所需的返回类型

下面是一个伪代码供您帮助

例如

调用函数：

HashMap hMap = getMap(Object[][] a, HashMap.class);

方法签名：

private <R> R (Object[][] a,Class<R> responseClazz){
    Map mp = new responseClazz();
    .....
    return mp;
}

private R（对象[][]a，类responseClazz）{
Map mp=new responseClazz（）；
.....
返回mp；
}

检查以下内容：

@SuppressWarnings("unchecked")
public static <S, T1, T2> S convert(Object[] inputobject, Class<S> mapType,
        Class<T1> keyType, Class<T2> valueType)
        throws IllegalAccessException, InstantiationException {
    Map<T1, T2> map = (Map<T1, T2>) mapType.newInstance();
    map.put((T1) inputobject[0], (T2) inputobject[1]);
    return (S) map;
}

样本输出：

{1=test}

---

我希望这能起作用。

您不能将对象强制转换为字符串或整数。而是重写您的方法以获取不同的数组，或者在其中包含instanceof if语句。

{1=test}