Usando os métodos da classe Array no Ruby
Tags: ruby, array
Published: 2022-12-05 22:29:34

Bem, vamos aprender a usar os métodos do Array.

E aperte o cinto que a viagem vai ser longa.

## Índice

* [Criando um objeto Array] (#criando)
* [Modificando o Array] (#modificando)
  - [Inserindo no final do array] (#inserindo_no_final)
  - [Inserindo no começo do array] (#inserindo_no_comeco)
  - [Concatenando dois array] (#concatenando)
  - [Inserindo item em determinado posição] (#inserindo_posicao)
     * [Substituindo o item] (#substituindo)
     * [Inserindo sem remover o item] (#inserindo_sem_remover)
  - [Embaralhar o array] (#embaralhar)
  - [Inverter o array] (#inverter)
  - [ordenando o array] (#ordenando)
  - [Lista de métodos não citado de modificação] (#lista_modificacao)
* [Consultando o array] (#consulta)
  - [Consultando o tamanho do array] (#tamanho)
  - [Consultando se está incluso no array] (#incluso)
  - [Consultando se está vazio o array] (#vazio)
  - [Consultando se todos os elementos cumpre a condição] (#todos)
  - [Consultando se existe pelo menos um elemento que cumpre a condição] (#pelos_menos_um)
  - [Consultando se existe somente um elemento que cumpre a condição] (#vazio)
  - [Consultando se existe nenhum elemento que cumpre a condição] (#nenhum)
  - [Contando os elementos] (#contando)
  - [Descobrindo a posição de um determinado elemento] (#posicao_do_elemento)
  - [Lista de métodos não citado de consulta] (#lista_consulta)
* [Busca no array] (#busca)
  - [Busca com índice] (#busca_com_indice)
  - [Pegando o primeiro elemento] (#primeiro_elemento)
  - [Pegando o ultimo elemento] (#ultimo_elemento)
  - [Pegando o maior número] (#maior)
  - [Pegando o menor número] (#menor)
  - [Pegando o menor e maior número] (#menor_maior)
  - [Buscando um elemento aleatório] (#aleatorio)
  - [Lista de métodos não citado de busca] (#lista_busca)
* [Removendo elemento do array] (#removendo)
  - [Removendo o primeiro elemento] (#removendo_primeiro)
  - [Removendo o último elemento] (#removendo_ultimo)
  - [Removendo todos os nil do array] (#removendo_nil)
  - [Removendo determinado elemento] (#removendo_elemento)
  - [Removendo elemento usando índice] (#removendo_elemento_indice)
  - [Removendo elemento com condição] (#removendo_elemento_condicao)
  - [Mantendo elemento com condição] (#mantendo_elemento_condicao)
  - [Removendo duplicata] (#removendo_duplicata)
  - [Lista de métodos não citado de remoção] (#lista_remocao)
* [Iteração] (#iteracao)

***

## Criando um objeto Array <a name="criando"></a>

Antes de nós começar a usar os métodos, vamos primeiro saber algumas maneiras de criar o objeto Array, que isso talvez possa ajudar você em alguma coisa.

Vamos começar com clássico, os colchetes.


```ruby
nomes = []
# ou
nomes = ["Alexandre", "Luiza", "Alisson"]
```

Não tem mistério, porém existe uma outra maneira de criar um Array. Ele é limitado, porém poderoso.

Mas supor uma situação em que você quer um Array bidimensional de 3x3 com valores nulos.

Você, talvez, faria desta forma.

```ruby
matriz = [[nil,nil, nil],[nil,nil, nil],[nil,nil, nil]]
# ou

matriz = []
3.times do
  matriz.append [nil, nil, nil]
end
matriz
#=> [[nil,nil, nil],[nil,nil, nil],[nil,nil, nil]]
```

Não tem problema em criar uma matriz desse jeito, é que existe uma forma mais reduzida.

```ruby
matriz = Array.new(3) { Array.new(3) }
#=> [[nil,nil, nil],[nil,nil, nil],[nil,nil, nil]]
```

Viu, muito mais reduzido.

É melhor eu explicar sobre o método `new`.

O `new` aceita dois argumentos, o primeiro é o tamanho do array, o segundo é o valor padrão.

Vamos ver alguns exemplos:

```ruby
array = Array.new(3)
#=> [nil,nil,nil]

zeros = Array.new(3, 0)
#=> [0,0,0]
```

Eu não sei se você percebeu que eu usei o bloco no exemplo de matriz, pode ser que você esteja se perguntando, por que ele não colocou o `Array.new` no segundo argumentos?

Vamos ver um exemplo que discutirei o problema a seguir.

```ruby
matriz = Array.new(3, Array.new(3))
#=> [[nil,nil, nil],[nil,nil, nil],[nil,nil, nil]]
```

Olha, funcionou.

Só que não. Existe um problema grave ai.

Bem, eu não sou bom em explicar esse tipo de coisa, então eu colocarei um exemplo e deixarei você descobrir o problema sozinho.

```ruby
matriz = Array.new(3, Array.new(3))

matriz[0][0] = 0
#=> [[0,nil, nil],[0,nil, nil],[0,nil, nil]]
```

Viu o problema, vou deixar você descobrir isso sozinho. Mas para não deixar você sem pista, eu lhe darei uma dica, Memória.

Boa sorte com a busca da resposta.

Bem, vamos voltar pro nosso exemplo da matriz.

```ruby
matriz = Array.new(3) { Array.new(3) }
#=> [[nil,nil, nil],[nil,nil, nil],[nil,nil, nil]]
```

Se você olhar isso, você percebe que eu não coloquei o `Array.new` no segundo argumento e sim em um bloco.

Caso você não saiba o que é um bloco, de forma resumida, é um agrupamento de código que está dentro de um `do end` ou `{}`.

Bem, novamente, não sei como explicar isso, mas se você quer saber mais sobre isso, pesquise sobre `yield`, talvez no futuro, eu escrevo sobre isso.

Acho que nós enrolamos demais na criação, então vamos aprender a inserir item no array.

## Modificando o Array <a name="modificando"></a>

Vamos começar inserindo o item no final do array.

### Inserindo no final do array <a name="inserindo_no_final"></a>

Nós temos três formas de inserir elemento no final e cada um dele faz a mesma coisa, então escolha a qual mais adequado em uma situação ou escolha o que você mais gostou.

```ruby
nomes = []

nomes.push "Alexandre"
#=> ["Alexandre"]

nomes.append "Fulano"
#=> ["Alexandre", "Fulano"]

nomes << "Thiago"
#=> ["Alexandre", "Fulano", "Thiago"]
```

### Inserindo no começo do array <a name="inserindo_no_comeco"></a>

Temos dois métodos para isso, e novamente, escolha da sua preferencia.

```ruby
nomes = []

nomes.unshift "Alexandre"
#=> ["Alexandre"]

nomes.prepend "Fulano"
#=> ["Fulano", "Alexandre"]
```

### Concatenando dois array <a name="concatenando"></a>

Talvez você queira juntar dois array para fazer algo com ele.

Tem duas formas de fazer isso, porém com uma diferença.

Por exemplo:

```ruby
nomes = ["Alexandre"]

# usando concat
nomes.concat ["Fulano"]
#=> ["Alexandre", "Fulano"]

# usando o +
nomes = nomes + ["Luiza"]
#=> ["Alexandre", "Fulano", "Luiza"]
```

Pode ser que você notou a diferença, se não notou, não tem problema, eu vou mostrar a diferença.

No método `concat`, pode notar que eu não uso atribuição, ou seja, isso significa que esse `concat` modifica o próprio array.

Enquanto o `+` não modifica o array, e para obter esse array concatenado, tem que usar a atribuição.

Também tem outro detalhe, o `concat` não cria um novo array e o `+` cria um novo array. Vamos ver uma demostração sobre isso.

```ruby
# usando concat
numeros = [1,2,3]

numeros.object_id
#=> 1037700

numeros.concat [4,5,6]
#=> [1, 2, 3, 4, 5, 6]

numeros.object_id
#=> 1037700

# usando o +
numeros = [1,2,3]

numeros.object_id
#=> 1078540

numeros = numeros + [4,5,6]
#=> [1, 2, 3, 4, 5, 6]

numeros.object_id
#=> 1112080
```

Viu a diferença?

Antes de explicar a diferença, talvez você não saiba o que é o `object_id`, considere ele como um número onde a variável está localizado na memória.

Bem, continuando.

Podemos perceber que no `concat` o object_id não muda após a concatenação, enquanto no `+` ele muda.

O que isso significa?

Isso significa que em questão de performance e eficiência, o `concat` pode ser considerado melhor.

### Inserindo item em determinado posição <a name="inserindo_posicao"></a>

Temos dois formas de inserir em determinado posição.

A primeira vai ser inserir naquela posição, porém removendo o item que estava nessa posição.

A segunda vai ser inserir naquela posição, porém sem remover o item que estava nessa posição.

#### Substituindo o item <a name="substituindo"></a>

Aposto que você já usou ele, então não muito o que explicar sobre ele.

Exemplo:

```ruby
comida = ["Pizza", "Pastel", "Hamburger"]
comida[1] = "Coxinha"
#=> "Coxinha"

comida
#=> ["Pizza", "Coxinha", "Hamburger"]
```

#### Inserindo sem remover o item <a name="inserindo_sem_remover"></a>

Não tem mistério neste método, então tome um exemplo:

```ruby
numeros = [1,3,4,5]

numeros.insert(1, 2)
#=> [1, 2, 3, 4, 5]
```

Você também pode colocar mais de um elemento.

```ruby
numeros = [1,4,5]

numeros.insert(1, 2, 3)
#=> [1, 2, 3, 4, 5]
```

### Embaralhar o array <a name="embaralhar"></a>

Se você quer embaralhar os itens do array, basta usar o `shuffle`.

```ruby
n = [1,2,3,4,5,6]

n.shuffle!
#=> [5, 6, 1, 4, 3, 2]
```

### Inverter o array <a name="inverter"></a>

Para inverter, basta usar o `reverse!`.

```ruby
n = [1,2,3,4,5,6]
n.reverse!
#=> [6, 5, 4, 3, 2, 1]
```

### Ordenando o array <a name="ordenando"></a>

Eu não vou me aprofundar em ordenar o array, Só vou mostrar como que usar e o resto você descobre.

Ordenando os números:

```ruby
n = [1,2,3,4,5,6]
n.shuffle!
#=> [4, 2, 5, 1, 6, 3]
n.sort!
#=> [1,2,3,4,5,6]
```

Ordenando pelo tamanho da string:

```ruby
nomes = ["Didi", "Zacarias", "Dede", "Mussum"]
nomes.sort_by! { |nome| nome.size }
#=> ["Didi", "Dede", "Mussum", "Zacarias"]
```

---

Acabamos de aprender alguns métodos que modifica o array, porém ainda restam alguns métodos que não citei, mas eu vou colocar uma lista aqui.

### Lista de métodos não citado de modificação <a name="lista_modificacao"></a>

* fill
* replace
* rotate

Com isso, acabamos com os métodos de modificação, agora vamos para consulta no array.

## Consultando o array <a name="consulta"></a>

Vou abordar todos os métodos de consulta, menos o `hash`.

### Consultando o tamanho do array <a name="tamanho"></a>

```ruby
n = [1,2,3,4,5]
n.size
#=> 5
# ou
n.length
#=> 5
```

Ambos métodos não tem diferença, então escolha por sua preferencia.

### Consultando se está incluso no array <a name="incluso"></a>

```ruby
n = [100,32,21,7,2]
n.include? 100
#=> true

n.include? 5
#=> false
```

### Consultando se está vazio o array <a name="vazio"></a>

```ruby
n = [100,32,21,7,2]
n.empty?
#=> false

n = []
n.empty?
#=> true
```

### Consultando se todos os elementos cumpre a condição <a name="todos"></a>

O método que vou demostrar serve para verificar se os elementos do array está seguindo uma condição posta.

Caso você não colocar uma condição, ele vai verificar pelo elemento que são verdadeiro, ou seja, se tiver um elemento `false` ou `nil`, vai ser falso, senão vai ser verdadeiro.

Vamos para um exemplo.

```ruby
[0, 1, "eu"].all?
# => true

[0, 1, false].all?
# => false

[0, 1, nil].all?
# => false
```

Para colocar uma condição, você pode usar um argumento ou pelo bloco, vamos primeiro com argumento.

```ruby
[0, 0, 0].all? 0
#=> true

[0, 1, 2].all? 0
#=> false

["Alex", "Alvin", "Annie"].all? /^A/
#=> true

["Alex", "Bia", "Carlos"].all? /^A/
#=> false
```

Agora vamos para o bloco

```ruby
[0, 1, 2].all? { |elemento| elemento < 3}
#=> true

[0, 1, 2].all? { |elemento| elemento > 2}
#=> false
```

### Consultando se existe pelo menos um elemento que cumpre a condição <a name="pelos_menos_um"></a>

É mesma coisa com `all?`, porém aqui é se existe pelo menos um.

Se você não dar um condição, ele vai considera o elemento verdadeiro, como eu citei no método `all?`.

```ruby
[nil, 1, false].any?
# => true

[nil, false].any?
# => false

[].any?
# => false
```

Como no método `all?`, ele aceita condição pelo argumento ou pelo bloco.

Vamos primeiro pelo argumento.

```ruby
[0, 0, 0, 0, 1, 0, 0, 0].any? 1
# => true

[0, 0, 0, 0, 2, 0, 0, 0].any? 1
# => false

["Alex", "Alvin", "Annie"].any? /x$/
#=> true

["Alex", "Bia", "Carlos"].any? /^D/
#=> false
```

Agora para o bloco.

```ruby
[0, 0, 11, 0, 0, 0].any? { |elemento| elemento > 10}
# => true

[0, 0, 11, 0, 0, 0].any? { |elemento| elemento > 100}
# => false
```

### Consultando se existe somente um elemento que cumpre a condição <a name="somente_um"></a>

É mesma coisa com `all?` e `any?`, então não vou repetir.

A diferença é que tem que ser somente um elemento.

```ruby
[nil, 1, false].one?
# => true

[nil, false].one?
# => false

[].one?
# => false
```

Usando o argumento.

```ruby
[0, 0, 0, 0, 1, 0, 0, 0].one? 1
# => true

[0, 0, 0, 0, 2, 0, 0, 0].one? 1
# => false

["Alex", "Alvin", "Annie"].one? /x$/
#=> true

["Alex", "Alvin", "Annie"].one? /^A/
#=> false
```

Agora para o bloco.

```ruby
[0, 0, 11, 0, 0, 0].one? { |elemento| elemento > 10}
# => true

[0, 0, 11, 0, 0, 0].one? { |elemento| elemento < 10}
# => false
```

### Consultando se existe nenhum elemento que cumpre a condição <a name="nenhum"></a>

Como sempre, este método é quase equivalente a `all?`, `any?` e `one?`.

Então vamos copiar e colar do exemplo acima.

```ruby
[nil, false].none?
# => true

[nil, false, 1].none?
# => false

[].none?
# => true
```

Usando o argumento.

```ruby
[0, 0, 0, 0, 1, 0, 0, 0].none? 1
# => false

[0, 0, 0, 0, 2, 0, 0, 0].none? 1
# => true

["Alex", "Alvin", "Annie"].none? /x$/
#=> false

["Alex", "Alvin", "Annie"].none? /^B/
#=> true
```

Agora para o bloco.

```ruby
[0, 0, 10, 0, 0, 0].none? { |elemento| elemento > 10}
# => true

[0, 0, 11, 0, 0, 0].none? { |elemento| elemento < 10}
# => false
```

### Contando os elementos <a name="contando"></a>

Agora você quer saber quantos elementos tem no array.

Se você não passar nenhum argumento, ele vai funcionar como o método `length`.

```ruby
[0,0,0,0,0,0,1].count
#=> 7

[0,0,0,0,0,0,1].count 0
#=> 6
```

Você pode usar bloco.

```ruby
[0,0,0,0,0,0,1].count { |elemento| elemento < 1}
#=> 6

[0,0,0,0,0,0,1].count { |elemento| elemento > 1}
#=> 0
```

### Descobrindo a posição de um determinado elemento <a name="posicao_do_elemento"></a>

Talvez a sua aplicação precisa descobrir o índice de um elemento.

Nós temos dois métodos, uma que busca a partir de direita para esquerda e a outra busca de esquerda para direita.

Vamos começar com esquerda para direita.

```ruby
[10,15,20,25,30,35,25].index 25
#=> 3

[10,15,20,25,30,35,25].index 50
#=> nil
```

Agora de direita para esquerda

```ruby
[10,15,20,25,30,35,25].rindex 25
#=> 6

[10,15,20,25,30,35,25].rindex 50
#=> nil
```

### Lista de métodos não citado de consulta <a name="lista_consulta"></a>

* hash

Com isso, acabamos com os métodos de consulta, agora vamos para métodos de busca.

## Busca no array <a name="busca"></a>

Existem muitos métodos de busca, mas muito mesmo, então eu só vou focar o que mais uso.

### Busca com índice <a name="busca_com_indice"></a>

A maneira clássica de busca é o colchete.

```ruby
#          0   1  2  3  4  5
numeros = [7, 12, 6, 8, 9, 2]
numeros[3]
#=> 8

numeros[100]
#=> nil
```

Tem o método `at`, que faz o mesmo trabalho que os colchetes.

```ruby
#          0   1  2  3  4  5
numeros = [7, 12, 6, 8, 9, 2]
numeros.at 3
#=> 8

numeros.at 100
#=> nil
```

Também pode usar o método `fetch`, porém existe uma diferença, observa no exemplo.

```ruby
#          0   1  2  3  4  5
numeros = [7, 12, 6, 8, 9, 2]
numeros.fetch 3
#=> 8

numeros.fetch 100
#=> index 100 outside of array bounds: -6...6 (IndexError)
```

Olha, ele deu erro ao tentar buscar um elemento fora do limite do array.

Existe uma maneira de evitar, que é dando um valor padrão para caso onde der erro.

```ruby
#          0   1  2  3  4  5
numeros = [7, 12, 6, 8, 9, 2]
numeros.fetch(100, "não tem")
#=> "não tem"

# Também pode usar o bloco
numeros.fetch(100) { |indice| "não tem o elemento no índice #{indice}" }
#=> "não tem o elemento no índice 100"
```

### Pegando o primeiro elemento <a name="primeiro_elemento"></a>

Obviamente que você usaria o colchete para pegar o primeiro elemento, mas saiba que existe um método, que é o `first`, por exemplo.

```ruby
n = [8,5,24,1,9,1,0]
n.first
#=> 8

# também pode pegar mais de um elemento
n.first 3
#=> [8, 5, 24]
```

### Pegando o ultimo elemento <a name="ultimo_elemento"></a>

Faz a mesma que o método `first`, porém pegando o último elemento usando `last`.

```ruby
n = [8,5,24,1,9,1,0]
n.last
#=> 0

# também pode pegar mais de um elemento
n.last 3
#=> [9, 1, 0]
```

### Pegando o maior número <a name="maior"></a>

Basta usar o `max`, que ele vai pegar o maior número.

```ruby
n = [8,5,24,1,9,1,0]
n.max
#=> 24

# também pode pegar um conjunto de números maiores
n.max 3
#=> [24, 9, 8]
```

Caso você queira busca o maior string, ele não vai funcionar, você tem passar um bloco, por exemplo:

```ruby
n = ["Alex", "Xande", "Sandra", "Alexandre"]
n.max { |a, b| a.size <=> b.size }
#=> "Alexandre"
```

### Pegando o menor número <a name="menor"></a>

Basta usar o `min`, que ele vai pegar o menor número.

```ruby
n = [8,5,24,1,9,1,0]
n.min
#=> 0

# também pode pegar um conjunto de números menores
n.min 3
#=> [0, 1, 1]
```

Caso você queira busca o menor string.

```ruby
n = ["Alex", "Xande", "Sandra", "Alexandre"]
n.min { |a, b| a.size <=> b.size }
#=> "Alex"
```

### Pegando o menor e maior número <a name="menor_maior"></a>

Ele é basicamente igual aos métodos `min` e `max`, porém pegando o menor e maior número ao mesmo tempo.

```ruby
n = [8,5,24,1,9,1,0]
n.minmax
#=> [0, 24]
```

Também é possível usar para buscar os string menor e maior.

```ruby
n = ["Alex", "Xande", "Sandra", "Alexandre"]
n.minmax { |a, b| a.size <=> b.size }
#=> ["Alex", "Alexandre"]
```

### Buscando um elemento aleatório <a name="aleatorio"></a>

Talvez você queira fazer um sorteio para pegar um valor aleatório, basta usar o método `sample`.

```ruby
sorteio = ["Fulano", "Você", "Eu", "Nós"]
sorteio.sample
#=> "Você"

# também pode pegar um conjunto de valores
sorteio.sample 2
#=> ["Você", "Fulano"]
```

### Selecionando elementos <a name="selecionando"></a>

E se você quer busca valores que começa com letra 'D'.

Vamos ver um exemplo disso.

```ruby
musicas = ["Cada instante", "Pacto", "Canção de carrasco", "Deusa da lua", "Dose de respeito", "Dragão"]

musicas.select {|musica| musica.start_with? "D" }
#=> ["Deusa da lua", "Dose de respeito", "Dragão"]
```

### Lista de métodos não citado de busca <a name="lista_busca"></a>

* assoc
* rassoc
* values_at
* values_at
* dig
* drop
* take
* drop_while
* take_while
* compact
* uniq
* bsearch
* bsearch_index

Bem, acabamos com os métodos de busca, agora vamos para métodos de remover elemento.

## Removendo elemento do array <a name="removendo"></a>

Agora vamos remover elementos do array com alguns métodos.

### Removendo o primeiro elemento <a name="removendo_primeiro"></a>

```ruby
frutas = ["Maçã", "Pera", "Uva", "Melão"]
frutas.shift
#=> "Maçã"
frutas
#=> ["Pera", "Uva", "Melão"]
```

### Removendo o último elemento <a name="removendo_ultimo"></a>

```ruby
frutas = ["Maçã", "Pera", "Uva", "Melão"]
frutas.pop
#=> "Melão"
frutas
#=> ["Maçã", "Pera", "Uva"]
```

### Removendo todos os nil do array <a name="removendo_nil"></a>

Tem situação em que você vai receber um array com valores nil, e então para remover, use o `compact!`.

```ruby
frutas = ["Maçã", nil, "Pera", nil, "Uva", nil, "Melão"]
frutas.compact!
#=> ["Maçã", "Pera", "Uva", "Melão"]
```

### Removendo determinado elemento <a name="removendo_elemento"></a>

```ruby
frutas = ["Maçã", "Pera", "Uva", "Melão"]
frutas.delete "Pera"
#=> "Pera"
frutas
#=> ["Maçã", "Uva", "Melão"]
```

### Removendo elemento usando índice <a name="removendo_elemento_indice"></a>

```ruby
frutas = ["Maçã", "Pera", "Uva", "Melão"]
frutas.delete_at 3
#=> "Melão"
frutas
#=> ["Maçã", "Pera", "Uva"]
```

### Removendo elemento com condição <a name="removendo_elemento_condicao"></a>

```ruby
frutas = ["Maçã", "Pera", "Uva", "Melão"]
frutas.delete_if { |fruta| fruta.end_with? "a" }
#=> ["Maçã", "Melão"]
```

### Mantendo elemento com condição <a name="mantendo_elemento_condicao"></a>

Esse método é o oposto do método anterior, pois ao invés de remover os elementos, ele mantém os elementos e remove aqueles que não cumpre a condição.

```ruby
frutas = ["Maçã", "Pera", "Uva", "Melão"]
frutas.keep_if { |fruta| fruta.end_with? "a" }
#=> ["Pera", "Uva"]
```

### Removendo duplicata <a name="removendo_duplicata"></a>

```ruby
numeros = [0, 1, 1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 9, 9, 0]
numeros.uniq!
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```

### Lista de métodos não citado de remoção <a name="lista_remocao"></a>

* reject!
* slice!
* select!, filter!

Bem, acabamos com os métodos de remoção, agora vamos para métodos de iteração.

## Iteração <a name="iteracao"></a>

Eu só vou abordar dois métodos, que são `each` e `each_with_index`.

Talvez você já usou um dele para iterar um array, veja um exemplo:

```ruby
nomes = ["Bruno", "Rafinha", "Neymar", "Fred"]

nomes.each do |nome|
  puts nome
end
# Bruno
# Rafinha
# Neymar
# Fred
```

Tem vezes que você quer a posição do elemento na iteração, então basta usar o `each_with_index`.

```ruby
nomes = ["Bruno", "Rafinha", "Neymar", "Fred"]

nomes.each_with_index do |nome, indice|
  puts "#{indice}: #{nome}"
end
# 0: Bruno
# 1: Rafinha
# 2: Neymar
# 3: Fred
```

Com isso, nós acabamos de ver quase todos os métodos da classe Array.

## Conclusão <a name="conclusao"></a>

Com isso, agora você vai construir a sua aplicação com mais eficiente.

Bem, é isso, Tchau!