aprendendo java: métodos úteis para manipulação de arrays

Iniciando a série "lembretes úteis para quem está aprendendo Java". Esta dica foi obtida no livro "Core Java 2 - Volume I: Fundamentos".

Para copiar o conteúdo de um array para outro, pode-se usar o método arraycopy da classe System. a sintaxe é a seguinte:

System.arraycopy(from, fromIndex, to, toIndex, count);

As variáveis from e to devem ser Object. E como sabemos, todo array em java É UM Object (ou seja, herda os campos e métodos da classe Object).

Traduzindo para o bom português: copie os "count" elementos de "from", começando em "fromIndex" e vá armazenando em "to" a partir de "toIndex".

Exemplo de utilização do método arraycopy:

public class teste {
  public static void main(String args[]) {
    int[] smallPrimes = {2, 3, 5, 7, 11, 13};
    int[] luckyNumbers = {1001, 1002, 1003, 1004, 1005, 1006, 1007};

    System.arraycopy(smallPrimes, 2, luckyNumbers, 3, 4);

    for(int i = 0; i < luckyNumbers.length; i++)
      System.out.println(i +": "+ luckyNumbers[i]);

  } // final de main
} // final da classe teste

A saída deste programa será:

0: 1001
1: 1002
2: 1003
3: 5
4: 7
5: 11
6: 13


A simples ordenação de um array pode ser feita através do método sort da classe java.util.Arrays. Para ordenar basta fazer o seguinte (luckyNumbers é um array de inteiros):

Arrays.sort(luckyNumbers);

Reza a lenda que este método usa o QuickSort.


Outros métodos úteis para manipulação de arrays (todos da classe java.util.Arrays):

static int binarySearch(type[] a, type v)
usa o algoritmo de busca binária para buscar o valor v dentro do array a. Se econtrado, seu índice é retornado. Do contrário é retornado um valor negativo r; o valor -r - 1 é o ponto em que v deverá ser inserido para manter o array a ordenado.
Parâmetros:
a: um array ORDENADO do tipo int, long, short, char, byte, float ou double.
v: um valor do mesmo tipo que os elementos de a.

static void fill(type[] a, type v)
atribui o valor v a todos os elementos do array a.

maneira Deitel de checar data

Essa é mais uma dica da série "como é que eu não tinha pensado nisso antes?". Trata-se de uma maneira super-simples de checar a validade de uma data. Vi isso no livro "Java: Como Programar", sexta edição, do Deitel. Aí vai...

- ano: pode ser qualquer inteiro não negativo.
- mês: inteiro dentro do intervalo [1,12].
- dia: aí vai o algoritmo em C, levando em consideração que o mês e ano são válidos.

int checarDia(int dia, int mes, int ano) {
   /* aqui está a simplicidade do algoritmo:
   * cada elemento deste array é o maior dia do mês cujo número
   * é o índice do elemento, exceto o elemento 0
   */
   int diaPorMes[] = { 0, 31, 28, 31, 30, 31, 30
   31, 31, 30, 31, 30, 31, 30 };

   /* veja que coisa mágica! */
   if(dia > 0 && dia <= diaPorMes[mes])
     return dia;

   /* cuidando do danadinho do ano bissexto */
   if(mes == 2 && dia == 29 && (ano % 400 == 0 || (ano % 4 == 0 && ano % 100 != 0)))
     return dia;

   /* se não for uma data válida, retornamos o dia primeiro */
     return 1;
}

Me lembro de um dia fazer um exercício de programação que pedia para validar se a data que o usuário entrou era válida, fiz o código usando switch-case e alguns ifs...

Ver essa solução usando um simples array chega a dar raiva! Raiva por não ter pensado nisso de primeira.

usando o qsort() do stdlib.h

O protótipo é o seguinte:

#include <stdlib.h>

void qsort(void *base, size_t nmemb, size_t size, int (*compare)(cont void *, const void*));

Criei uma função compara() para comparar dois inteiros:

int compara(int const *a, int const *b) {
    return *a - *b;
}

e usei o seguinte comando para ordenar um array de inteiros lista[] com 10 elementos.

qsort(lista, 10, sizeof(int), &compara);

Pronto! Agora lista já está ordenada.