在java中将原始类型数组转换为对象数组

Question

为什么我不能在java中做到这一点？

Object[] o = (Object[])(new int[]{0,1,2,3.14,4});

我有一个方法，它接收一个对象，然后将其表示为字符串，但这取决于他的类型（原始、原始包装器、数组等）。当我创建单元测试时，我将一个数组作为 Object 传递，这是好的，但是当我将该对象强制转换为 Object[] 时，我得到 <强>ClassCastException。 这种情况仅发生在原始类型数组中。有什么办法可以避免这种行为吗？如果没有，有人可以解释一下 Java 虚拟机上这种行为的原因是什么。

非常感谢任何帮助。

Answer 1

这是一个简单的单行：

Double[] objects = ArrayUtils.toObject(primitives);

您需要导入 Apache commons-lang3：

import org.apache.commons.lang3.ArrayUtils;

Answer 2

在 Java 中，原始类型和引用类型是两个不同的世界。这反映在数组上：原始数组不是对象数组，这就是不能进行强制转换的原因。

这是问题中解决方案的一个简单版本：

private Object[] getArray(Object val){
    if (val instanceof Object[])
       return (Object[])val;
    int arrlength = Array.getLength(val);
    Object[] outputArray = new Object[arrlength];
    for(int i = 0; i < arrlength; ++i){
       outputArray[i] = Array.get(val, i);
    }
    return outputArray;
}

当他们有时决定向虚拟机添加新的原始类型时，这仍然有效。

当然，您可能希望始终进行复制，而不仅仅是在原始情况下，那么它会变得更简单：

private Object[] getArray(Object val){
    int arrlength = Array.getLength(val);
    Object[] outputArray = new Object[arrlength];
    for(int i = 0; i < arrlength; ++i){
       outputArray[i] = Array.get(val, i);
    }
    return outputArray;
}

当然，这不是强制转换，而是转换。

Answer 3

最初由 OP 在问题本身中发布，但作为单独的答案拉到此处。

---

在收到 StKiller 和其他用户的回复后
我能够创建一个更通用的方法，位于下面：

private final Class<?>[] ARRAY_PRIMITIVE_TYPES = { 
        int[].class, float[].class, double[].class, boolean[].class, 
        byte[].class, short[].class, long[].class, char[].class };

private Object[] getArray(Object val){
    Class<?> valKlass = val.getClass();
    Object[] outputArray = null;

    for(Class<?> arrKlass : ARRAY_PRIMITIVE_TYPES){
        if(valKlass.isAssignableFrom(arrKlass)){
            int arrlength = Array.getLength(val);
            outputArray = new Object[arrlength];
            for(int i = 0; i < arrlength; ++i){
                outputArray[i] = Array.get(val, i);
                            }
            break;
        }
    }
    if(outputArray == null) // not primitive type array
        outputArray = (Object[])val;

    return outputArray;
}

您可以将数组类型传递到 getArray 方法中，该方法将返回Object[]，而不会抛出 ClassCastException。

再次感谢您的所有回复。

Answer 4

原始类型不能以这种方式进行转换。
在你的例子中，有一个双精度值数组，原因是 3.14。
这会起作用：

    List<Object> objectList = new ArrayList<Object>();
    objectList.addAll(Arrays.asList(0,1,2,3.14,4));

即使这样也能起作用：

List<Object> objectList = new ArrayList<Object>();
objectList.addAll(Arrays.asList(0,"sfsd",2,3.14,new Regexp("Test")));
for(Object object:objectList)
{
    System.out.println(object);
}

更新
好的，正如前面所说，没有直接的方法将原始数组转换为 Object[]。
如果你想要一个转换字符串中任何数组的方法，我可以建议这种方式

public class CastArray {

    public static void main(String[] args) {
        CastArray test = new CastArray();
        test.TestObj(new int[]{1, 2, 4});
        test.TestObj(new char[]{'c', 'a', 'a'});
        test.TestObj(new String[]{"fdsa", "fdafds"});
    }

    public void TestObj(Object obj) {
        if (!(obj instanceof Object[])) {
            if (obj instanceof int[]) {
                for (int i : (int[]) obj) {
                    System.out.print(i + " ");
                }
                System.out.println("");
            }
            if (obj instanceof char[]) {
                for (char c : (char[]) obj) {
                    System.out.print(c + " ");
                }
                System.out.println("");
            }
            //and so on, for every primitive type.
        } else {
            System.out.println(Arrays.asList((Object[]) obj));
        }
    }
}

是的，为每个基本类型编写一个循环很烦人，但没有其他方法，恕我直言。

Answer 5

正如原发帖者首先在他的问题中所说：

我有一个接收对象然后将其表示为字符串的方法

虽然目的是以友好的方式输出对象的值，但他使用强制转换作为意思 为此。因此，扩展 Paŭlo Ebermann 的答案，这是我的解决方案，使大多数对象 toString() 友好。

主要问题是数组，它会递归地将任何数组 X[] 转换为其相当于 List 的对象，无论 X 是否是一个原始与否。如果需要的话，其余的将由每个特定对象的 toString() 处理，这是理所应当的。

重要警告：假设没有循环引用！

给定：

System.out.println(objectify(new double[][]{{65.5 * 15.9, 0}, {0.123456, 1}}))

预期结果：

[[1041.45, 0.0], [0.123456, 1.0]]

实施：

public Object objectify(Object obj) {
    if(obj == null)
        return obj;
    Object o = obj;
    if(obj.getClass().isArray()) {
        // array
        if(obj instanceof Object[]) {
            // array of Object
            Object[] oI = (Object[])obj;
            Object[] oO = new Object[oI.length];
            for(int i = 0; i < oI.length; i++) {
                // objectify elements
                oO[i] = objectify(oI[i]);
            }
            o = Arrays.asList(oO);
        } else {
            // array of primitive
            int len = Array.getLength(obj);
            Object[] out = new Object[len];
            for(int i = 0; i < len; i++)
                out[i] = Array.get(obj, i);
            o = Arrays.asList(out);
        }
    }
    return o;
}

Answer 6

在 Java 8 中，您可以使用带有映射函数的 Streams 将数组转换为任何其他类型之一，如下所示：

Foo[] fooArray = ...;
Bar[] barArray = Arrays.stream(fooArray).map(object -> (Bar) object).toArray();

假设给定的对象可分配给您将其转换为的类型。在您的情况下，您可以将整数数组转换为稍微不同的对象数组，因为整数流具有不同的映射对象的方式：

Arrays.stream(intArray).mapToObj(i -> (Object) i).toArray();

Answer 7

getArray 函数的另一个实现，可以灵活处理基本类型：

public static Object[] createArrayFromArrayObject(Object o) throws XYZException {
    if(!o.getClass().isArray())
        throw new XYZException("parameter is not an array");

    if(!o.getClass().getComponentType().isPrimitive())
        return (Object[])o;

    int element_count = Array.getLength(o);
    Object elements[] = new Object[element_count];

    for(int i = 0; i < element_count; i++){
        elements[i] = Array.get(o, i);          
    }

    return elements;
}

Answer 8

您可以这样做：

int[] intArray = new int[]{0,1,2,3,14,4};
ArrayList<MyObject> myObjArray = new ArrayList<MyObject>;

for (int i = 0; i < intArray.length; i++) {
myObjArray.set(new MyObject(intArray[i]));
}

您需要定义一个类，其中构造函数将整数参数设置为实例字段（在 MyObject 类中）。

Answer 9

您只能转换派生类型的对象，该对象作为基类型处理和传递。在相反的方向上，您可以将派生类型分配给基类型：

Object o = new String ("simple assignment");
String s = (String) o; 

对象不会发生任何转换 - 它只是被揭开它本来的样子，它一直是什么。

Integer [] ia = new Integer [] {4, 2, 6};
Object  [] oa = ia;     

但原始整数不是对象，因此它们不能分配给对象数组。然而，如果可能的话，选角只会在相反的方向上发挥作用。

Answer 10

这里给出的答案都不适用于多维数组，所以这是我的通用包装器。它适用于任何类型和任何维度的数组，并且还可以正确处理空引用（包括深度隐藏的引用）。

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArrayWrapper {
    private static Object[] deepWrap(Class<?> componentClass, Object a) {
        if (a == null)
            return null;
        Object[] result = (Object[])Array.newInstance(componentClass, Array.getLength(a));
        if (componentClass.isArray()) {
            Class<?> innerCompClass = componentClass.getComponentType();
            Object[] b = (Object[])a;
            Arrays.parallelSetAll(result, i -> deepWrap(innerCompClass, b[i]));
        } else
            Arrays.setAll(result, i -> Array.get(a, i));
        return result;
    }

    public static Object[] wrap(Object a) {
        if (a == null)
            return null;
        Class<?> c = a.getClass();
        if (!c.isArray())
            throw new IllegalArgumentException("Not an array");
        int dimension = 0;
        do {
            dimension++;
            c = c.getComponentType();
        } while (c.isArray());
        if (!c.isPrimitive())
            return (Object[])a;
        c = Array.get(Array.newInstance(c, 1), 0).getClass();
        while (--dimension > 0)
            c = Array.newInstance(c, 0).getClass();
        return deepWrap(c, a);
    }
}

使用演示：

public static void main(String[] args) {
    final int size1 = 5;
    final int size2 = 4;
    int[][] b = new int[size1][size2];
    for (int i = 0; i < size1; i++)
        for (int j = 0; j < size2; j++)
            b[i][j] = (i + 1) * (j + 1);
    b[1] = new int[7];
    b[1][4] = 4;
    b[3] = null;
    System.out.println(b.getClass().getCanonicalName());
    System.out.println(Arrays.deepToString(b));
    Integer[][] w = (Integer[][])wrap(b);
    System.out.println(w.getClass().getCanonicalName());
    System.out.println(Arrays.deepToString(w));
}

Answer 11

原始类型不是对象。没有解决方法，您可以将任何包含对象的数组强制转换为 Object[]，但不能将包含基本类型的数组强制转换。