如何判斷數組中的項目是否也是數組？

Question

我試着寫了下面的方法：

public static long[] deepDoubleToLong(double... original) 
{ 
    long[] ret = new long[original.length]; 
    for(int i = 0; i < ret.length; i++) 
     if (original[i] instanceof double[]) 
      ret[i] = deepDoubleToLong((double[])original[i]); 
     else 
      ret[i] = (long)original[i]; 
    return ret; 
} 

位我得到這個編譯錯誤：

Uncompilable source code - unexpected type 
    required: reference 
    found: double 
    at ArrayConversion.deepDoubleToLong(ArrayConversion.java:5) 

怎麼回事，如果不是這樣，我可以告訴我們，如果一個項目是一個數組？

Answer 1

我懷疑你正在尋找我的Rebox類。

這個問題（正如開頭的註釋所描述的那樣）出現在您調用帶有數組參數的可變參數方法時。這會導致數組被封裝並在第一個參數中顯示爲一個基元數組 - 或類似的東西。

無論如何 - 使用它 - 它做你所需要的。

/** 
* Can rebox a boxed primitive array into its Object form. 
* 
* Generally I HATE using instanceof because using it is usually 
* an indication that your hierarchy is completely wrong. 
* 
* Reboxing - however - is an area I am ok using it. 
* 
* Generally, if a primitive array is passed to a varargs it 
* is wrapped up as the first and only component of an Object[]. 
* 
* E.g. 
* 
* public void f(T... t) {}; 
* f(new int[]{1,2}); 
* 
* actually ends up calling f with t an Object[1] and t[0] the int[]. 
* 
* This unwraps it and returns the correct reboxed version. 
* 
* In the above example it will return an Integer[]. 
* 
* Any other array types will be returned unchanged. 
* 
* @author OldCurmudgeon 
*/ 
public class Rebox { 
    public static <T> T[] rebox(T[] it) { 
    // Default to return it unchanged. 
    T[] result = it; 
    // Special case length 1 and it[0] is primitive array. 
    if (it.length == 1 && it[0].getClass().isArray()) { 
     // Which primitive array is it? 
     if (it[0] instanceof int[]) { 
     result = rebox((int[]) it[0]); 
     } else if (it[0] instanceof long[]) { 
     result = rebox((long[]) it[0]); 
     } else if (it[0] instanceof float[]) { 
     result = rebox((float[]) it[0]); 
     } else if (it[0] instanceof double[]) { 
     result = rebox((double[]) it[0]); 
     } else if (it[0] instanceof char[]) { 
     result = rebox((char[]) it[0]); 
     } else if (it[0] instanceof byte[]) { 
     result = rebox((byte[]) it[0]); 
     } else if (it[0] instanceof short[]) { 
     result = rebox((short[]) it[0]); 
     } else if (it[0] instanceof boolean[]) { 
     result = rebox((boolean[]) it[0]); 
     } 
    } 
    return result; 
    } 

    // Rebox each one separately. 
    private static <T> T[] rebox(int[] it) { 
    T[] boxed = makeTArray(it.length); 
    for (int i = 0; i < it.length; i++) { 
     boxed[i] = (T) Integer.valueOf(it[i]); 
    } 
    return boxed; 
    } 

    private static <T> T[] rebox(long[] it) { 
    T[] boxed = makeTArray(it.length); 
    for (int i = 0; i < it.length; i++) { 
     boxed[i] = (T) Long.valueOf(it[i]); 
    } 
    return boxed; 
    } 

    private static <T> T[] rebox(float[] it) { 
    T[] boxed = makeTArray(it.length); 
    for (int i = 0; i < it.length; i++) { 
     boxed[i] = (T) Float.valueOf(it[i]); 
    } 
    return boxed; 
    } 

    private static <T> T[] rebox(double[] it) { 
    T[] boxed = makeTArray(it.length); 
    for (int i = 0; i < it.length; i++) { 
     boxed[i] = (T) Double.valueOf(it[i]); 
    } 
    return boxed; 
    } 

    private static <T> T[] rebox(char[] it) { 
    T[] boxed = makeTArray(it.length); 
    for (int i = 0; i < it.length; i++) { 
     boxed[i] = (T) Character.valueOf(it[i]); 
    } 
    return boxed; 
    } 

    private static <T> T[] rebox(byte[] it) { 
    T[] boxed = makeTArray(it.length); 
    for (int i = 0; i < it.length; i++) { 
     boxed[i] = (T) Byte.valueOf(it[i]); 
    } 
    return boxed; 
    } 

    private static <T> T[] rebox(short[] it) { 
    T[] boxed = makeTArray(it.length); 
    for (int i = 0; i < it.length; i++) { 
     boxed[i] = (T) Short.valueOf(it[i]); 
    } 
    return boxed; 
    } 

    private static <T> T[] rebox(boolean[] it) { 
    T[] boxed = makeTArray(it.length); 
    for (int i = 0; i < it.length; i++) { 
     boxed[i] = (T) Boolean.valueOf(it[i]); 
    } 
    return boxed; 
    } 

    // Trick to make a T[] of any length. 
    // Do not pass any parameter for `dummy`. 
    // public because this is potentially re-useable. 
    public static <T> T[] makeTArray(int length, T... dummy) { 
    return Arrays.copyOf(dummy, length); 
    } 
} 

雖然我可能是錯的。

使用方法如下：

public StringBuilder add(StringBuilder s, T... values) { 
    // Remember to rebox it in case it's a primitive array. 
    for (T v : Rebox.rebox(values)) { 
    add(s, v); 
    } 
    return s.append(fin()); 
} 

在回答你的問題標題我怎麼能知道在數組中的項也是一個數組？ - 使用it[i].getClass().isArray()

Answer 2

如果您更改參數類型Object... original，用Class#isArray()，像這樣：

if (original[i].getClass().isArray()) 

Answer 3

使用變量參數運算符（...）本身是創建一個陣列的本地您方法（在這種情況下稱爲「原始」），所以傳遞給它的任何東西都將成爲一個數組。那麼你是否打算將多維和單維數組傳遞給此方法，然後讓方法區分這些類型？如果你沒有在你的類中聲明任何多維數組，那麼檢查它們將是完全沒有必要的。如果你確實需要單擊和多重輸入，我可能會建議重載方法，並讓方法參數自己做分離。 因此，像：

public static long[] doubleToLong(double[][] original, int index){ 
//your conversion logic here that will type cast your second dimension array 
long[] ret = new long[original.length];  
for(int i = 0; i < ret.length; i++) 
    ret[i] = (long)original[index][i]; 
return ret; 
} 

public static long[] doubleToLong(double[] original){ 
//your conversion logic here that type casts a single dimension array 
long[] ret = new long[original.length];  
for(int i = 0; i < ret.length; i++) 
    ret[i] = (long)original[i]; 
return ret; 
} 

已編譯對我來說，看它是否確實爲你，也測試，以確保它你想要做什麼。但方法參數將排序通過哪些數組是單一的，哪些是多維的。

希望它有幫助！快樂的編碼！

Answer 4

這裏是爲我工作的解決方案：

import java.util.Arrays; 

public class ArrayConversion 
{ 
    public static Object[] deepToDouble(Object[] original) 
    { 
     Object[] ret = new Object[original.length]; 
     for(int i = 0; i < ret.length; i++) 
      if (original[i] instanceof Object[]) 
       ret[i] = deepToDouble((Object[])original[i]); 
      else 
       ret[i] = 
       (
        original[i] instanceof Number 
         ? ((Number)original[i]).doubleValue() 
         : Double.NaN 
       ); 
     return ret; 
    } 

    public static void main(String... args) 
    { 
     Object[] test = new Object[]{1, new Object[]{1, 2, 3}, 3}; 
     System.out.println(Arrays.deepToString(test)); 
     System.out.println(Arrays.deepToString(deepToDouble(new Object[]{1, new Object[]{1, 2, 3}, 3}))); 
    } 
} 

，輸出是：

[1, [1, 2, 3], 3] 
[1.0, [1.0, 2.0, 3.0], 3.0] 

我知道它仍然是鬆散類型爲Object，但它是現在雙打的數組，這是我的最終目標