Eu gostaria de saber se é possível descompactar uma matriz de objetos em separado na chamada de método que aceita vargs. Esta questão é semelhante aeste.

Eu tenho um código como:

public class Test {
    public static Object doWork(Object... objects){
        System.out.println(objects.length);
        return objects;
    }

    public static void main(String[] args){
        Object res = doWork("one", "two");
        res = doWork("three", res);
    }
}

Eu gostaria de descompactar ores objeto na segunda chamada para receber uma matriz de objetos com comprimento 3 em vez de comprimento 2 como agora (em que a segunda posição é uma matriz de Objetos de comprimento 2, tendo então todos os três argumentos).

Até isso é possível em Java?

Mais detalhado:

Fazendo

Object res = doWork("one", "two");
res = doWork("three", res);

a segunda chamada é chamada como:

doWork( Object[ "three", Object[ "one", "two" ] ] )

onde eu gostaria:

doWork(Object[ "one", "two", "three" ] )

Eu sei que isso pode ser alcançado fazendo:

public static void main(String[] args){
res = doWork("one", "two");
    List<Object> los = Arrays.asList(res);
    los = new ArrayList<>(los);     // Can't modify an underlying array
    los.add("three");
    res = doWork(los.toArray());
}

Mas estou procurando algo como ounpack Lua construída em função ou a maneira do Python descrita na questão SO mencionada anteriormente.

Ambas as respostas dadas por @chancea e @ Cyrille-ka são boas e também resolvem o problema. Um dos fatos que pode ser uma boa ideia levar em conta é se a assinatura do método puder ser modificada. @ cyrille-ka answer respeita a assinatura da função, enquanto @chancea não. No entanto, na maioria dos casos, acho que é possível simplesmente escrever uma função de wrapper simples para outra, de modo que isso não seja um problema. Por outro lado, o caminho do @chance pode ser mais fácil de usar durante a programação (não há erro possível em esquecer de chamar a função de desempacotamento).