Java varags не откриват, когато се извиква vararg метод в друг vararg метод

В метода

in(T parameter, T... values) //in(true, values); // values is T

Когато предавате булев масив values, целият масив се приема като един елемент T Това е причината да го показвате 1.

Вие предавате булев масив и получаващият тип е T, където всеки елемент се счита за масив.

Можете да отпечатате стойностите вътре в метода и да видите какъв е резултатът. Виждате масивен обект. Не отделните булеви елементи.

Когато въвеждате or, параметърът boolean... values се преобразува в масив от boolean. След това, когато извикате in(true, values), вторият параметър на in всъщност е масив от примитивен тип boolean (така че една стойност). Действителният проблем е, че Java не поставя автоматично в кутия масив от примитивни типове.

public static boolean or(boolean... values) {
    System.out.println("OR values size.. " + values.length);
    // here values is an array of the primitive boolean
    return in(true, values);
}

public static void main(String[] args) {
    System.out.println(or(false, true, false));
}

Можете да се справите с този проблем, като поставите своя boolean в Boolean обект по следния начин:

public static <T> boolean in(T parameter, T... values) {
    if (null != values) {
        System.out.println("IN values size.. " + values.length);
        return Arrays.asList(values).contains(parameter);
    }
    return false;
}

public static boolean or(boolean... values) {
    System.out.println("OR values size.. " + values.length);
    Boolean[] boxedValues = new Boolean[values.length];
    for (int i = 0; i < values.length; i++) {
        boxedValues[i] = values[i];
    }
    return in(true, boxedValues);
}

public static void main(String[] args) {
    System.out.println(or(false, true, false));
}

Обърнете внимание, че започвайки с Java 7, този код ще излъчва предупреждение, което можете да деактивирате с анотацията @SafeVarargs.

Използвам статичен инструмент, за да се справя с този странен ръбов случай.

/**
 * 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 static 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 static <T> boolean in(T parameter, T... values) {
    if (null != values) {
        System.out.println("IN values size.. " + values.length);
        return Arrays.asList(values).contains(parameter);
    }
    return false;
}

public static boolean or(boolean... values) {
    System.out.println("OR values size.. " + values.length);
    return in(true, Rebox.rebox(values));
}

public void test() {
    System.out.println(or(false, true, false));
}

Това отпечатва:

OR values size.. 3
IN values size.. 3
true

както изисквате.