0Pricing
Java Academy · Aula

Parâmetros Varargs

Defina métodos que aceitam listas de argumentos de comprimento variável e combine-os com matrizes.

Parâmetros Varargs é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Parâmetros de número variável

Argumentos variáveis (listas de argumentos de comprimento variável) permitem definir métodos que aceitam qualquer quantidade de argumentos do mesmo tipo, tratados internamente como um vetor.

Declarando argumentos variáveis

Use Type... name para um parâmetro de argumentos variáveis. Ele deve ser o último parâmetro, e só pode haver um por método.

static int sum(int... numbers) {
    int total = 0;
    for (int n : numbers) total += n;
    return total;
}

System.out.println(sum());           // 0 (empty array)
System.out.println(sum(1));          // 1
System.out.println(sum(1, 2, 3));    // 6
System.out.println(sum(1, 2, 3, 4)); // 10

// Can also pass an array
int[] arr = {5, 10, 15};
System.out.println(sum(arr));        // 30

Argumentos variáveis internamente

Argumentos variáveis são açúcar sintático. O compilador transforma a chamada na criação de um vetor no local da chamada.

// Calling: sum(1, 2, 3)
// Compiler generates: sum(new int[]{1, 2, 3})

static void printAll(String label, String... items) {
    System.out.println(label + ":");
    for (String item : items) System.out.println("  - " + item);
}

printAll("Fruits", "Apple", "Banana", "Cherry");
// Fruits:
//   - Apple
//   - Banana
//   - Cherry

printAll("Empty"); // varargs is empty array

Parâmetros mistos com argumentos variáveis

Os argumentos variáveis devem ser o último parâmetro. Você pode combinar parâmetros normais antes deles.

static double average(String label, double... values) {
    if (values.length == 0) return 0.0;
    double sum = 0;
    for (double v : values) sum += v;
    double avg = sum / values.length;
    System.out.printf("%s average: %.2f%n", label, avg);
    return avg;
}

average("Math scores", 92.0, 85.5, 78.0, 95.0);
// Math scores average: 87.62

average("Single value", 100.0);
// Single value average: 100.00

Argumentos variáveis com tipos genéricos

Usar argumentos variáveis com tipos genéricos causa um aviso de poluição da memória. Suprima-o com @SafeVarargs quando for possível provar que o método é seguro.

import java.util.Arrays;
import java.util.List;

@SafeVarargs  // suppresses heap pollution warning
static <T> List<T> listOf(T... elements) {
    return Arrays.asList(elements); // safe: we don't store to the array
}

List<String> names = listOf("Alice", "Bob", "Charlie");
System.out.println(names); // [Alice, Bob, Charlie]

List<Integer> scores = listOf(95, 87, 73);
System.out.println(scores); // [95, 87, 73]

Argumentos variáveis e sobrecarga

Quando um método com argumentos variáveis é sobrecarregado com uma correspondência exata, a correspondência exata tem preferência. Os argumentos variáveis são o último recurso.

static void log(String msg)         { System.out.println("1-arg: " + msg); }
static void log(String m1, String m2) { System.out.println("2-arg: " + m1 + ", " + m2); }
static void log(String... msgs)        { System.out.println("varargs: " + msgs.length); }

log("hello");          // 1-arg: hello
log("a", "b");         // 2-arg: a, b
log("a", "b", "c");   // varargs: 3
log();                  // varargs: 0

printf usa argumentos variáveis

System.out.printf usa argumentos variáveis — aceita uma string de formato e qualquer quantidade de argumentos de qualquer tipo.

// printf signature: printf(String format, Object... args)
System.out.printf("%s ordered %d items for $%.2f%n",
    "Alice", 3, 59.97);
// Alice ordered 3 items for $59.97

// String.format is also varargs
String msg = String.format("Error %d: %s", 404, "Not Found");
System.out.println(msg); // Error 404: Not Found

Construindo um registrador com argumentos variáveis

Implementação de um registrador estruturado simples que aceita pares de chave e valor usando argumentos variáveis.

static void logEvent(String event, Object... keyValues) {
    if (keyValues.length % 2 != 0)
        throw new IllegalArgumentException("Key-value pairs required");
    StringBuilder sb = new StringBuilder(event);
    for (int i = 0; i < keyValues.length; i += 2)
        sb.append(" ").append(keyValues[i]).append("=").append(keyValues[i+1]);
    System.out.println(sb);
}

logEvent("user.login",  "userId", 42, "ip", "192.168.1.1", "success", true);
// user.login userId=42 ip=192.168.1.1 success=true

Consideração de desempenho

Cada chamada com argumentos variáveis cria um novo vetor na memória. Para métodos utilitários chamados com alta frequência, forneça sobrecargas com quantidade fixa de argumentos para evitar alocações.

// Java's own EnumSet does this:
static <E extends Enum<E>> EnumSet<E> of(E e)              { ... }
static <E extends Enum<E>> EnumSet<E> of(E e1, E e2)       { ... }
static <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3) { ... }
static <E extends Enum<E>> EnumSet<E> of(E e1, E... rest)  { ... }
// Avoids array creation for 1-3 args (most common case)

// Apply the same pattern to your own hot-path APIs:
static void report(String msg)             { log(new String[]{msg}); }
static void report(String m1, String m2)   { log(new String[]{m1, m2}); }
static void report(String... msgs)         { log(msgs); }

Argumentos variáveis e nulo

Passar null para um método com argumentos variáveis é ambíguo — Java pode interpretá-lo como um vetor nulo. Use uma conversão explícita para evitar o aviso.

static void printItems(String... items) {
    if (items == null) {
        System.out.println("null array passed");
        return;
    }
    for (String item : items)
        System.out.println(item != null ? item : "(null element)");
}

printItems((String[]) null); // null array passed
printItems(null, "valid");   // (null element), valid
printItems();                 // empty array (0 items)

Prático: auxiliar de formatação de String

Um wrapper seguro de printf que retorna a string formatada, usando argumentos variáveis para seguir o estilo de texto de formato e argumentos.

static String fmt(String pattern, Object... args) {
    try {
        return String.format(pattern, args);
    } catch (java.util.IllegalFormatException e) {
        return "[FORMAT ERROR: " + e.getMessage() + "]";
    }
}

System.out.println(fmt("User %s has %d orders", "Alice", 5));
// User Alice has 5 orders

System.out.println(fmt("Invalid %z format", "arg"));
// [FORMAT ERROR: Conversion = 'z' ...]

Verificação rápida

Qual é o tipo de um parâmetro de argumentos variáveis dentro do corpo do método?

Recapitulação: parâmetros de número variável

Principais conclusões:

  • Argumentos variáveis (tipo... nome) aceitam zero ou mais argumentos, tratados internamente como um vetor
  • Devem ser o último parâmetro — só pode haver um parâmetro de argumentos variáveis por método
  • Quem chama o método pode passar valores individuais ou um vetor
  • Use @SafeVarargs para suprimir avisos de poluição da memória em argumentos variáveis genéricos
  • Sobrecargas com correspondência exata têm preferência sobre sobrecargas com argumentos variáveis
  • Forneça sobrecargas com quantidade fixa de argumentos para métodos chamados com frequência e evite a alocação de vetores

Perguntas Frequentes

A aula “Parâmetros Varargs” é grátis?

Sim — o texto completo de “Parâmetros Varargs” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Parâmetros Varargs”?

Defina métodos que aceitam listas de argumentos de comprimento variável e combine-os com matrizes. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Parâmetros Varargs”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Regras de Sobrecarga de Métodos
  2. Parâmetros Varargs
  3. Campos e Constantes Estáticos
  4. Classes Utilitárias e Métodos de Fábrica Estáticos
← Voltar para Java Academy