Classe de matrizes

Olá de novo! :) Na aula de hoje, falaremos sobre a classe Arrays em Java. Na última lição, conhecemos essa estrutura de dados chamada array. Aprendemos como criá-los e preenchê-los com dados. E vimos como eles são armazenados na memória. Hoje veremos algumas tarefas e exemplos de trabalho com arrays que você verá com frequência no trabalho real. Por exemplo, imagine esta situação: temos uma matriz de 10 números aleatórios.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

Nossa tarefa é classificar esse array em ordem crescente: do menor para o maior. No final, deve ficar assim: [-234, -2, 16, 26, 35, 43, 92, 99, 167] Como fazemos isso? Esta tarefa não é trivial. Nunca fizemos isso antes :/ Alguma ideia? Tente adivinhar. Aqui está uma solução:

• Percorra todos os elementos da matriz. Compare cada elemento com o seguinte ([0] com [1], [1] com [2], [2] com [3], etc.). Se o elemento atual for maior que o próximo, nós os trocamos e passamos para o próximo elemento. Se não, deixe-os como estão e siga em frente
• Assim, após a primeira passagem pelos elementos, o maior valor (167) é garantido na última célula.
• Agora vamos percorrer todos os elementos novamente, mas desta vez vamos começar com o índice [0] até o penúltimo elemento (o maior número já está em seu lugar) e fazer as mesmas comparações e trocas. Após esta passagem, na penúltima célula, teremos o segundo maior valor (99).
• Repita esse processo quantas vezes tivermos elementos de array.

Nós temos a ideia. Agora só precisamos escrever o código. Se parece com isso:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       for (int i = numbers.length - 1; i > 0; i--) {
           for (int j = 0; j < i; j++) {
           /* Compare the elements in pairs.
             If they are not in the right order,
             then swap them */
               if (numbers[j] > numbers[j + 1]) {
                   int tmp = numbers[j];
                   numbers[j] = numbers[j + 1];
                   numbers[j + 1] = tmp;
               }
           }
       }

   }
}

Uh ... Parece um pouco complicado -_- Mesmo que o princípio geral seja compreensível, ainda temos que escrever muito código para resolver uma tarefa tão simples. Ok, talvez tenhamos nos superestimado? A tarefa que enfrentamos provavelmente ainda é muito complicada para nós. Vamos tentar algo mais simples. Por exemplo, pegue a mesma matriz de números.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

Nossa tarefa é copiar seu conteúdo para outro array.

int [] numbersCopy = new int[10];

Pense em como você faria isso usando o que já sabe sobre arrays? Por exemplo, você pode percorrer a matriz de números em um loop e escrever sequencialmente seus elementos em numbersCopy :

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = new int[10];

       for (int i = 0; i < numbers.length; i++) {

           numbersCopy[i] = numbers[i];
       }

   }
}

Bem, uh, aqui nós basicamente fizemos isso! Parece que resolvemos o problema. No entanto, se você precisar fazer isso com frequência, seu código terá vários loops idênticos. Na verdade, essas (e outras) tarefas já foram resolvidas pelos criadores do Java. Não precisamos "reinventar a roda" e codificar nossa própria solução. Existe uma classe estática especial ( Arrays ) para ajudá-lo a realizar tarefas comuns ao trabalhar com arrays. Métodos para realizar as tarefas mais comuns enfrentadas pelos programadores Java foram adicionados a esta classe. Por exemplo, a tarefa de ordenar um array, que tentamos manipular, é resolvida em uma única linha:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       Arrays.sort(numbers);

       System.out.println(Arrays.toString(numbers));

   }
}

O método Arrays.sort() classifica o array. E seu algoritmo é muito mais eficiente do que o código que escrevemos. Saída do console: [-234, -2, 16, 26, 35, 43, 80, 92, 99, 167] Nota: Para converter o array em uma string, usamos outro método da classe Arrays : Arrays.toString() . Arrays em Java não substituem o método toString() por conta própria. Então, se você simplesmente escrever

System.out.println(numbers.toString());

o toString() da classe Object será chamado. Para uma matriz, a saída será mais ou menos assim: [I@4554617c Não entraremos em detalhes agora sobre por que exatamente essa é a saída. O principal é que claramente não é o que precisamos. Mas Arrays.toString() faz exatamente o que queremos. A propósito, a cópia também é facilmente realizada com a classe Arrays :

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOf(numbers, numbers.length);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Passamos para o método Arrays.copyOf() nosso array original (do qual queremos copiar os valores) e o tamanho do novo array no qual estamos copiando os dados. Neste caso, indicamos números.comprimento como comprimento, pois queremos copiar o array inteiro. Se quisermos copiar apenas os primeiros elementos, podemos especificar o comprimento de um novo array menor:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOf(numbers, 4);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Aqui especificamos 4 como o comprimento da nova matriz. Assim, apenas os primeiros 4 elementos dos números serão copiados para a nova matriz. Saída do console: [167, -2, 16, 99] A propósito, Arrays também permite que você copie parte de um array do meio em vez do início do array:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOfRange(numbers, 2,6);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Saída: [16, 99, 26, 92] Os números foram copiados para a nova matriz da segunda matriz do segundo (inclusivo) ao sexto (não inclusivo) elemento. Também podemos precisar comparar dois arrays. Como no método toString() , os próprios arrays não substituem o método equals() . Então, se tentarmos compará-los assim

public class Main {

   public static void main(String[] args) {

       int[] numbers = {1, 2, 3};
       int[] numbers2 = {1, 2, 3};

       System.out.println(numbers.equals(numbers2));
   }
}

então ficamos falsos. Isso ocorre porque Object.equals() , que compara referências, será chamado. E, obviamente, eles são diferentes! Mas o que precisamos é comparar o conteúdo do array, não as referências. A classe Arrays substitui o método equals() para fazer exatamente o que queremos:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {1, 2, 3};
       int[] numbers2 = {1, 2, 3};

       System.out.println(Arrays.equals(numbers, numbers2));
   }
}

Saída: true A propósito, a classe Arrays funciona não apenas com arrays comuns, mas também com bidimensionais:

public class Main {

   public static void main(String[] args) {

       int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

       int[][] numbersCopy = Arrays.copyOf(numbers, numbers.length);

       System.out.println("Are these two-dimensional arrays equal?");
       System.out.println(Arrays.deepEquals(numbers, numbersCopy));

       System.out.println(Arrays.deepToString(numbersCopy));
   }
}

Saída: Esses arrays bidimensionais são iguais? true [[1, 2, 3], [4, 5, 6], [7, 8, 9]] Como você pode ver, o método Arrays.copyOf() foi capaz de copiar um array bidimensional. E a classe tem métodos especiais para comparar e exibir arrays bidimensionais: deepEquals e deepToString() . No futuro, você verá repetidamente (e se alegrará com isso) que os criadores de Java anteciparam muitas situações frequentemente enfrentadas pelos programadores e implementaram soluções prontas para elas na linguagem. Usar essas soluções é muito mais fácil e prático do que reinventar a roda, certo? :) Certifique-se de ler a documentação da classe Arrays no site da Oracle . Boa sorte em seus estudos!