Classe de arrays e seu uso

Olá de novo! :) Na última lição, conhecemos uma estrutura de dados como um array (array Java), aprendemos como criar arrays, preenchê-los com dados e também aprendemos como eles são armazenados na memória. Hoje veremos algumas tarefas e exemplos de trabalho com arrays que você encontrará frequentemente no trabalho real. Por exemplo, imagine esta situação: temos um array de 10 números escritos em ordem aleatória.

//array Java, example
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 número. No final deve ficar assim:

[-234, -2, 16, 26, 35, 43, 80, 92, 99, 167]

Como vamos fazer isso? A tarefa não é trivial, nunca fizemos isso antes:/Alguma ideia? Tente adivinhar. Aqui está o que podemos fazer, por exemplo:

• Itere por todos os elementos do array. Compare cada elemento com o próximo ( [0]com [1], [1]com [2], [2]com , [3]etc.). Se o elemento atual do array for maior que o próximo, nós os trocamos e passamos para o próximo elemento. Se não, deixe como está e siga em frente.


• Assim, após a primeira passagem pelos elementos do array, é garantido que o maior valor (167) esteja na última célula.


• Agora vamos percorrer todos os elementos do array novamente, começando pelo elemento com index [0], mas até o penúltimo elemento (o maior número já está em seu lugar) e fazer as mesmas comparações e trocas. 
  Ao final, na penúltima célula teremos o segundo maior valor (99).


• Vamos repetir este trabalho quantas vezes tivermos menos um elemento no array.

Tivemos a ideia, só falta escrever o código. Isso parecerá assim:

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 in the wrong order,
             then swap them */
               if (numbers[j] > numbers[j + 1]) {
                   int tmp = numbers[j];
                   numbers[j] = numbers[j + 1];
                   numbers[j + 1] = tmp;
               }
           }
       }

   }
}

Hum... Parece um pouco complicado -_- Mesmo que o princípio geral de operação seja claro, você terá que escrever bastante código para resolver uma tarefa aparentemente tão simples. Ok, talvez apenas nos superestimamos? Provavelmente, a tarefa que assumimos é muito difícil para nós até agora. Vamos tentar fazer algo mais simples. Por exemplo, vamos pegar 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 conhecimento que você já possui sobre arrays? Você pode, por exemplo, percorrer um array numberse escrever seus elementos um por um 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, já conseguimos mais ou menos! O problema parece ter sido resolvido, mas novamente: se precisar ser executado com frequência, o código terá vários loops idênticos. Na verdade, esses e outros problemas já foram resolvidos pelos criadores do Java, e não precisamos “reinventar a roda” e escrever algum código para nossa própria solução.

Classe de matrizes Java

Uma classe Java especial ajudará você a resolver problemas típicos ao trabalhar com arrays - Arrays. Métodos foram adicionados a esta classe para resolver os problemas mais comuns que os programadores Java encontram em seu trabalho. Por exemplo, a tarefa de ordenar um array, para a qual nós mesmos tentamos encontrar soluções, pode ser resolvida em uma 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. Além disso, o algoritmo incorporado torna isso muito mais eficiente do que o código que escrevemos. Saída do console:

[-234, -2, 16, 26, 35, 43, 80, 92, 99, 167]

Observação: para converter o array em uma string, usamos outro método de classe Arrays- Arrays.toString(). Os próprios arrays Java não substituem o toString(). Então, se você apenas escrever

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

toString()o método da classe será chamado Object. No caso de arrays, a saída será mais ou menos assim:

[I@4554617c

Agora não entraremos em detalhes sobre por que a conclusão é assim; o principal é que claramente não é disso que precisamos. Mas Arrays.toString() fez o que queríamos. Aliás, nosso problema de cópia também é facilmente resolvido na aula 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));

   }
}

Para o método Arrays.copyOf()passamos nosso array original (do qual precisamos copiar os valores) e o comprimento do novo array no qual copiamos os dados. Neste caso, indicamos como comprimento numbers.length, porque queremos copiar o array inteiro. Se quisermos copiar apenas os primeiros elementos, podemos especificar um comprimento menor para o novo 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.copyOf(numbers, 4);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Aqui especificamos que o comprimento do novo array é 4. Conseqüentemente, apenas os primeiros 4 elementos numbersserão copiados para o novo array. Saída do console:

[167, -2, 16, 99]

A propósito, se você precisar copiar parte de um array, mas não do início, mas “do meio”, Arraysvocê também pode fazer isso:

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));

   }
}

Conclusão:

[16, 99, 26, 92]

Os números das células dois ( inclusivas ) a seis ( não inclusivas ) foram copiados para a nova matriz. Além disso, podemos precisar comparar duas matrizes entre si. Assim como acontece com o 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));
   }
}

obtemos o resultado false. Object.equals()Afinal, o método que compara links será chamado . E é claro que eles são diferentes! Mas precisamos comparar o conteúdo dos arrays, não dos links. A classe Arrayscontém um método substituído equals()que faz exatamente o que precisamos:

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));
   }
}

Conclusão:

true

A propósito, a classe Arraysfunciona com sucesso não apenas com arrays comuns, mas também com arrays 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 to each other?");
       System.out.println(Arrays.deepEquals(numbers, numbersCopy));

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

Conclusão:

Равны ли эти двумерные массивы между собой?
true
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Como você pode ver, o método Arrays.copyOf()lidou com a cópia de um array bidimensional. Observe que neste caso, ao copiar um array bidimensional, ocorre a chamada “cópia superficial”. E para comparar matrizes bidimensionais e enviá-las para o console, são fornecidos métodos especiais - deepEqualse deepToString(); No futuro, você verá mais de uma vez (e ficará feliz com isso) que os criadores de Java previram muitas situações típicas que os programadores enfrentam ao trabalhar e implementaram soluções prontas para elas na linguagem. Usar essas soluções é muito mais fácil e conveniente do que reinventar rodas, certo? :) Não deixe de ler a documentação da classe Arraysno site da Oracle . Boa sorte com seus estudos!