Você está aqui: Java ::: Dicas & Truques ::: Matemática e Estatística |
Como calcular porcentagem em Java - Eu tenho um valor de R$ 500,00 que aumentou para R$ 800,00. Qual foi o aumento percentual?Quantidade de visualizações: 740 vezes |
Nesta dica mostrarei como calcular a porcentagem do aumento sofrido por um determinado valor usando a linguagem Java. Este é um cenário muito comum. Veja a seguinte situação: a) Temos um produto x que custava R$ 500,00 e que foi aumentado para R$ 800,00. Queremos, dessa forma, descobrir o percentual de aumento que o preço do produto sofreu. Veja o código Java para a realização deste cálculo: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package estudos; import java.util.Scanner; public class Estudos{ public static void main(String[] args){ // vamos usar a classe Scanner para ler os dados Scanner entrada = new Scanner(System.in); // vamos ler o preço anterior e o novo preço System.out.print("Preço anterior do produto: "); double precoAnterior = Double.parseDouble(entrada.nextLine()); System.out.print("Preço atual do produto: "); double precoAtual = Double.parseDouble(entrada.nextLine()); double a = precoAnterior; double b = 100 * precoAtual; double c = b / a; double d = c - 100; System.out.println("A porcentagem de aumento foi: " + d + "%"); System.exit(0); } } Ao executar este código Java nós teremos um resultado parecido com: Preço anterior do produto: 500 Preço atual do produto: 800 A porcentagem de aumento foi: 60.0% |
![]() |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Java Básico |
Exercícios Resolvidos de Java - Uma locadora de charretes cobra R$ 10,00 de taxa para cada 3 horas de uso destasQuantidade de visualizações: 5989 vezes |
Exercício Resolvido de Java - Uma locadora de charretes cobra R$ 10,00 de taxa para cada 3 horas de uso destas Pergunta/Tarefa: Uma locadora de charretes cobra R$ 10,00 de taxa para cada 3 horas de uso destas e R$ 5,00 para cada 1 hora abaixo destas 3 horas. Faça um programa (algorítmo) Java que leia a quantidade de horas que a charrete foi usada, calcule e escreva o valor a ser pago pelo cliente. Sua saída deverá ser parecida com: Quantidade de horas que a charrete foi usada: 7 Valor total a ser pago: R$ 25,00 Veja a resolução comentada deste exercício usando Java console: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package exercicio; import java.text.NumberFormat; import java.util.Scanner; public class Exercicio { public static void main(String[] args) { // vamos fazer a leitura usando a classe Scanner Scanner entrada = new Scanner(System.in); // vamos ler a quantidade de horas que a charrete foi usada System.out.print("Quantidade de horas que a charrete foi usada: "); int horas = Integer.parseInt(entrada.nextLine()); // vamos calcular o valor por 3 horas exatas int valor = horas / 3; // valor a ser pago para cada hora abaixo de 3 int restante = horas % 3; // finalmente calculamos o valor total a ser pago double valor_total = (valor * 10.0) + (restante * 5); // e exibimos o resultado NumberFormat formato = NumberFormat.getCurrencyInstance(); System.out.println("Valor total a ser pago: " + formato.format(valor_total)); } } |
Java ::: Dicas & Truques ::: Trigonometria - Funções Trigonométricas |
Como obter o valor de PI em Java usando a constante Math.PIQuantidade de visualizações: 21191 vezes |
A constante PI, ou simplesmente PI, é o valor da razão entre a circunferência de qualquer círculo e seu diâmetro. Veja a figura abaixo para melhor entendimento:![]() Em Java, o PI pode ser obtido por meio do uso da constante PI da classe Math. Seu valor é algo como: 3,14159... Veja o trecho de código abaixo: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package arquivodecodigos; public class Estudos{ public static void main(String[] args){ // obtém e exibe o valor da constante PI System.out.println("O valor de PI é: " + Math.PI); System.exit(0); } } Ao executar este código nós teremos o seguinte resultado: O valor de PI é: 3.141592653589793 |
Java ::: Reflection (introspecção) e RTI (Runtime Type Information) ::: Passos Iniciais |
Saiba o que é Reflexão (Reflection) em Java - Como usar Reflexão (Reflection) na linguagem Java - RevisadoQuantidade de visualizações: 18348 vezes |
Reflection (ou Reflexão), também conhecida como RTI (Runtime Type Information) em algumas linguagens, é um mecanismo para descobrir dados a respeito de um programa em tempo de execução. Reflection em Java nos permite descobrir informações sobre atributos ou membros (campos), métodos e construtores de classes. Podemos também operar nos campos e métodos que descobrimos. A Reflection permite o que é normalmente chamada de programação dinâmica em Java. A Reflection em Java é conseguida usando a Java Reflection API. Esta API consiste de classes nos pacotes java.lang e java.lang.reflect. Antes de prosseguirmos, veja um exemplo de como podemos listar todos os métodos públicos da classe Object: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package arquivodecodigos; import java.lang.reflect.*; public class Estudos{ public static void main(String args[]){ // vamos carregar a classe Object try{ Class c = Class.forName("java.lang.Object"); // obtém os nomes dos métodos Method[] metodos = c.getMethods(); // exibe o nome de cada método for(int i = 0; i < metodos.length; i++){ System.out.println(metodos[i].getName()); } } catch(ClassNotFoundException e){ System.out.println(e.getMessage()); } System.exit(0); } } Ao executarmos este código nós teremos o seguinte resultado: wait wait wait equals toString hashCode getClass notify notifyAll Eis uma lista das coisas que podemos fazer com a Java Reflection API: 1) Determinar a classe de um objeto; 2) Obter informações sobre os modificadores, campos (atributos), métodos, construtores e superclasses de uma classe; 3) Descobrir quais constantes e declarações de métodos pertencem a uma interface; 4) Criar uma instância de uma classe cujo nome não sabemos até o tempo de execução; 5) Obter e definir o valor do campo de um objeto; 6) Invocar um método em um objeto; 7) Criar um novo array, cujo tamanho e tipo de dados só saberemos em tempo de execução. A Java Reflection API é geralmente usada para criar ferramentas de desenvolvimento tais como debuggers, class browsers e construtores de GUI. Geralmente, neste tipo de ferramentas, precisamos interagir como classes, objetos, métodos e campos, e não sabemos quais em tempo de compilação. Assim, a aplicação deve, dinamicamente, encontrar e acessar estes itens. Esta dica foi revisada e testada no Java 8. |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Estruturas de Controle |
Exercício Resolvido de Java - Escreva um programa Java que informa a quantidade de dias em um determinado mês e ano. Seu código deverá solicitar ao usuário o número correspondenteQuantidade de visualizações: 965 vezes |
Exercícios Resolvidos de Java - Escreva um programa Java que informa o número de dias em um determinado mês e ano. Seu código deverá solicitar ao usuário o número correspondente Pergunta/Tarefa: Escreva um programa Java que informa a quantidade de dias em um determinado mês e ano. Seu código deverá solicitar ao usuário o número correspondente ao mês, na faixa de 1 a 12, e o ano. Verifique também se o ano é bissexto ou não. Sua saída deverá ser parecida com: Informe o mês (1 - 12): 4 Informe o ano: 2022 Abril de 2022 possui 30 dias. Veja a resolução comentada deste exercício usando Java: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package estudos; import java.util.Scanner; public class Estudos { public static void main(String[] args) { // vamos usar a classe Scanner para ler a entrada do usuário Scanner entrada = new Scanner(System.in); // para guardar a quantidade de dias no mês int quantDiasNoMes = 0; // para o nome do mês String nomeMes = ""; // vamos ler o número do mês System.out.print("Informe o mês (1 - 12): "); int mes = Integer.parseInt(entrada.nextLine()); // vamos ler o ano System.out.print("Informe o ano: "); int ano = Integer.parseInt(entrada.nextLine()); // agora usamos um switch para tratar o mês informado switch (mes){ case 1: nomeMes = "Janeiro"; quantDiasNoMes = 31; break; case 2: nomeMes = "Fevereiro"; // é ano bissexto? if ((ano % 400 == 0) || ((ano % 4 == 0) && (ano % 100 != 0))) { quantDiasNoMes = 29; } else { quantDiasNoMes = 28; } break; case 3: nomeMes = "Março"; quantDiasNoMes = 31; break; case 4: nomeMes = "Abril"; quantDiasNoMes = 30; break; case 5: nomeMes = "Maio"; quantDiasNoMes = 31; break; case 6: nomeMes = "Junho"; quantDiasNoMes = 30; break; case 7: nomeMes = "Julho"; quantDiasNoMes = 31; break; case 8: nomeMes = "Agosto"; quantDiasNoMes = 31; break; case 9: nomeMes = "Setembro"; quantDiasNoMes = 30; break; case 10: nomeMes = "Outubro"; quantDiasNoMes = 31; break; case 11: nomeMes = "Novembro"; quantDiasNoMes = 30; break; case 12: nomeMes = "Desembro"; quantDiasNoMes = 31; break; } // mostra o resultado System.out.println(nomeMes + " de " + ano + " possui " + quantDiasNoMes + " dias."); System.out.println("\n"); } } |
Java ::: Java para Engenharia ::: Geometria Analítica e Álgebra Linear |
Como converter Coordenadas Cartesianas para Coordenadas Polares usando Java - Java para EngenhariaQuantidade de visualizações: 2113 vezes |
Nesta nossa série de Java para Geometria Analítica e Álgebra Linear, mostrarei um código 100% funcional para fazer a conversão entre coordenadas cartesianas e coordenadas polares. Esta operação é muito frequente em computação gráfica e é parte integrante das disciplinas dos cursos de Engenharia (com maior ênfase na Engenharia Civil). Na matemática, principalmente em Geometria e Trigonometria, o sistema de Coordenadas no Plano Cartesiano, ou Espaço Cartesiano, é um sistema que define cada ponto em um plano associando-o, unicamente, a um conjuntos de pontos numéricos. Dessa forma, no plano cartesiano, um ponto é representado pelas coordenadas (x, y), com o x indicando o eixo horizontal (eixo das abscissas) e o y indicando o eixo vertical (eixo das ordenadas). Quando saímos do plano (espaço 2D ou R2) para o espaço (espaço 3D ou R3), temos a inclusão do eixo z (que indica profundidade). Já o sistema de Coordenadas Polares é um sistema de coordenadas em duas dimensões no qual cada ponto no plano é determinado por sua distância a partir de um ponto de referência conhecido como raio (r) e um ângulo a partir de uma direção de referência. Este ângulo é normalmente chamado de theta (__$\theta__$). Assim, um ponto em Coordenadas Polares é conhecido por sua posição (r, __$\theta__$). Antes de prosseguirmos, veja uma imagem demonstrando os dois sistemas de coordenadas: ![]() A fórmula para conversão de Coordenadas Cartesianas para Coordenadas Polares é: __$r = \sqrt{x^2+y2}__$ __$\theta = \\arctan\left(\frac{y}{x}\right)__$ E aqui está o código Java completo que recebe as coordenadas cartesianas (x, y) e retorna as coordenadas polares (r, __$\theta__$): ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package arquivodecodigos; import java.util.Scanner; public class Estudos{ public static void main(String args[]){ Scanner entrada = new Scanner(System.in); // vamos ler as coordenadas cartesianas System.out.print("Valor de x: "); double x = Double.parseDouble(entrada.nextLine()); System.out.print("Valor de y: "); double y = Double.parseDouble(entrada.nextLine()); // vamos calcular o raio double raio = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2)); // agora calculamos o theta (ângulo) em radianos double theta = Math.atan2(y, x); // queremos o ângulo em graus também double angulo_graus = 180 * (theta / Math.PI); // e exibimos o resultado System.out.println("As Coordenadas Polares são:\n" + "raio = " + raio + ", theta = " + theta + ", ângulo em graus = " + angulo_graus); } } Ao executar este código nós teremos o seguinte resultado: Valor de x: -1 Valor de y: 1 As Coordenadas Polares são: raio = 1.4142135623730951, theta = 2.356194490192345, ângulo em graus = 135.0 Veja que as coordenadas polares equivalentes são (__$\sqrt{2}__$, __$\frac{3\pi}{4}__$), com o theta em radianos. Sim, os professores das disciplinas de Geometria Analítica e Álgebra Linear, Física e outras gostam de escrever os resultados usando raizes e frações em vez de valores reais. |
Java ::: Dicas & Truques ::: Geometria, Trigonometria e Figuras Geométricas |
Como testar se um ponto está dentro de um círculo em Java - Desenvolvimento de Games com JavaQuantidade de visualizações: 852 vezes |
Quando estamos trabalhando com computação gráfica, geometria e trigonometria ou desenvolvimento de jogos em Java, é comum precisarmos verificar se um determinado ponto (uma coordenada x, y) está contido dentro de um círculo. Para melhor entendimento, veja a imagem a seguir: ![]() Veja que temos um círculo com raio igual a 115 e com centro nas coordenadas (x = 205; y = 166). Temos também dois pontos. O ponto vermelho está nas coordenadas (x = 140; y = 90) e o ponto azul está nas coordenadas (x = 330; y = 500. Como podemos ver na imagem, o ponto vermelho está dentro do círculo, enquanto o ponto azul está fora. E nosso intenção nesta dica é escrever o código Java que permite fazer essa verificação. Tenha em mente que está técnica é muito útil para o teste de colisões no desenvolvimento de games. Veja o código completo para o exemplo: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package estudos; // vamos declarar a classe Circulo class Circulo{ double xc; double yc; double raio; public Circulo(double xc, double yc, double raio){ this.xc = xc; // x do centro this.yc = yc; // y do centro this.raio = raio; // raio do círculo } } // agora vamos declarar a classe Ponto class Ponto{ double x; double y; public Ponto(double x, double y){ this.x = x; // coordenada x this.y = y; // coordenada y } } // classe principal da aplicação public class Estudos{ public static void main(String[] args){ // vamos criar um objeto Circulo Circulo c = new Circulo(205, 166, 115); // vamos criar um objeto Ponto Ponto p = new Ponto(140, 90); // vamos verificar se o ponto está dentro do // círculo double dx = p.x - c.xc; double dy = p.y - c.yc; if((Math.pow(dx, 2) + Math.pow(dy, 2)) < Math.pow(c.raio, 2)){ System.out.println("O ponto está dentro do círculo"); } else{ System.out.println("O ponto NÃO está dentro do círculo"); } } } Ao executar este código Java nós teremos o seguinte resultado: O ponto está dentro do círculo. Experimente com círculos de raios e coordenadas centrais diferentes e também com pontos em várias coordenadas e veja como os resultados são interessantes. |
Java ::: Pacote java.awt ::: Graphics |
Como desenhar linhas em determinados ângulos usando o método drawLine() da classe Graphics - Computação Gráfica em JavaQuantidade de visualizações: 13730 vezes |
É possível usar o método drawLine() da classe Graphics para desenhar linhas em determinados ângulos. Observe atentamente a assinatura deste método:public abstract void drawLine(int x1, int y1, int x2, int y2) Aqui x1 e x2 representam as coordenadas iniciais da linha e x2 e y2 representam as coordenadas finais. Assim, vamos analisar a fórmula matemática que permite definir o ângulo de desenho. Comece definindo os valores para as coordenadas iniciais x1 e y1, o ângulo desejado e o comprimento da linha: int x1 = 30; int y1 = 50; int ang = 0; int comp = 100; Vamos começar obtendo a coordenada x final, que chamaremos de x2. Já sabemos que o ângulo é 0, então obteremos uma linha horizontal para a direita. Vamos ao cálculo: int x2 = (int)(x1 + Math.cos(ang / 180.0 * Math.PI) * comp); Já sabemos que o valor de x2 é igual a 0 pois (pode testar na barra de endereços de seu browser): javascript:alert(0 / 180.0 * Math.PI) resulta em 0 e: javascript:alert(Math.cos(0)) resulta em 1. Assim: x1 + (1 * 100) = 130. Para que nosso código esteja correto, o valor de y2 deverá ser igual a y1. Vejamos: int y2 = (int)(y1 - Math.sin(ang / 180.0 * Math.PI) * comp); Já sabemos que (ang / 180.0 * Math.PI) resulta em 0 e que o seno de 0 é 0. Assim: y1 - (0 * 100) = 50. Veja o código completo: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Estudos extends JFrame{ JLabel label; public Estudos() { super("Desenhando em um JLabel"); Container c = getContentPane(); c.setLayout(new BorderLayout()); // Cria um JLabel label = new JLabel(); c.add(label, BorderLayout.CENTER); // Cria um botão JButton btn = new JButton("Desenhar uma linha (ângulo)"); btn.addActionListener( new ActionListener(){ public void actionPerformed(ActionEvent e){ // Desenha uma string no JLabel int x1 = 30; // coordenada inicial x int y1 = 50; // coordenada inicial y int ang = 0; // ângulo int comp = 100; // comprimento // coordenada x final int x2 = (int)(x1 + Math.cos(ang / 180.0 * Math.PI) * comp); // coordenada y final int y2 = (int)(y1 - Math.sin(ang / 180.0 * Math.PI) * comp); Graphics graphics = label.getGraphics(); graphics.drawLine(x1, y1, x2, y2); } } ); // Adiciona o botão à janela c.add(btn, BorderLayout.SOUTH); setSize(350, 250); setVisible(true); } public static void main(String args[]){ Estudos app = new Estudos(); app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } } Experimente agora fornecer ângulos diferentes, por exemplo, 45 (uma linha diagonal para a direita e para cima), 90 (uma linha vertical para cima), 135 (uma linha diagonal para a esquerda e para cima), 180 (uma linha horizontal para a esquerda), 225 (uma linha diagonal para a esquerda e para baixo), 270 (uma linha vertical para baixo), 315 (uma linha diagonal para a direita e para baixo) e 360 (uma linha horizontal para a direita). Há algo de interessante neste código. Se você maximizar, minimizar ou redimensionar a janela verá que o desenho é apagado. Isso acontece porque todas as vezes que a janela sofre alguma alteração, ela é pintada novamente, juntamente com seus componentes filhos. Se você deseja que o desenho seja feito automaticamente novamente, é melhor fazer uma sub-classe do componente desejado e sobrescrever seu método paintComponent(). Nesta mesma seção você encontrará exemplos de como fazer isso. |
Java ::: Estruturas de Dados ::: Árvore Binária e Árvore Binária de Busca |
Estruturas de dados em Java - Como pesquisar um nó em uma árvore binária de busca usando um método recursivo usando JavaQuantidade de visualizações: 2431 vezes |
Nesta dica mostraremos um exemplo completo de como pesquisar um valor em uma árvore binária de busca em Java. Note que o exemplo usa apenas inteiros, mas você não terá dificuldades para modificar a classe Nó para os dados que você precisar. Código para No.java: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package arvore_binaria; public class No { private int valor; // valor armazenado no nó private No esquerdo; // filho esquerdo private No direito; // filho direito // construtor do nó public No(int valor){ this.valor = valor; this.esquerdo = null; this.direito = null; } public int getValor() { return valor; } public void setValor(int valor) { this.valor = valor; } public No getEsquerdo() { return esquerdo; } public void setEsquerdo(No esquerdo) { this.esquerdo = esquerdo; } public No getDireito() { return direito; } public void setDireito(No direito) { this.direito = direito; } } Código para ArvoreBinariaBusca.java: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package arvore_binaria; public class ArvoreBinariaBusca { private No raiz; // referência para a raiz da árvore // método usado para inserir um novo nó na árvore // retorna true se o nó for inserido com sucesso e false // se o elemento // não puder ser inserido (no caso de já existir um // elemento igual) public boolean inserir(int valor){ // a árvore ainda está vazia? if(raiz == null){ // vamos criar o primeiro nó e definí-lo como a raiz da árvore raiz = new No(valor); // cria um novo nó } else{ // localiza o nó pai do novo nó No pai = null; No noAtual = raiz; // começa a busca pela raiz // enquanto o nó atual for diferente de null while(noAtual != null){ // o valor sendo inserido é menor que o nó atual? if(valor < noAtual.getValor()) { pai = noAtual; // vamos inserir do lado esquerdo noAtual = noAtual.getEsquerdo(); } // o valor sendo inserido é maior que o nó atual else if(valor > noAtual.getValor()){ pai = noAtual; // vamos inserir do lado direito noAtual = noAtual.getDireito(); } else{ return false; // um nó com este valor foi encontrado } } // cria o novo nó e o adiciona como filho do nó pai if(valor < pai.getValor()){ pai.setEsquerdo(new No(valor)); } else{ pai.setDireito(new No(valor)); } } return true; // retorna true para indicar que o novo nó foi inserido } // método que permite pesquisar na árvore binária de busca public No pesquisar(int valor){ return pesquisar(raiz, valor); // chama a versão recursiva do método } // sobrecarga do método pesquisar que recebe dois // parâmetros (esta é a versão recursiva do método) private No pesquisar(No noAtual, int valor){ // o valor pesquisado não foi encontrado....vamos retornar null if(noAtual == null){ return null; } // o valor pesquisado foi encontrado? if(valor == noAtual.getValor()){ return noAtual; // retorna o nó atual } // ainda não encontramos...vamos disparar uma nova // chamada para a sub-árvore da esquerda else if(valor < noAtual.getValor()){ return pesquisar(noAtual.getEsquerdo(), valor); } // ainda não encontramos...vamos disparar uma nova // chamada para a sub-árvore da direita else{ return pesquisar(noAtual.getDireito(), valor); } } } E finalmente o código para a classe principal: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package arvore_binaria; import java.util.Scanner; public class ArvoreBinariaTeste { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // vamos criar um novo objeto da classe ArvoreBinariaBusca ArvoreBinariaBusca arvore = new ArvoreBinariaBusca(); // vamos inserir 5 valores na árvore for(int i = 0; i < 5; i++){ System.out.print("Informe um valor inteiro: "); int valor = Integer.parseInt(entrada.nextLine()); // vamos inserir o nó e verificar o sucesso da operação if(!arvore.inserir(valor)){ System.out.println("Não foi possível inserir." + " Um elemento já contém este valor."); } } // vamos pesquisar um valor na árvore System.out.print("\nInforme o valor a ser pesquisado: "); int valorPesquisa = Integer.parseInt(entrada.nextLine()); // obtém um objeto da classe NoArvore a partir do // método pesquisar() da classe ArvoreBinariaBusca No res = arvore.pesquisar(valorPesquisa); // o valor foi encontrado? if(res != null){ System.out.println("O valor foi encontrado na árvore"); } else{ System.out.println("O valor não foi encontrado na árvore"); } System.out.println("\n"); } } |
Desafios, Exercícios e Algoritmos Resolvidos de Java |
Veja mais Dicas e truques de Java |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
1º lugar: Java |