---
# System prepended metadata

title: CRUD utilizando Array

---

![](https://imgur.com/t88ZpHH.png)

# CRUD utilizando Array
![](https://i.imgur.com/kgHucE2.png)

Este projeto apresenta um CRUD completo utilizando Array. CRUD é um projeto que contém as 4 principais operações que podemos fazer em uma estrutura de dados ou em um banco de dados:

•	**CREATE** - criação de novos registros;
•	**READ** ou retrieve - leitura de um ou mais registros;
•	**UPDATE** - atualização de um ou mais registros;
•	**DELETE** - remoção de um ou mais registros.

O objetivo desse projeto é familiarizar novos alunos com recursos de programação orientada a objetos. A melhor forma de dominarmos uma linguagem de programação é exercitando o desenvolvimento apenas com os recursos da linguagem, no início de nosso aprendizado. Dessa forma, focamos em lógica de programação e algoritmos aplicados à codificação que estamos aprendendo.

Estrutura do projeto depois de finalizado:
![](https://i.imgur.com/ApSWwap.png)

Para criar esse projeto:
Clicar no menu File :arrow_right: New :arrow_right: Other
![](https://i.imgur.com/7b6QXw3.png)

Em sequida digitamos **Java Project**, e selecionamos a opção quando ela aparecer abaixo da caixa de texto. Depois, clicamos **Next**.
![](https://i.imgur.com/UQjQfRO.png)

Damos um nome para o nosso projeto, verificamos se estamos trabalhando com **JAVA 8** e clicamos em **Finish**
![](https://i.imgur.com/UgeyVXA.png)

Feito isso, precisamos criar os **dois pacotes** onde vamos salvar as **classes** do nosso projeto. Vamos criar os pacotes **entity** e **controll** *(a grafia deliberadamente alterada para lembrar que estamos no pacote Controller da arquietura MVC, que estamos começando a conhecer)*.

Para criar um **novo pacote**, clicamos com o botão direito em src, depois selecionamos New :arrow_right: Package.
![](https://i.imgur.com/pvwf0A3.png)

Na tela seguinte, digitamos o **nome** do pacote e podemos clicar em **Finish**.
![](https://i.imgur.com/pWU6uWm.png)

Repetimos o processo para a criação do pacote **controll**.

Agora, precisamos criar as **classes** do nosso projeto. Vamos precisar apenas de duas: **Pessoa.java** e **ControlPessoaArray.java** - cada uma em um dos pacotes que criamos.

Para criar uma classe, clicamos com o botão direito no nome de pacote e selecionamos New :arrow_right: Class.
![](https://i.imgur.com/FZn63Wp.png)

Na tela seguinte, precisamos apenas dar o **nome** da classe e podemos clicar em **Finish**.
![](https://i.imgur.com/BFESf5k.png)

Nossa primeira classe é a classe **Pessoa**, que é uma classe de dados.

## Pessoa.java

```java=
package entity;

public class Pessoa {

	private Integer id;
	private String nome;
	private Integer idade;

	public Pessoa() {
	}

	public Pessoa(Integer id, String nome, Integer idade) {
		this.id = id;
		this.nome = nome;
		this.idade = idade;
	}

	@Override
	public String toString() {
		return "Pessoa [id=" + id + ", nome=" + nome + ", idade=" + idade + "]";
	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getNome() {
		return nome;
	}

	public void setNome(String nome) {
		this.nome = nome;
	}

	public Integer getIdade() {
		return idade;
	}

	public void setIdade(Integer idade) {
		this.idade = idade;
	}

}

```

A classe **Pessoa** possui apenas 3 atributos: **id, nome e idade**. São o suficiente para ilustrarmos as operações que vamos realizar com **Array**. Lembrando que **idade** é um campo que utilizamos aqui apenas como exemplo. Essa informação, numa situação real, é calculada a partir da data de nascimento armazenada em banco.

A segunda classe do nosso sistema é a classe **ControlPessoaArray**, onde vamos efetivamente realizar as 4 operações: 
* criação do Array e de registros, 
* leitura, 
* alteração e 
* remoção.

## ControlPessoaArray.java
```java=
package controll;

import entity.Pessoa;

public class ControlPessoaArray {

	private Pessoa[] pessoas;

	public Pessoa[] getPessoas() {
		return pessoas;
	}

	public void setPessoas(Pessoa[] pessoas) {
		this.pessoas = pessoas;
	}

	public Boolean vetorVazio() {
		if (this.pessoas.length == 0) { 
			System.out.println("Array Vazio!!!");
			return true;
		} else {
			return false;
		}

	}

	public void adicionarPessoaVazio(Integer n, Pessoa... p) {
		if (n == 0) {
			System.out.println("Adicao invalida!!!");
		} else {
			this.pessoas = new Pessoa[n];
			int i = 0;
			for (Pessoa x : p) {
				if (i > (this.pessoas.length - 1)) {
					throw new ArrayIndexOutOfBoundsException("Numero de registros excede o tamanho do Array!!!");
				} else {
					this.pessoas[i] = new Pessoa(x.getId(), x.getNome(), x.getIdade());
					i++;
				}
			} 
		}
	}

	public void adicionarPessoa(Integer n, Pessoa... p) {
		if (this.pessoas.length == 0) {
			System.out.println("Necessario criar o Array primeiro!!!");
		} else {
			int i = 0;
			while ((i < this.pessoas.length) && (this.pessoas[i] != null)) {
				i++;
			}
			if (i > (this.pessoas.length - 1)) {
				System.out.println("Array cheio!!!");
			} else {
				if ((this.pessoas.length - i) < n) {
					System.out.println("Numero de registros excede o tamanho do Array!!!");
				} else {
					for (Pessoa x : p) {
						this.pessoas[i] = new Pessoa(x.getId(), x.getNome(), x.getIdade());
						i++;
					}
				}
			}
		}
	}

	public void listarPessoa() {

		if (!vetorVazio()) {
			for (int i = 0; i < this.pessoas.length; i++) {
				if (pessoas[i] != null) {
				System.out.println(i + " : " + pessoas[i]);
				} else {
				System.out.println(i + " : Espaco vazio");
				}
			}
		}
	}

	public void atualizarPessoa(Pessoa p) {
		int achado = 0;
		if (!vetorVazio()) {
			for (int i = 0; i < this.pessoas.length; i++) {
				if ((this.pessoas[i] != null) && (this.pessoas[i].getId().equals(p.getId()))) {
					this.pessoas[i] = p;
					achado++;
				}
			}
		}
		if (achado == 0) {
			System.out.println("Pessoa nao encontrada!!!");
		}
	}

	public void removerPessoa(Pessoa p) {
		int achado = 0;
		if (!vetorVazio()) {
			for (int i = 0; i < this.pessoas.length; i++) {
				if ((this.pessoas[i] != null) && (this.pessoas[i].getId().equals(p.getId()))) {
					achado++;
					for (int j = i; j < this.pessoas.length; j++) {
						if (this.pessoas[j] != null)
						pessoas[j] = pessoas[j + 1];
					}
				}
			}
		}
		if (achado == 0) {
			System.out.println("Pessoa nao encontrada!!!");
		}
	}

	public static void main(String[] args) {

		Pessoa p1 = new Pessoa(10, "P1", 30);
		Pessoa p2 = new Pessoa(11, "P2", 31);
		Pessoa p3 = new Pessoa(12, "P3", 32);

		ControlPessoaArray cp = new ControlPessoaArray();
		// cp.adicionarPessoaVazio(10, p1, p2, p3);
		cp.adicionarPessoaVazio(10, p1, p2, p3);
		cp.adicionarPessoa(2, p1, p2);
	// cp.removerPessoa(new Pessoa(12, null, null));
	 cp.atualizarPessoa(new Pessoa(12, "atualizou", 50));
		cp.listarPessoa();
	}
}
```

A classe possui apenas um atributo, que é um **Array** de objetos da classe **Pessoa**.
```javascript=
private Pessoa[] pessoas;
```

Precisamos de um método que retorna **true** caso o **Array** esteja vazio e **false** caso contrário:
```javascript=
public Boolean vetorVazio() 
```

Vamos utilizar esse método em verificações feitas por outros métodos.

Lembrando que Array e Vetor são termos utilizados de forma semelhante.

O próximo método é o de criação de um Array, ou seja o de inserção de elementos em um array vazio:

```javascript=
public void adicionarPessoaVazio(Integer n, Pessoa... p)
```

O método não retorna valor (void) e recebe dois parâmetros: um inteiro com o número de registros que vamos inserir, e uma sequência de objetos da classe **Pessoa**, passados via **Varargs**. 

> Lembrando que **Varargs** é um recurso que permite a passagem de um ou mais parâmetros, separados por vírgula. Devemos lembrar também, que cada método só pode receber uma sequência de parâmetros via **Varargs** e essa sequência precisa ser sempre o último parâmetro a ser passado. 

Se passamos o valor zero como parâmetro, o método retorna a mensagem **"Adição inválida"** e o método não executa mais nada.

Caso contrário, criamos um **Array** com dimensão "n", ou seja, com suas posições numeradas de 0 a n-1.

Feito isso, setamos um contador (chamado **i**) como zero e iniciamos um **loop** com os seguintes passos:

Para cada objeto "x" da classe **Pessoa**, na sequência de objetos passados como parâmetro no **Varargs**:

1) Verificamos se o valor do contador "i" excede o tamanho do Array que definimos;
2) Caso esse valor seja maior que o tamanho do Array, lançamos uma exceção:

```javascript=
throw new ArrayIndexOutOfBoundsException("Numero de registros excede o tamanho do Array!!!");
```

Lembrando que quando lançamos uma exceção, o método não executa mais nada.

3) Se o valor do contador não for maior que o tamanho do Array, inserimos o objeto e incrementamos o valor do contador.

O próximo método faz adição de elementos num array que já tenha alguns elementos inseridos, mas não esteja completo.
```javascript=
public void adicionarPessoa(Integer n, Pessoa... p)
```

Esse método também recebe um **inteiro** e um **Varargs**, assim como o método anterior.

Verificamos se o **Array** está vazio - se estiver, não é esse método que deve ser chamado e sim o método descrito anteriormente. Se o **Array** estiver vazio, imprimimos a mensagem " Necessario criar o Array primeiro!!!", e o método não executa mais nada.

Em seguida, precisamos percorrer o **Array** até encontrarmos uma posição vazia, ou seja, contendo **null**.
```javascript=
while ((i < this.pessoas.length) && (this.pessoas[i] != null))
```
Enquanto o contador "i" estiver dentro dos limites do tamanho do **Array** e não encontrarmos um elemento **null**, incrementamos o valor do contador.

Em seguida, verificamos o valor do contador "i":
```javascript=
if (i > (this.pessoas.length - 1)) {
				System.out.println("Array cheio!!!");
```

Se esse valor for maior que tamanho do **Array** menos 1, é sinal de que i varreu o **Array** inteiro e não achou nenhuma posição vazia, portanto o **Array** está cheio. Imprimimos a mensagem "Array Cheio!!!" e o método não executa mais nada.

Em seguida verificamos se o valor n passado por parâmetro é maior que o número de posições vazias no **Array** - se for, imprimimos a mensagem Numero de registros excede o tamanho do Array!!! e o método não executa mais nada.

Caso contrário, executamos um **loop** inserindo os objetos passados por **Varargs** e incrementando o valor do contador "i" para inserirmos o próximo objeto na posição seguinte.

O próximo método é o listarPessoa(). Nesse método, varremos o **Array** e imprimimos cada objeto. Caso algum objeto seja **null**, imprimimos a mensagem "Espaco vazio".

O próximo método varre o **Array** em busca de um registro para alterá-lo:
```javascript=
public void atualizarPessoa(Pessoa p)
```

Utilizamos um contador chamado "achado". Verificamos se o **Array** está vazio, se não estiver, varremos o **Array** comparando o valor do atributo Id de cada elemento como valor de Id do objeto que foi passado por parâmetro. Enquanto não encontrarmos o elemento que estamos buscando, não atualizamos o contador "achado".

Caso encontremos o objeto procurado, alteramos seus atributos e incrementamos o contador "achado". 

Se chegarmos ao fim do **Array** e o valor do contador ainda for zero, é porque não encontramos o objeto que procurávamos.

O último método se chama **removerPessoa** e também recebe um objeto da classe Pessoa como parâmetro. 

O método fuciona exatamente como o método de atualização de **Pessoa**, a única diferença é que, uma vez encontrado o objeto buscado, o que fazemos é executar o **loop** abaixo:
```javascript=
for (int j = i; j < this.pessoas.length; j++) {
	if (this.pessoas[j] != null)
		pessoas[j] = pessoas[j + 1];
}
```

O que esse **loop** faz é rearranjar os elementos do **Array** de forma a não ficar uma posição com o valor **null** no meio do **Array**, ou seja, a partir do elemento apagado, cada elemento recebe o elemento seguinte.

No método **main**, criamos 3 objetos da classe **Pessoa**, criamos um objeto da classe **ControlPessoaArray** e temos exemplos de chamadas para todos os métodos. Utilize as linhas comentadas para testar todas as operações. Os resultados aparecem no console.
![](https://i.imgur.com/i9EfPwp.png)




