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?
[quote=digaoneves]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.[/quote]
a saida do arquivo seria essa
Sequencial:1
Nome:NOME_DO_CONTATO
Cidade:CIDADE_DO_CONTATO
Fones:1=FONE_DO_CONTATO — 2=FONE_DO_CONTATO — 3=FONE_DO_CONTATO
Email:EMAIL_DO_CONTATO
Sequencial:2
Nome:NOME_DO_CONTATO
Cidade:CIDADE_DO_CONTATO
Fones:1=FONE_DO_CONTATO
Email:EMAIL_DO_CONTATO
Arquivo? que arquivo?
Você tem o enunciado desse problema aí? Fica mais fácil se eu souber exatamente o que você precisa.
[quote=digaoneves]Arquivo? que arquivo?
Você tem o enunciado desse problema aí? Fica mais fácil se eu souber exatamente o que você precisa.[/quote]
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.
[quote=digaoneves]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.[/quote]
pois é não sei de onde meu professor tirou isso kkk…
mas vou verificar aqui…
vlw
[quote=macario1983][quote=digaoneves]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.[/quote]
pois é não sei de onde meu professor tirou isso kkk…
mas vou verificar aqui…
vlw[/quote]
quando você fala sobre implementar meu codigo, existe algo que eu possa ler para melhorar minhas ideias?
sobre como estruturar meu programa?
[quote=macario1983]quando você fala sobre implementar meu codigo, existe algo que eu possa ler para melhorar minhas ideias?
sobre como estruturar meu programa?[/quote]
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.
[quote=digaoneves][quote=macario1983]quando você fala sobre implementar meu codigo, existe algo que eu possa ler para melhorar minhas ideias?
sobre como estruturar meu programa?[/quote]
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.[/quote]
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:[code]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
}[/code] Deu pra entender? Os comportamentos que você criou classes para implementar, deveriam ser implementados em métodos.
[quote=digaoneves]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:[code]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
}[/code] Deu pra entender? Os comportamentos que você criou classes para implementar, deveriam ser implementados em métodos.
[/quote]
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…
[quote=nel]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…[/quote]
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.
[quote=nel]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.[/quote]
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…
[quote=macario1983][quote=nel]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.[/quote]
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…[/quote]
É 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.