Arquivo Discussoes de Programacao e Tecnologia boa tarde
estou aprendendo a materia de colecoes em java, e meu professor passou um exercicio, fiz ja leitura sobre list, set e map
e ai vou usar o ArrayList por ser mais facil mas ai to com uma duvida
criei 2 classes
uma telefone e uma contato, cada uma com seus respectivos atributos
sendo que a classe contato pode ter de 0 a N telefones…
minha duvida vem a ser no seguinte sentido…como trabalhar com essas 2 listas ja que uma fica ligada a outra…
Obrigado
Seria esse o relacionamento?
class Contato {
private List<Telefone> telefones;
public List<Telefone> getTelefones() {
return telefones;
}
}
class Telefone {
private String numero;
public String getNumero() {
return numero;
}
}
Seria esse o relacionamento?class Contato { private List<Telefone> telefones; public List<Telefone> getTelefones() { return telefones; } } class Telefone { private String numero; public String getNumero() { return numero; } }
public class Telefone {
private int cod;
private String num_Telefone;
public void setCod(int cod) {
this.cod = cod;
}
public String getNum_Telefone() {
return num_Telefone;
}
public void setNum_Telefone(String num_Telefone) {
this.num_Telefone = num_Telefone;
}
}
public class ListTelefone {
private List<Telefone> listTelefone;
public ListTelefone() {
listTelefone = new ArrayList<Telefone>();
}
public void LimparTelefone() {
this.listTelefone.clear();
}
public void AdcionarTelefone(Telefone t) {
listTelefone.add(t);
}
}
public class ListContato {
private List<Contato> listaContato;
public ListContato() {
this.listaContato = new ArrayList<Contato>();
}
public void LimparContato() {
this.listaContato.clear();
}
public void AdcionarContato(Contato c) {
this.listaContato.add(c);
}
public List<Contato> MostrarListaContato(){
return this.listaContato;
}
}
public class Contato {
private int cod;
private String nome;
private String cidade;
private ListTelefone telefone;
private String email;
public void setCod(int cod) {
this.cod = cod;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getCidade() {
return cidade;
}
public void setCidade(String cidade) {
this.cidade = cidade;
}
public ListTelefone getTelefone() {
return telefone;
}
public void setTelefone(ListTelefone telefone) {
this.telefone = telefone;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
Por que criar uma classe só pra ter as listas? Por que não utilizar a orientação a objetos e dizer que Contato tem uma lista de Telefones?
cara estou aprendendo…
o proposito seria o seguinte…
tenho que fazer um programa usando conceitos que estudei de poo, coleções, excessoes…
se quiser me sugerir uma ideia melhor tudo bem
eu preciso gravar isso num txt
pq o contato pode 0 a n telefones…
pensei em guardar em list ou algo do tipo
Opa manolo, estamos aqui pra ajudar. Da uma olhada no exemplo que eu passei, o que você acha dele? Você não acha que fica mais entendível? Fica bem explícito que Contato tem vários Telefones e fica mais fácil de trabalhar também.
Seria esse o relacionamento?class Contato { private List<Telefone> telefones; public List<Telefone> getTelefones() { return telefones; } } class Telefone { private String numero; public String getNumero() { return numero; } }
vi seu exemplo e vc criou uma lista de telefones dentro do contato...
seria isso nao?
pq vc discordou do meu?
Isso mesmo. Na verdade eu não discordei, te mostrei uma solução, que ao meu ver, é melhor, mais orientado a objetos. Na sua implementação vc está encapsulando sua lista em outra classe e novamente, ao meu ver, não seria uma boa solução.
entendi eu acho
pq eu criei as classes das entidades
depois criei as classes das listas das entidades
e ai comecei a usar elas…
vc ta dizendo pra eu ir direto ao ponto né?
Isso manolo.
mas ai vem uma duvida…como acessar a lista de telefones a partir da lista de contatos?
Vamos por passos, quem tem a lista de contatos? vamos supor que seja uma Pessoa. então ficamos assim:
Uma pessoa tem uma lista de contatos, e cada contato tem uma lista de telefones. Você tem que ir acessando hierarquicamente.
Fez sentido?
Vamos por passos, quem tem a lista de contatos? vamos supor que seja uma Pessoa. então ficamos assim:Uma pessoa tem uma lista de contatos, e cada contato tem uma lista de telefones. Você tem que ir acessando hierarquicamente.
Fez sentido?
Um contato PODE ( 0…N) ter varios numeros de telefone
Vamos por passos, quem tem a lista de contatos? vamos supor que seja uma Pessoa. então ficamos assim:Uma pessoa tem uma lista de contatos, e cada contato tem uma lista de telefones. Você tem que ir acessando hierarquicamente.
Fez sentido?
Um contato PODE ( 0…N) ter varios numeros de telefone
Eu sei, cara, se você diz como pode ter acesso a um contato específico, aí a situação é diferente.
O ArrayList você acessa por índice, se quer pegar o primeiro da lista tem que fazer assim:Contato contato = listaContatos.get(0); então no caso pra fazer o que você quer, pegaria a lista de telefones após isso, mas isso não fica muito bonito enviando um número pra buscar o contato, né, como você vai saber se é o cara que você quer?
Nesse caso eu sugiro que use uma implementação de Map, você ja leu sobre elas?
Vamos por passos, quem tem a lista de contatos? vamos supor que seja uma Pessoa. então ficamos assim:Uma pessoa tem uma lista de contatos, e cada contato tem uma lista de telefones. Você tem que ir acessando hierarquicamente.
Fez sentido?
Um contato PODE ( 0…N) ter varios numeros de telefone
Eu sei, cara, se você diz como pode ter acesso a um contato específico, aí a situação é diferente.
O ArrayList você acessa por índice, se quer pegar o primeiro da lista tem que fazer assim:
Contato contato = listaContatos.get(0);então no caso pra fazer o que você quer, pegaria a lista de telefones após isso, mas isso não fica muito bonito enviando um número pra buscar o contato, né, como você vai saber se é o cara que você quer?Nesse caso eu sugiro que use uma implementação de Map, você ja leu sobre elas?
Ler eu li, ontem ate conversando com meu professor sobre isso…ler até que é facil sobre set, list e map mas o problema é na hora de usar…codigo!!!
Eu peguei um codigo de exemplo e joguei no eclipse de um hashmap e deu erro
Era muito estranho…
Outro detalhe, irei acessar o contato oferencendo a opcao ao usuario o codigo, nome, cidade ou email…pois o exercicio pede isso
voce tem que conseguir acessar o contato com qualquer uma dessas informações? é isso ?
isso…
terei que acessa, ja comecei a ler um pouco sobre maps cara
eu usei set para nao deixar inserir contato repetido na lista…
fazendo o uso do valor booleano retornado pelo metodo add
você tem algo pronto aí ja?
Porque creio que a idéia seja correr a lista de Contato, buscando pelo atributo informado. Vamos supor que a busca é por nome, aí faz assim:for(Contato contato : listaContatos){
if(contato.getNome().equals(nomeInformado)){
System.out.println(contato);
}
}
Supondo que a variável nomeInformado possui a String que o usuário digitou. Não sei se isso é muito avançado para o que você está acostumado, você ja percorreu arrays, listas?
você tem algo pronto aí ja?Porque creio que a idéia seja correr a lista de Contato, buscando pelo atributo informado. Vamos supor que a busca é por nome, aí faz assim:
for(Contato contato : listaContatos){ if(contato.getNome().equals(nomeInformado)){ System.out.println(contato); } }Supondo que a variável nomeInformado possui a String que o usuário digitou. Não sei se isso é muito avançado para o que você está acostumado, você ja percorreu arrays, listas?
ter algo pronto tenho mas resolvi refazer meu trabalho ainda mais que a faculdade entrou de greve acho que terei bastante tempo para ver isso
sobre o q vc passou é um for each que eu ja li no deitel e ontem fiz de exemplo
problema de que estou aprendendo e me sinto as vezes perdido para fazer um trabalho bem organizado e usando bem a linguagem por isso pedi a ajuda
por exemplo o cara la em cima pediu para eu colocar um arraylist da classe telefone dentro da classe contato
queria dicas da moçada que sabe bem mais q eu
vi aqui o problema do map eu estava coloando tipo primitivo
Muito bem então.
A idéia do Map era pra caso você tivesse uma chave fixa pra buscar seu objeto, mas como você tem que conseguir buscar por mais de uma chave, acho melhor você iterar um por um. Fica mais simples.
você precisa de um mecanismo de controle pra saber qual chave será usada no momento, se é o nome ou qualquer uma das outras.
entao tenho q sim
mas pensei outra coisa
tive uma ideia usar um treemap pegando o seguinte
pelo que entendi o treemap poe na ordem de inserção
estou correto?
irei associar fazer assim
codigo do contato com telefone, entendeu?
Muito bem então.A idéia do Map era pra caso você tivesse uma chave fixa pra buscar seu objeto, mas como você tem que conseguir buscar por mais de uma chave, acho melhor você iterar um por um. Fica mais simples.
você precisa de um mecanismo de controle pra saber qual chave será usada no momento, se é o nome ou qualquer uma das outras.
a saida do arquivo seria essa
Arquivo? que arquivo?
Você tem o enunciado desse problema aí? Fica mais fácil se eu souber exatamente o que você precisa.
Arquivo? que arquivo?Você tem o enunciado desse problema aí? Fica mais fácil se eu souber exatamente o que você precisa.
Crie um projeto Java para implementar uma agenda telefônica simples
Cada contato deve possuir Número sequencial de cadastro, Nome, Cidade, um ou mais
telefones e endereço de e-mail. Permita ao usuário inserir, remover e mostrar os contatos
da agenda. Além disso, implemente filtros para pesquisar os contatos por Nome, Cidade ou
endereço de e-mail
Fique atento a algumas regras (utilize tratamento de exceções sempre que possível) para:
? nenhum dos atributos do contato pode ser cadastrado em branco
? se não houver nenhum contato, não deve ser mostrado nada
? não permitir contatos em duplicidade
? definir que cada contato pode ter um ou mais telefones de contato (não existe limite)
Ao final, permita também que o usuário, caso queira, possa exportar a lista de contatos para
um arquivo texto com o nome de ?contatos.txt? com o seguinte formato:
não tinha um exercício assim no spoj? hehehe
bom, idependente disso, esse exercício é bem completo hein, cara… Por que você não tenta começar a implementação, e quando forem surgindo erros/dúvidas você vai postando aqui, vai fazendo do seu jeito mesmo, que você pode postar aqui e o pessoal te ajuda a refatorar depois, caso seja necessário. Já use a dica do gabrielfrios.
não tinha um exercício assim no spoj? hehehebom, idependente disso, esse exercício é bem completo hein, cara… Por que você não tenta começar a implementação, e quando forem surgindo erros/dúvidas você vai postando aqui, vai fazendo do seu jeito mesmo, que você pode postar aqui e o pessoal te ajuda a refatorar depois, caso seja necessário. Já use a dica do gabrielfrios.
pois é não sei de onde meu professor tirou isso kkk…
mas vou verificar aqui…
vlw
não tinha um exercício assim no spoj? hehehebom, idependente disso, esse exercício é bem completo hein, cara… Por que você não tenta começar a implementação, e quando forem surgindo erros/dúvidas você vai postando aqui, vai fazendo do seu jeito mesmo, que você pode postar aqui e o pessoal te ajuda a refatorar depois, caso seja necessário. Já use a dica do gabrielfrios.
pois é não sei de onde meu professor tirou isso kkk…
mas vou verificar aqui…
vlw
quando você fala sobre implementar meu codigo, existe algo que eu possa ler para melhorar minhas ideias?
sobre como estruturar meu programa?
quando você fala sobre implementar meu codigo, existe algo que eu possa ler para melhorar minhas ideias?sobre como estruturar meu programa?
Se isso está te causando muita confusão, sugiro que volte para o começo, reforce a base do seu conhecimento em Orientação a Objetos, que vai te ajudar muito.
Sugiro que leia alguma apostila como essa da Caelum, que é sobre Java e Orientação a Objetos, ela é bem simples, fácil de entender e tem muitos exemplos e desafios.
quando você fala sobre implementar meu codigo, existe algo que eu possa ler para melhorar minhas ideias?sobre como estruturar meu programa?
Se isso está te causando muita confusão, sugiro que volte para o começo, reforce a base do seu conhecimento em Orientação a Objetos, que vai te ajudar muito.
Sugiro que leia alguma apostila como essa da Caelum, que é sobre Java e Orientação a Objetos, ela é bem simples, fácil de entender e tem muitos exemplos e desafios.
humildemente falando estou no capitulo 10 do livro do deitel…
acho que o problema não seria criar classes e essas coisas…
mas estou preocupado com esse negocio de colecoes…
ontem estive pensando o dia todo sobre meu problema e cheguei a seguinte ideia…
gostaria da opiniao
irei usar um map<codigo do numero, numero do telefone> para a lista de telefones
talvez um set ou map <codigo do contato,dados do contato> para o contato
e irei associar em outro map os 2 maps…
o que acham da minha ideia?
refiz ontem meu projeto, a classe que cria contato deixei assim
package modelo;
import java.util.HashMap;
public class Contato {
private String nome;
private String cidade;
private String email;
private HashMap<Integer, String> listaTel;
public Contato(String nome, String cidade, String email,
HashMap<Integer, String> listaTel) {
setNome(nome);
setCidade(cidade);
setEmail(email);
setListaTel(listaTel);
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getCidade() {
return cidade;
}
public void setCidade(String cidade) {
this.cidade = cidade;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public HashMap<Integer, String> getListaTel() {
return listaTel;
}
public void setListaTel(HashMap<Integer, String> listaTel) {
this.listaTel = listaTel;
}
public String toString() {
return ("Nome: " + this.getNome() + "\n" + "Cidade: "
+ this.getCidade() + "\n" + "Fones: " + this.getListaTel()
+ "\n" + "Email: " + this.getEmail());
}
}
a classe que adciona telefone
package visao;
import java.util.HashMap;
import java.util.Scanner;
import controle.ExcessaoCampoEmBranco;
public class AddTel {
private int cod;
private int op;
private String tel;
private Scanner input = new Scanner(System.in);
private HashMap<Integer, String> listaTel = new HashMap<Integer, String>();
public HashMap<Integer, String> AddTelefone() throws ExcessaoCampoEmBranco {
this.op = perguntarUsuario();
while (this.op != 0) {
this.cod++;
try {
System.out.printf("Digite o telefone %d do contato: ", cod);
this.tel = input.next();
if (this.tel.isEmpty()) {
throw new ExcessaoCampoEmBranco();
}
this.listaTel.put(new Integer(this.cod), this.tel);
System.out.println("Telefone adicionado");
} catch (ExcessaoCampoEmBranco e) {
e.getMessage("Telefone");
e.printStackTrace();
}
System.out.println("Deseja adicionar outro telefone?");
this.op = perguntarUsuario();
}
return (listaTel);
}
private int perguntarUsuario() {
System.out.println("Digite 1 para adicionar um telefone ao contato");
System.out.println("Digite 0 para sair");
System.out.print("Digite a opcao: ");
return input.nextInt();
}
}
a classe que adiciona o contato
package visao;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;
import modelo.Contato;
import controle.ExcessaoCampoEmBranco;
import controle.ExcessaoRegistroDuplicado;
public class AddCon {
private int cod;
private int op;
private String nome;
private String cidade;
private String email;
private Scanner input = new Scanner(System.in);
private HashMap<Integer, Contato> listaContato = new HashMap<Integer, Contato>();
private static HashSet<String> listaNome = new HashSet<String>();
public HashMap<Integer, Contato> AddContato() throws ExcessaoCampoEmBranco,
ExcessaoRegistroDuplicado {
op = perguntarUsuario();
while (op != 0) {
cod++;
try {
System.out.printf("Digite o nome do contato %d: ", cod);
this.nome = input.next();
System.out.printf("Digite a cidade do contato %d: ", cod);
this.cidade = input.next();
System.out.printf("Digite o email do contato %d: ", cod);
this.email = input.next();
if (!listaNome.add(nome)) {
throw new ExcessaoRegistroDuplicado();
}
if (nome.isEmpty()) {
throw new ExcessaoCampoEmBranco();
}
listaContato.put(new Integer(cod), new Contato(this.nome,
this.cidade, this.email, new AddTel().AddTelefone()));
System.out.println("Contato adicionado");
} catch (ExcessaoRegistroDuplicado e) {
this.cod--;
System.out.println(e.getMessage(this.nome));
} catch (ExcessaoCampoEmBranco e) {
System.out.println(e.getMessage("contato"));
}
System.out.println("Deseja adicionar outro contato?");
op = perguntarUsuario();
}
return listaContato;
}
private int perguntarUsuario() {
System.out.println("Digite 1 para adicionar um contato");
System.out.println("Digite 0 para sair");
System.out.print("Digite a opcao: ");
return input.nextInt();
}
}
e a classe que map do contato…
package persistencia;
import java.util.HashMap;
import modelo.Contato;
public class MapContato {
private HashMap<Integer, Contato> mapContato;
public MapContato() {
}
public HashMap<Integer, Contato> getMapContato() {
return mapContato;
}
public void setMapContato(HashMap<Integer, Contato> mapContato) {
this.mapContato = mapContato;
}
public String toString() {
return "Sequencia: " + getMapContato().keySet()+ "\n"
+ getMapContato().entrySet();
}
}
gostaria da opinião, se fiz certo…
estou com duvidas sobre métodos to string…para mostrar na tela para o usuário o resultado todo da coleção
qq posso melhorar…
obrigado
Então o ideal seria você fazer com métodos o que fez com as classes.
Ao invés de ter uma classe que adiciona um telefone, ou uma classe que adiciona um contato, fazer tudo orientado a objetos, cada Classe tendo os atributos e comportamentos que tem que ter.
Ex: Crie uma classe Agenda que possui uma lista de contatos, mais ou menos assim:public class Agenda{
private Map<Integer, Contato> contatos;
public void adicionarContato(Contato contato){
/* Aqui você faz todo o processamento necessário para se adicionar um contato
* à lista que você tem como atributo dessa classe, ou seja,
* o que você fazia na classe AddCon
*/
}
// outros métodos da classe.
}
// E o mesmo na classe Contato
public class Contato{
private String nome;
private String cidade;
private String email;
private Map<Integer, String> listaTel;
public void adicionarTelefone(String telefone){
/* Aqui você faz todo o processamento necessário para se adicionar um telefone
* à lista que você tem como atributo dessa classe, ou seja,
* o que você fazia na classe AddTel
*/
}
// outros métodos da classe
}
Então o ideal seria você fazer com métodos o que fez com as classes.Ao invés de ter uma classe que adiciona um telefone, ou uma classe que adiciona um contato, fazer tudo orientado a objetos, cada Classe tendo os atributos e comportamentos que tem que ter.
Ex: Crie uma classe Agenda que possui uma lista de contatos, mais ou menos assim:Deu pra entender? Os comportamentos que você criou classes para implementar, deveriam ser implementados em métodos.public class Agenda{ private Map<Integer, Contato> contatos; public void adicionarContato(Contato contato){ /* Aqui você faz todo o processamento necessário para se adicionar um contato * à lista que você tem como atributo dessa classe, ou seja, * o que você fazia na classe AddCon */ } // outros métodos da classe. } // E o mesmo na classe Contato public class Contato{ private String nome; private String cidade; private String email; private Map<Integer, String> listaTel; public void adicionarTelefone(String telefone){ /* Aqui você faz todo o processamento necessário para se adicionar um telefone * à lista que você tem como atributo dessa classe, ou seja, * o que você fazia na classe AddTel */ } // outros métodos da classe }
Cara a mp que te mandei era pq eu terminei o trabalho e refiz ele todo esses dias...
Vc tem interesse em ver o resultado "final"?
Vlw
Se quiser poste aqui como ele ficou estruturado, pra poder servir de exemplo.
macario1983, não vi nem 10% do tópico, vi apenas que no seu código tem método recebendo e retornando implementações de interface. Isso não é uma boa pratica de programação. Vamos imaginar que você tem um método que retorne um HashMap (você tem…). Há 100 classes que usam esse método, ok ?
Agora imagina que você esteja tendo problemas de ordenação, precisa que o map mantenha a ordem de inserção, ops, o LinkedHashMap resolve isso. O que tu faz agora ?
Altera o retorno para LinkedHashMap e todas as 100 classes que executam a chamada ? Por isso, o ideal é programar orientado a interfaces, no seu caso, seria receber e retornar um Map.
P.s: é uma dica, não sei se já alterou isso…
pacote controle
package controle;
public class AgendaVaziaException extends Exception{
private final String mensagem = "\nA agenda telefonica não possui contatos";
@Override
public String getMessage() {
return mensagem;
}
}
package controle;
public class RegistroDuplicadoException extends Exception {
public String getMessage(String contato) {
return "\nO contato " + contato + " já se encontra cadastrado na agenda\n" +
"Sendo assim o cadastro foi cancelado";
}
}
package controle;
public class CampoBrancoException extends Exception {
private final String mensagem = "\nPreencha o campo ";
public String getMessage(String campo) {
return mensagem + campo;
}
}
pacote modelo
package modelo;
public class Telefone {
private String telefone;
// construtor ja recebe como parametros os dados da classe
public Telefone(String telefone) {
setTelefone(telefone);
}
public String getTelefone() {
return telefone;
}
public void setTelefone(String telefone) {
this.telefone = telefone;
}
public String toString() {
return getTelefone();
}
}
package modelo;
import java.util.Map;
import java.util.Map.Entry;
public class Contato {
private String nome;
private String cidade;
private String email;
private Map<Integer, Telefone> listaTelefone;
// construtor ja recebe como parametros os dados da classe
public Contato(String nome, String cidade, String email,
Map<Integer, Telefone> listaTelefone) {
setNome(nome);
setCidade(cidade);
setEmail(email);
setListaTelefone(listaTelefone);
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getCidade() {
return cidade;
}
public void setCidade(String cidade) {
this.cidade = cidade;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getListaTelefone() {
StringBuilder lista = new StringBuilder();
int tam_max = listaTelefone.size() - 1;
int i = 0;
for (Entry<Integer, Telefone> entry : listaTelefone.entrySet()) {
lista.append(entry).append((i < tam_max) ? " --- " : " " );
i++;
}
return lista.toString();
}
public void setListaTelefone(Map<Integer, Telefone> listaTelefone) {
this.listaTelefone = listaTelefone;
}
}
pacote persistencia
package persistencia;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import modelo.Contato;
import visao.Alterar;
import visao.Excluir;
import visao.Inserir;
import visao.Pesquisar;
import controle.AgendaVaziaException;
import controle.CampoBrancoException;
import controle.RegistroDuplicadoException;
public class MapContato {
private Map<Integer, Contato> mapContato;
// construtor que criar o mapcontato ao criar a classe
public MapContato() {
mapContato = new HashMap<>();
}
public Map<Integer, Contato> getMapContato() {
return mapContato;
}
public void setMapContato(Map<Integer, Contato> mapContato) {
this.mapContato = mapContato;
}
// metodo para adicionar contato
public void adicionar() throws CampoBrancoException,
RegistroDuplicadoException {
new Inserir().inserir(getMapContato());
}
public void alterar() throws CampoBrancoException,
RegistroDuplicadoException, AgendaVaziaException {
new Alterar().alterar(getMapContato());
}
public void excluir() throws AgendaVaziaException {
new Excluir().excluirContato(getMapContato());
}
public void gravarAgenda() throws IOException, AgendaVaziaException {
new Gravar().gravarArquivo(getMapContato());
}
public void pesquisar() throws AgendaVaziaException {
new Pesquisar().pesquisar(getMapContato());
}
@Override
public String toString() {
StringBuilder lista = new StringBuilder();
String newline = "";
for (Integer keySet : mapContato.keySet()) {
Contato contato = mapContato.get(keySet);
lista.append(newline).append("Sequencial: " + keySet)
.append("\nNome: " + contato.getNome())
.append("\nCidade: " + contato.getCidade())
.append("\nFones: " + contato.getListaTelefone())
.append("\nEmail: " + contato.getEmail());
newline = " \n\n";
}
return lista.toString();
}
}
package persistencia;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Map;
import java.util.Scanner;
import modelo.Contato;
import controle.AgendaVaziaException;
public class Gravar {
private final static String PATH = "C:/Agenda/agenda.txt";
private final static Charset CHARSET = StandardCharsets.UTF_8;
private static Scanner input = new Scanner(System.in);
public void gravarArquivo(Map<Integer, Contato> mapContato)
throws IOException, AgendaVaziaException {
try {
if (mapContato.isEmpty()) {
throw new AgendaVaziaException();
}
Path caminho = Paths.get(PATH);
if (!Files.exists(caminho)) {
Files.createFile(caminho);
escreverArquivo(mapContato);
} else {
System.out.print("Deseja reescreve o arquivo (S/N)?: ");
if (input.next().toUpperCase().equals("S")) {
escreverArquivo(mapContato);
}
}
} catch (AgendaVaziaException e) {
System.out.println(e.getMessage());
}
}
private void escreverArquivo(Map<Integer, Contato> mapContato)
throws IOException {
BufferedWriter w = Files.newBufferedWriter(Paths.get(PATH), CHARSET);
PrintWriter print = new PrintWriter(w);
for (Integer keySet : mapContato.keySet()) {
Contato c = mapContato.get(keySet);
print.println("Sequencial: " + keySet +
"\r\nNome: " + c.getNome() +
"\r\nCidade: " + c.getCidade() +
"\r\nFones: " + c.getListaTelefone() +
"\r\nEmail: " + c.getEmail() + "\r\n");
}
print.close();
w.close();
System.out.println("\nArquivo gerado com sucesso!");
}
}
pacote visao
package visao;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import modelo.Contato;
import modelo.Telefone;
import controle.CampoBrancoException;
import controle.RegistroDuplicadoException;
public class Dados {
public Contato dadosContato(Map<Integer, Contato> mapContato)
throws CampoBrancoException, RegistroDuplicadoException {
return new DadosContato().setDados(mapContato);
}
}
class DadosContato {
private Scanner input = new Scanner(System.in);
protected Contato setDados(Map<Integer, Contato> mapContato)
throws CampoBrancoException, RegistroDuplicadoException {
String nome = "";
String cidade = "";
String email = "";
try {
System.out.print("\nDigite o nome do contato: ");
nome = input.next();
if (isDuplicado(isEmpty(nome), getListaNomes(mapContato))) {
throw new RegistroDuplicadoException();
}
System.out.print("Digite a cidade do contato: ");
cidade = input.next();
System.out.print("Digite o email do contato: ");
email = input.next();
return new Contato(nome, cidade, email, new DadosTelefone().inserir());
} catch (RegistroDuplicadoException e) {
System.out.println(e.getMessage(nome));
}
return null;
}
private String isEmpty(String nome) {
try {
if (nome.isEmpty()) {
throw new CampoBrancoException();
}
} catch (CampoBrancoException e) {
System.out.println(e.getMessage("contato"));
e.printStackTrace();
}
return nome;
}
private Set<String> getListaNomes(Map<Integer, Contato> mapContato) {
Set<String> nomes = new HashSet<String>();
if (mapContato != null) {
for (Integer entry : mapContato.keySet()) {
nomes.add(mapContato.get(entry).getNome());
}
}
return nomes;
}
private boolean isDuplicado(String nome, Set<String> getListaNomes) {
Set<String> listaNome = getListaNomes;
boolean isduplicado = false;
if (!listaNome.add(nome)) {
isduplicado = true;
}
return isduplicado;
}
}
class DadosTelefone {
private Scanner input = new Scanner(System.in);
protected Map<Integer, Telefone> inserir() throws CampoBrancoException {
int cod = 0;
String op = "S";
Map<Integer, Telefone> mapTelefone = new HashMap<Integer, Telefone>();
System.out.print("Adicionar um telefone ao contato (S/N): ");
op = input.next();
while (op.toUpperCase().equals("S")) {
mapTelefone.put(new Integer(++cod), setTelefone());
System.out.println("Telefone adicionado");
System.out.print("Deseja adicionar outro telefone (S/N)?: ");
op = input.next();
}
return mapTelefone;
}
private String setDados() {
System.out.print("Digite o telefone do contato: ");
return (input.next());
}
private String isEmpty(String tel) {
try {
if (tel.isEmpty()) {
throw new CampoBrancoException();
}
} catch (CampoBrancoException e) {
System.out.println(e.getMessage("telefone"));
e.printStackTrace();
}
return tel;
}
private Telefone setTelefone() throws CampoBrancoException {
return new Telefone(isEmpty(setDados()));
}
}
package visao;
import java.util.Map;
import java.util.Scanner;
import modelo.Contato;
import controle.AgendaVaziaException;
import controle.CampoBrancoException;
import controle.RegistroDuplicadoException;
public class Alterar {
public void alterar(Map<Integer, Contato> mapContato)
throws CampoBrancoException, RegistroDuplicadoException {
new AlteraContato().alterarContato(mapContato);
}
}
class AlteraContato extends Dados {
private static Scanner input = new Scanner(System.in);
public void alterarContato(Map<Integer, Contato> mapContato)
throws CampoBrancoException, RegistroDuplicadoException {
try {
if (mapContato.isEmpty()) {
throw new AgendaVaziaException();
}
String op = "S";
int key = 0;
key = new Pesquisar().pesquisarIndice(mapContato);
if (key != 0) {
System.out.print("Deseja alterar o contato (S/N)?: ");
op = input.next();
if (op.toUpperCase().equals("S")) {
Contato contato = mapContato.get(key);
new Mostrar().mostrarFormatado(key, contato);
contato = dadosContato(mapContato);
if (contato != null) {
mapContato.remove(key);
mapContato.put(new Integer(key), contato);
System.out.println("Contato alterado");
}
}
} else {
System.out.println("Contato não localizado");
}
} catch (AgendaVaziaException e) {
System.out.println(e.getMessage());
}
}
}
package visao;
import java.util.Map;
import java.util.Scanner;
import modelo.Contato;
import controle.CampoBrancoException;
import controle.RegistroDuplicadoException;
public class Inserir {
public void inserir(Map<Integer, Contato> mapContato)
throws CampoBrancoException, RegistroDuplicadoException {
new InsereContato().inserirNovo(mapContato);
}
}
class InsereContato extends Dados {
private Scanner input = new Scanner(System.in);
private static int cod = 0;
protected Map<Integer, Contato> inserirNovo(Map<Integer, Contato> mapContato)
throws CampoBrancoException, RegistroDuplicadoException {
String op = "S";
while (op.toUpperCase().equals("S")) {
Contato contato = dadosContato(mapContato);
if (contato != null){
mapContato.put(new Integer(++cod), contato);
System.out.println("Contato adicionado");
}
System.out.print("Deseja adicionar outro contato (S/N)?: ");
op = input.next();
}
return mapContato;
}
}
package visao;
import java.util.Map;
import modelo.Contato;
import controle.AgendaVaziaException;
public class Excluir {
public void excluirContato(Map<Integer, Contato> mapContato) {
try {
if (mapContato.isEmpty()) {
throw new AgendaVaziaException();
}
Contato contato = mapContato.remove(new Pesquisar().pesquisarIndice(mapContato));
System.out.println(contato != null ? "Contato removido" : "Contato não localizado");
} catch (AgendaVaziaException e) {
System.out.println(e.getMessage());
}
}
}
package visao;
import modelo.Contato;
public class Mostrar {
public void mostrarFormatado(int key, Contato contato) {
System.out.print("\nSequencial: " + key +
"\nNome: " + contato.getNome() +
"\nCidade: " + contato.getCidade() +
"\nFones: " + contato.getListaTelefone() +
"\nEmail: " + contato.getEmail() + "\n");
}
}
package visao;
import java.util.Map;
import java.util.Scanner;
import controle.AgendaVaziaException;
import modelo.Contato;
public class Pesquisar {
private static Scanner input = new Scanner(System.in);
public void pesquisar(Map<Integer, Contato> mapContato) {
try {
if (mapContato.isEmpty()) {
throw new AgendaVaziaException();
}
System.out.println("Digite algum dado referente ao contato: ");
String nome = input.next();
int i = 0;
for (Integer entrySet : mapContato.keySet()) {
Contato contato = mapContato.get(entrySet);
if (contato.getNome().equals(nome)
|| contato.getCidade().equals(nome)
|| contato.getEmail().equals(nome)) {
new Mostrar().mostrarFormatado(entrySet, contato);
i++;
}
}
System.out.println((i != 0) ? "Foram localizados " + i + " contato(s)": "Não foram localizados contato(s)");
} catch (AgendaVaziaException e) {
System.out.println(e.getMessage());
}
}
public int pesquisarIndice(Map<Integer, Contato> mapContato) {
System.out.print("Digite algum dado referente ao contato: ");
String nome = input.next();
for (Integer keySet : mapContato.keySet()) {
Contato contato = mapContato.get(keySet);
if (contato.getNome().equals(nome)
|| contato.getCidade().equals(nome)
|| contato.getEmail().equals(nome)) {
return keySet;
}
}
return 0;
}
}
package visao;
import java.util.Scanner;
public class Menu {
public static int menuAplicacao() {
Scanner input = new Scanner(System.in);
System.out.println("\nAgenda de contatos\n");
System.out.println("1 - Adicionar contato(s)");
System.out.println("2 - Alterar contato");
System.out.println("3 - Excluir contato");
System.out.println("4 - Mostrar contatos");
System.out.println("5 - Pesquisar");
System.out.println("6 - Gravar");
System.out.println("7 - Sair");
System.out.print("Digite a opção: ");
return input.nextInt();
}
}
package visao;
import java.io.IOException;
import persistencia.MapContato;
import controle.AgendaVaziaException;
import controle.CampoBrancoException;
import controle.RegistroDuplicadoException;
public class Principal {
public static void main(String[] args) throws CampoBrancoException,
RegistroDuplicadoException, IOException, AgendaVaziaException {
MapContato mapContato = new MapContato();
int op = -1;
while (op != 7) {
op = Menu.menuAplicacao();
switch (op) {
case 1:
mapContato.adicionar();
break;
case 2:
mapContato.alterar();
break;
case 3:
mapContato.excluir();
break;
case 4:
System.out.println("\n" + mapContato);
break;
case 5:
mapContato.pesquisar();
break;
case 6:
mapContato.gravarAgenda();
break;
case 7:
System.out.println("Programa finalizado");
break;
default:
System.out.println("Opção inválida");
break;
}
}
}
}
bom tentei refatorar as classes, deixar mais separadas e conversando metodos e classes…
é isso…
macario1983, não vi nem 10% do tópico, vi apenas que no seu código tem método recebendo e retornando implementações de interface. Isso não é uma boa pratica de programação. Vamos imaginar que você tem um método que retorne um HashMap (você tem…). Há 100 classes que usam esse método, ok ?Agora imagina que você esteja tendo problemas de ordenação, precisa que o map mantenha a ordem de inserção, ops, o LinkedHashMap resolve isso. O que tu faz agora ?
Altera o retorno para LinkedHashMap e todas as 100 classes que executam a chamada ? Por isso, o ideal é programar orientado a interfaces, no seu caso, seria receber e retornar um Map.P.s: é uma dica, não sei se já alterou isso…
nel eu sei q devo usar desta forma mais genérica só não imaginava q uma situação seria essa sabe…
vlw pela ideia…o código esta acima para ser criticado…
vlw
Não tem como eu olhar todo o projeto e fazer críticas, até porque não tenho tempo hábil. Mas já vi algo “errado” ali . O método escrever arquivo pode gerar uma IOException e manter aberto a leitura de arquivo. Por isso, é de boa prática que use um bloco finally para validar algo assim. Exemplo:
InputStream is = null;
try {
is = new FileInputStream("teste.txt");
// faz qlqr coisa
} catch (IOException ex) {
//trata como quiser...
} finally {
if (null != is)
is.close();
}
Veja se não há mais casos em seu projeto que necessitem deste tipo de tratamento.
Não tem como eu olhar todo o projeto e fazer críticas, até porque não tenho tempo hábil. Mas já vi algo “errado” ali . O método escrever arquivo pode gerar uma IOException e manter aberto a leitura de arquivo. Por isso, é de boa prática que use um bloco finally para validar algo assim. Exemplo:
InputStream is = null; try { is = new FileInputStream("teste.txt"); // faz qlqr coisa } catch (IOException ex) { //trata como quiser... } finally { if (null != is) is.close(); }Veja se não há mais casos em seu projeto que necessitem deste tipo de tratamento.
eu tratei as demais q o exercicio pedi mas essa eu n tratei pq imaginei q o eclipse poderia sugerir…irei fazer essa alteração cara…
Não tem como eu olhar todo o projeto e fazer críticas, até porque não tenho tempo hábil. Mas já vi algo “errado” ali . O método escrever arquivo pode gerar uma IOException e manter aberto a leitura de arquivo. Por isso, é de boa prática que use um bloco finally para validar algo assim. Exemplo:
InputStream is = null; try { is = new FileInputStream("teste.txt"); // faz qlqr coisa } catch (IOException ex) { //trata como quiser... } finally { if (null != is) is.close(); }Veja se não há mais casos em seu projeto que necessitem deste tipo de tratamento.
eu tratei as demais q o exercicio pedi mas essa eu n tratei pq imaginei q o eclipse poderia sugerir…irei fazer essa alteração cara…
É que é um simples exercício, mas quando desenvolver sistemas reais, esse tipo de tratamento é essencial, por isso demonstrei á você. O Eclipse não sugere isso (ao menos nunca sugeriu pra mim), ele indica tratamento com os try-catch somente. Mas enfim, está dada a dica.
O que eu falei acima ainda é válido pro seu projeto na minha opinião, sobre usar métodos ao invés de classes.
Você poderia ao invés de ter as classes: Inserir, Alterar, Excluir, etc.
criar uma classe DAO, que possui os métodos: inserir(), alterar(), excluir(), etc.
O que eu falei acima ainda é válido pro seu projeto na minha opinião, sobre usar métodos ao invés de classes.Você poderia ao invés de ter as classes: Inserir, Alterar, Excluir, etc.
criar uma classe DAO, que possui os métodos: inserir(), alterar(), excluir(), etc.
mas essa classe não ira ficar extensa demais não cara?
O que eu falei acima ainda é válido pro seu projeto na minha opinião, sobre usar métodos ao invés de classes.Você poderia ao invés de ter as classes: Inserir, Alterar, Excluir, etc.
criar uma classe DAO, que possui os métodos: inserir(), alterar(), excluir(), etc.
Não percebi esse datalhe. Concordo plenamente. Se eu fosse criar para cada método no meu EJB uma classe, eu estava perdido.
O que eu falei acima ainda é válido pro seu projeto na minha opinião, sobre usar métodos ao invés de classes.Você poderia ao invés de ter as classes: Inserir, Alterar, Excluir, etc.
criar uma classe DAO, que possui os métodos: inserir(), alterar(), excluir(), etc.
mas essa classe não ira ficar extensa demais não cara?
O que é uma classe extensa, para você ?
O que eu falei acima ainda é válido pro seu projeto na minha opinião, sobre usar métodos ao invés de classes.Você poderia ao invés de ter as classes: Inserir, Alterar, Excluir, etc.
criar uma classe DAO, que possui os métodos: inserir(), alterar(), excluir(), etc.
mas essa classe não ira ficar extensa demais não cara?
O que é uma classe extensa, para você ?
com mt codigo…
calma pessoal…sobre esse framework ejb e tudo mais…eu so tenho 3 meses que to nisso…
claro q se vc me disserem qq eu deva aplicar irei estudar…
para deixar o codigo mais dividido…
Eu concordo com você que a responsabilidade tem que ser dividida, e algumas classes são criadas para tal.
O padrão DAO, define uma Classe que será usada para controlar as operações de persistência, ou seja, o CRUD.
então tudo o que for relacionado à essas operações ficaria centralizado em uma única classe, com seus métodos, onde você envia uma Entidade, e o DAO se “preocupa” com como vai tratá-la para as operações, assim você deixa seu código com acoplamento mais baixo, uma classe não “depende” da outra para seu funcionamento.
Por que você não faz esse exercício? Crie um DAO e implemente os métodos nele, não se preocupe que a classe não vai ficar extensa, ela vai ter o tamanho que precisa ter.
Leia também sobre o padrão DAO e sobre o padrão MVC.
Não tem como eu olhar todo o projeto e fazer críticas, até porque não tenho tempo hábil. Mas já vi algo “errado” ali . O método escrever arquivo pode gerar uma IOException e manter aberto a leitura de arquivo. Por isso, é de boa prática que use um bloco finally para validar algo assim. Exemplo:
InputStream is = null; try { is = new FileInputStream("teste.txt"); // faz qlqr coisa } catch (IOException ex) { //trata como quiser... } finally { if (null != is) is.close(); }Veja se não há mais casos em seu projeto que necessitem deste tipo de tratamento.
eu tratei as demais q o exercicio pedi mas essa eu n tratei pq imaginei q o eclipse poderia sugerir…irei fazer essa alteração cara…
É que é um simples exercício, mas quando desenvolver sistemas reais, esse tipo de tratamento é essencial, por isso demonstrei á você. O Eclipse não sugere isso (ao menos nunca sugeriu pra mim), ele indica tratamento com os try-catch somente. Mas enfim, está dada a dica.
fiz a correção conforme sugerida por vc, como diria meu professor, dando maior robustes ao programa…
vlw
Eu concordo com você que a responsabilidade tem que ser dividida, e algumas classes são criadas para tal.
O padrão DAO, define uma Classe que será usada para controlar as operações de persistência, ou seja, o CRUD.
então tudo o que for relacionado à essas operações ficaria centralizado em uma única classe, com seus métodos, onde você envia uma Entidade, e o DAO se “preocupa” com como vai tratá-la para as operações, assim você deixa seu código com acoplamento mais baixo, uma classe não “depende” da outra para seu funcionamento.
Por que você não faz esse exercício? Crie um DAO e implemente os métodos nele, não se preocupe que a classe não vai ficar extensa, ela vai ter o tamanho que precisa ter.
Leia também sobre o padrão DAO e sobre o padrão MVC.
digaoneves eu ja senti assim olhando pro meu projeto algo estranho, muitas classes em um mesmo pacote é estranho sabe…mas como eu disse ainda to inicio, irei ler sobre DAO, MVC conforme sugerido…
cara vc falando assim da impressão que eu n fiz o exercício kkkk…
Pois é, tentei refatorar o primeiro trabalho deixando mais divido as coisas sabe…
Pra ficar mais organizado e melhor distribuído e deixando tb os métodos menores…
O professor pretendia nos ensinar o padrão DAO, mas a faculdade entrou de greve to tendo que contar com a ajuda da moçada para coisas q estou em duvida sabe…
Obrigado pela ajuda ai galera
Hehehe, eu quis dizer o exercício de transformar essas Classes que você criou em um DAO.
Hehehe, eu quis dizer o exercício de transformar essas Classes que você criou em um DAO.
é como eu te disse em uns posts atras, eu preciso aprender a desenvolver projeto, e implementar ele…
algo alem do q estou vendo agora…
estou fazendo um trabalho para a matéria de seminários sobre SCRUM e tem um pouco sobre isso…
sobre desenvolvimento de projeto…
andei procurando no youtube algo sobre os 2 padrões e não tem problemas caso envolver BD né? o importante seria eu pegar a essência destes padrões né…
mas e quanto aos método vc acha q ficou legal?
macario1983 citei o EJB porque eu uso aqui, não estou dizendo pra tu estudar isso. Foi só um exemplo. De resto, o que dissemos foi para ajuda-lo a melhorar seu código, não era essa a ideia?
Os dois envolvem persistência em algum ponto… na camada de Modelo do MVC, e o DAO é completamente relacionado a persistência, seja em banco de dados ou em arquivo como você fez.
Em relação aos métodos, não acho bom você interagir com o usuário no método de persistência como fez, receba toda a informação do usuário antes, na View, e no método gravar(), você faz exatamente o que o método diz que faz, grava. E mais nada.
sem problemas…
Os dois envolvem persistência em algum ponto… na camada de Modelo do MVC, e o DAO é completamente relacionado a persistência, seja em banco de dados ou em arquivo como você fez.Em relação aos métodos, não acho bom você interagir com o usuário no método de persistência como fez, receba toda a informação do usuário antes, na View, e no método gravar(), você faz exatamente o que o método diz que faz, grava. E mais nada.
Cara não entendi direito oq vc quiz dizer com isso sabe…
Eu pego os dados na visão (view) e jogo no metodo gravar…qual seria uma forma correta entao…
No seu método gravar você imprime uma mensagem na tela perguntando se o usuário quer ou não reescrever o arquivo, você precisa tratar isso antes, e somente chamar o método de gravar, quando quiser gravar.
bom assim, este projeto se minhas aulas voltarem rápido oq acho difícil irei entregar desse jeito MAS, já estou estudando o DAO aqui…vendo uns videos, po cara fica mais separado ainda do q eu fiz sabe…
mt melhor…
irei refazer meu projeto…igual o cara fez no video…
fazendo uma diagramação as classes com os atributos e metodos…
se eu conseguir fazer igual a moçada vai ficar show de bola…(espero eu)