# CRUD utilizando Array
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:
Para criar esse projeto:
Clicar no menu File :arrow_right: New :arrow_right: Other
Em sequida digitamos **Java Project**, e selecionamos a opção quando ela aparecer abaixo da caixa de texto. Depois, clicamos **Next**.
Damos um nome para o nosso projeto, verificamos se estamos trabalhando com **JAVA 8** e clicamos em **Finish**
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.
Na tela seguinte, digitamos o **nome** do pacote e podemos clicar em **Finish**.
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.
Na tela seguinte, precisamos apenas dar o **nome** da classe e podemos clicar em **Finish**.
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.
Sign in with Wallet
Connect another wallet