Métodos Java arrays

Desenvolvendo métodos

Estou criando dois métodos estáticos em Java: duplica_impares para multiplicar elementos ímpares por 2 e aplica_se para aplicar um operador e verificar um predicado em um array de inteiros.

Transformando elementos

Estou mapeando um método aplica_se para transformar elementos em um array conforme um predicado, aplicando um operador a elementos que correspondem e mantendo os outros inalterados.

Transformando arrays

Estou desenvolvendo métodos Java para dois exercícios: o primeiro mapeia elementos ímpares e o segundo aplica um operador a elementos que atendem a um predicado específico.

Thought about exercícios de programação em Java por 18 segundos

a) Método duplica_impares

A ideia aqui é verificar se cada elemento do array é ímpar. Caso seja, multiplicamos por 2; caso contrário, apenas copiamos o valor original. Segue um exemplo de implementação:

public static int[] duplica_impares(int[] a) {
    int[] resultado = new int[a.length];
    for (int i = 0; i < a.length; i++) {
        if (a[i] % 2 != 0) {   // verifica se é ímpar
            resultado[i] = a[i] * 2;
        } else {
            resultado[i] = a[i];
        }
    }
    return resultado;
}

• Exemplo de uso:

  public static void main(String[] args) {
      int[] arrayOriginal = {1, 1, 2, 3, 4, 5};
      int[] arrayResultante = duplica_impares(arrayOriginal);
      // arrayResultante será [2, 2, 2, 6, 4, 10]
  }
  

b) Método aplica_se (alta ordem)

Nesta versão generalizada, recebemos além do array, duas “funções” (na forma de lambdas ou instâncias de interfaces funcionais):

1. Um UnaryOperator<Integer> (chamado op), que define como iremos transformar os elementos.
2. Um Predicate<Integer> (chamado P), que define a condição para decidir se transformamos (se P.test(elemento) for true) ou não.

A implementação segue o mesmo padrão:

import java.util.function.Predicate;
import java.util.function.UnaryOperator;

public static int[] aplica_se(int[] a, 
                              UnaryOperator<Integer> op, 
                              Predicate<Integer> pred) {
    int[] resultado = new int[a.length];
    for (int i = 0; i < a.length; i++) {
        if (pred.test(a[i])) {
            resultado[i] = op.apply(a[i]);
        } else {
            resultado[i] = a[i];
        }
    }
    return resultado;
}

• Exemplo de uso:

  public static void main(String[] args) {
      int[] arrayOriginal = {7, 3, 2, 0, 8, 9};
  
      // Queremos aplicar (i -> i - 5) apenas aos elementos >= 5
      int[] transformado = aplica_se(arrayOriginal, 
                                     i -> i - 5, 
                                     i -> i >= 5);
  
      // Nesse caso, cada elemento >= 5 é transformado subtraindo 5.
      // O array resultante será [2, 3, 2, 0, 3, 4].
  }
  

Observações:

• O Predicate<Integer> é usado para testar a condição: pred.test(a[i]).
• Se for verdadeiro, chamamos op.apply(a[i]) para aplicar a transformação.
• Se for falso, mantemos o valor original no array final.