2

如何将此字节数组转换为双精度数组。

byte[] byteArray = {1,0,0,1,0};

我喜欢将它从不使用循环转换，因为这个字节数组有大量元素。

请帮我

4

4 回答 4

4

可能的“无环”解决方案将使用System.arraycopyor Arrays.copyOf，但在这些解决方案中，您无法避免将您的byte[]转换为double[]. 问题是根据规范，这种铸造是不可能的：

Given a compile-time reference type S (source) and a compile-time reference 
type T (target), a casting conversion exists from S to T if no compile-time 
errors occur due to the following rules.
[...]
If S is an array type SC[], that is, an array of components of type SC: 
[...] 
  - If T is an array type TC[], that is, an array of components of type TC, 
    then a compile-time error occurs unless one of the following is true: 
    - TC and SC are the same primitive type. 
    - [...]

使用循环。另请参见此处。

于 2013-08-21T12:32:07.093 回答
2

好的，有一些操作java不提供单行操作，因为它实际上并不需要。

让我们考虑以下。我正在将您的字节数组转换为单行字符串，没有循环。

    byte[] byteArray = {1,0,0,1,0};          
    String str=Arrays.toString(byteArray);

但，

里面发生了toString()很多事情。

    public static String toString(byte[] a) {
    if (a == null)
        return "null";
    int iMax = a.length - 1;
    if (iMax == -1)
        return "[]";

    StringBuilder b = new StringBuilder();
    b.append('[');
    for (int i = 0; ; i++) {
        b.append(a[i]);
        if (i == iMax)
            return b.append(']').toString();
        b.append(", ");
    }
}

现在你可以看到，这里居然有一个loop。同样，如果您能够找到单行方式转换byte[]为double[]您正在做同样的事情。（带循环）。

您可以按以下方式执行此操作

 byte[] byteArray = {1,0,0,1,0};
 double[] arr=toDoubleArray(byteArray);

但是，您也需要以下方法。

public static double[] toDoubleArray(byte[] byteArr){
    double[] arr=new double[byteArr.length];
    for (int i=0;i<arr.length;i++){
        arr[i]=byteArr[i];
    }
    return arr;
}
于 2013-08-21T12:35:09.033 回答
1

如果要避免循环，可以将迭代实现为递归：

public static double[] convert(byte[] in, int idx) {
    double[] ret;
    if (idx == 0) {
        ret = new double[in.length];
        ret[0] = (double)in[0];
    }
    else {
        ret = convert(in, idx-1);
        ret[idx] = (double)in[idx];
    }
    return ret;
}

public static void main(String[] args) {
    byte[] byteArray = {1,0,0,1,0};        
    double[] converted = convert(byteArray, byteArray.length-1);
    for (int i=0;i<byteArray.length;i++) {
        System.out.println(Byte.toString(byteArray[i])+ " converted to double "+converted[i]);
    }
}

输出：

1 converted to double 1.0
0 converted to double 0.0
0 converted to double 0.0
1 converted to double 1.0
0 converted to double 0.0

然而：

  • 从您的问题中不清楚您要达到什么目的，但是从字节转换为双精度时，您必须注意字节数组的字节序
  • 我不建议用递归迭代替换循环，因为它的开销要大得多
  • 如果您想将字节数组转换为无法完成的双数组（请参阅 kol 的答案）
于 2013-08-21T12:41:35.810 回答
-3

我假设您正在寻找 Java 答案...

这将在一行中完成您想要的操作，但它仍然在后台循环。据我所知，没有在某处发生某种程度的循环的情况下，没有办法投射数组

ByteBuffer.wrap(bytes).asDoubleBuffer().array();
于 2013-08-21T12:09:39.817 回答