Ofereço ajuda em Java, C/C++, Python, C#, LISP, AutoLisp, AutoCAD
+55 (062) 98553-6711
Ofereço ajuda em PHP, Python, C#, JavaScript, Laravel, Google Ads e SEO
+55 (062) 98243-1195

Você está aqui: Java ::: Pacote java.lang ::: String

Qual a diferença entre a comparação de strings usando o operador "==" e o método equals() da classe String?

Quantidade de visualizações: 2998 vezes
Uma das dúvidas mais frequentes entre os estudantes de Java é a diferença entre a comparação de strings usando o operador "==" e o método equals() da classe String. Quando se trata de objetos, o operador "==" verifica se as duas variáveis (referências) apontam para o mesmo objeto String na memória. O método equals(), por sua vez, compara o conteúdo dos dois objetos apontados por duas variáveis. Veja o exemplo a seguir:

----------------------------------------------------------------------
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;

public class Estudos{
  public static void main(String[] args) {
    String s1 = "Java";
    String s2 = "Java";
    String s3 = new String("Java");
   
    // vamos verificar se s1 e s2 são referências para o mesmo objeto String
    if(s1 == s2){
      System.out.println("s1 e s2 apontam para o mesmo objeto String");
    }
    else{
      System.out.println("s1 e s2 não apontam para o mesmo objeto String");
    }
    
    // vamos verificar se s1 e s3 são referências para o mesmo objeto String
    if(s1 == s3){
      System.out.println("s1 e s3 apontam para o mesmo objeto String");
    }
    else{
      System.out.println("s1 e s3 não apontam para o mesmo objeto String");
    }
    
    // vamos verificar se o conteúdo de s1 é igual ao conteúdo de s3
    if(s1.equals(s3)){
      System.out.println("O conteúdo de s1 e s3 é igual");
    }
    else{
      System.out.println("O conteúdo de s1 e s3 não é igual");
    }
  }
}

Ao executarmos este código nós teremos o seguinte resultado:

----------------------------------------------------------------------
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 
----------------------------------------------------------------------

s1 e s2 apontam para o mesmo objeto String
s1 e s3 não apontam para o mesmo objeto String
O conteúdo de s1 e s3 é igual

Neste exemplo nós declaramos e instanciamos uma variável do tipo String chamada s1 e com o conteúdo "Java". Ao declararmos a variável s2 com o mesmo conteúdo, o compilador descobre que o conteúdo das duas variáveis é o mesmo e "aponta" a segunda variável para o conteúdo da primeira. Isso faz com que as duas variáveis s1 e s2 apontem para o mesmo objeto e a comparação s1 == s2 retorne true. Já a variável s3 aponta para um novo objeto String. Desta vez o compilador não aproveita o objeto já criado. Ele cria um novo objeto String fazendo com que a comparação s1 == s3 retorne false.

Link para compartilhar na Internet ou com seus amigos:

Java ::: Desafios e Lista de Exercícios Resolvidos ::: Java Básico

Exercícios Resolvidos de Java - Um programa que lê dois números inteiros e mostra o menor

Quantidade de visualizações: 4221 vezes
Pergunta/Tarefa:

Escreva um programa Java que solicita dois números inteiros ao usuário e mostra o menor deles. Mostre uma mensagem informando se os dois números são iguais. Sua saída deverá ser parecida com:

Informe o primeiro número: 34
Informe o segundo número: 30
O menor número é: 30

Informe o primeiro número: 12
Informe o segundo número: 43
O menor número é: 12

Informe o primeiro número: 7
Informe o segundo número: 7
Os dois números são iguais.
Resposta/Solução:

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) {
    Scanner entrada = new Scanner(System.in);  
    
    // vamos solicitar os dois números inteiros
    System.out.print("Informe o primeiro número: ");
    int num1 = Integer.parseInt(entrada.nextLine());
    System.out.print("Informe o segundo número: ");
    int num2 = Integer.parseInt(entrada.nextLine());
    
    // o primeiro número é menor que o segundo?
    if(num1 < num2){
      System.out.println("O menor número é: " + num1);  
    }
    else if(num2 < num1){ // o segundo número é menor que o primeiro?
      System.out.println("O menor número é: " + num2);  
    }
    else{
      System.out.println("Os dois números são iguais.");  
    }
    
    System.out.println("\n");
  }
}



Java ::: Estruturas de Dados ::: Árvore Binária e Árvore Binária de Busca

Estruturas de dados em Java - Como fazer a travessia de uma árvore binária de busca em Java usando o percurso em-ordem (in-order, In-ordem ou ordem simétrica)

Quantidade de visualizações: 4825 vezes
Antes de discutirmos o percurso in-order, veja a árvore binária de busca na figura abaixo:



Esta árvore possui 9 nós e obedece à regra de que os nós com valores menores que o nó pai ficam à sua esquerda, e aqueles com nós maiores que o nó pai, ficam à sua direita.

O percurso em ordem é usado quando queremos exibir os valores dos nós da árvore binária de busca em ordem ascendente. Neste tipo de percurso nós visitamos primeiramente a sub-árvore da esquerda, então o nó atual e finalmente a sub-árvore à direita do nó atual. É importante notar que esta travessia é feita por meio de um método recursivo.

Veja o código completo para o exemplo:

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 disparar a travessia em-ordem
  public void emOrdem(){
    emOrdem(raiz);
  }
 
  // sobrecarga do método emOrdem com uma parâmetro (esta é a versão 
  // recursiva do método)
  private void emOrdem(No raiz){
    if(raiz == null){ // condição de parada
      return;
    }
     
    // visita a sub-árvore da esquerda
    emOrdem(raiz.getEsquerdo());
    // visita o nó atual
    System.out.print(raiz.getValor() + " ");
    // visita a sub-árvore da direita
    emOrdem(raiz.getDireito());
  }
}

E agora 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 9 valores na árvore
    for(int i = 0; i < 9; 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 exibir os nós da árvore usando o percurso in-order
    System.out.println("\nPercurso in-order:");
    arvore.emOrdem();
     
    System.out.println("\n");
  }
}

Ao executar este código teremos o seguinte resultado:

Informe um valor inteiro: 8
Informe um valor inteiro: 3
Informe um valor inteiro: 10
Informe um valor inteiro: 1
Informe um valor inteiro: 6
Informe um valor inteiro: 14
Informe um valor inteiro: 4
Informe um valor inteiro: 7
Informe um valor inteiro: 13

Percurso in-order:
1 3 4 6 7 8 10 13 14



Java ::: Desafios e Lista de Exercícios Resolvidos ::: Java Básico

Exercícios Resolvidos de Java - Um programa que lê um salário e concede um aumento de 20% para os salários inferiores a R$ 800,00

Quantidade de visualizações: 4732 vezes
Exercícios Resolvidos de Java - Um programa que lê um salário e concede um aumento de 20% para os salários inferiores a R$ 800,00

Pergunta/Tarefa:

A empresa XYZ decidiu conceder um aumento de 20% aos funcionários com salários inferiores a R$ 800,00. Faça um programa Java que solicita o salário do funcionário e mostre o valor do salário reajustado ou uma mensagem, caso o funcionário não tenha direito ao aumento.

Sua saída deverá ser parecida com:

Informe o salário: 520
O salário informado foi: 520.0
O salário reajustado é: 530.4 
Resposta/Solução:

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) {
    Scanner entrada = new Scanner(System.in);  
    
    // vamos solicitar o salário do funcionário
    System.out.print("Informe o salário: ");
    double salario = Double.parseDouble(entrada.nextLine());
    System.out.println("O salário informado foi: " + salario);
    
    // vamos conceder o aumento ao salário inferior a 800,00
    if(salario < 800.00){
      double novoSalario = salario + (salario * (2.0 / 100.00));
      System.out.println("O salário reajustado é: " + novoSalario);
    }
    else{
      System.out.println("Não tem direito ao reajuste.");
    }
    
    System.out.println("\n");
  }
}



Java ::: Desafios e Lista de Exercícios Resolvidos ::: Recursão (Recursividade)

Exercícios Resolvidos de Java - Como calcular a potência de um número usando recursividade em Java - Funções recursivas em Java

Quantidade de visualizações: 4681 vezes
Pergunta/Tarefa:

A potenciação ou exponenciação é a operação de elevar um número ou expressão a uma dada potência. Escreva um método Java recursivo que recebe uma base e um expoente e eleva a base ao expoente.

Seu método deverá possuir a seguinte assinatura:

public static int potencia(int base, int expoente){
  // sua implementação aqui
}
Como melhoria na resolução, você pode tratar o caso no qual o expoente é igual a 0 (na resolução abaixo deixei esta possibilidade em aberto).

Sua saída deverá ser parecida com:

Informe a base: 5
Informe o expoente: 3
A base 5 elevada ao exponente 3 é 125
Resposta/Solução:

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 estudos;

import java.util.Scanner;

public class Estudos {
  public static void main(String[] args) {
    // cria um novo objeto da classe Scanner
    Scanner entrada = new Scanner(System.in);
    
    // solicita a base
    System.out.print("Informe a base: ");
    // lê a base
    int base = Integer.parseInt(entrada.nextLine());
    // solicita o expoente
    System.out.print("Informe o expoente: ");
    // lê o expoente
    int expoente = Integer.parseInt(entrada.nextLine());
    
    // mostra o resultado
    System.out.print("A base " + base + " elevada ao exponente " +
      expoente + " é " + potencia(base, expoente));
    System.out.println("\n");
  }
  
  // método recursivo que eleva uma base a um determinado expoente
  public static int potencia(int base, int expoente){
    // a recursivida deve parar quando o expoente for igual a 1
    if(expoente == 1){
      return base;
    }
    else{
      // efetua uma nova chamada recursiva fornecendo o expoente - 1
      return base * potencia(base, expoente - 1);
    }
  }
}



Java ::: Dicas & Truques ::: Strings e Caracteres

Como contar as ocorrências de uma substring em uma string do Java usando o método substring() e um laço for

Quantidade de visualizações: 3 vezes
Nesta dica mostrarei como podemos usar o método substring() da classe String, combinado com o laço for, para contar as ocorrências de uma substring em uma string da linguagem Java. Note que usamos também os métodos length() e equals() para completar a tarefa.

Veja o código Java 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;

public class Estudos{
  public static void main(String[] args){
    // vamos criar uma string representando uma frase
    String frase = "Programar em Java só é melhor que programar em Java";
    
    // a substring que vamos pesquisar
    String sub = "Java"; // ocorrências de "Java"
    
    // quantidade de ocorrências
    int cont = 0;
    
    // um laço for que vai de 0 até o tamanho da primeira string menos
    // o tamanho da segunda string - 1
    for(int i = 0; i < (frase.length() - sub.length() + 1); i++){
      String res = frase.substring(i, (i + sub.length()));
      
      // encontramos a substring mais uma vez?
      if(res.equals(sub)){
        cont++;
      }
    }
    
    System.out.println("A frase contém " + cont + " ocorrências de " + sub);
    
    // fecha o programa
    System.exit(0);
  }
}  

Ao executar este código Java nós teremos o seguinte resultado:

A frase contém 2 ocorrências de Java


Java ::: Desafios e Lista de Exercícios Resolvidos ::: Laços de Repetição

Exercícios Resolvidos de Java - Escreva um programa (algorítmo) Java que usa o laço do...while para ler um número indeterminado de idades. A condição de parada do laço é o valor da idade igual a 0

Quantidade de visualizações: 9011 vezes
Pergunta/Tarefa:

Escreva um programa (algorítmo) Java que usa o laço do...while para ler um número indeterminado de idades de algumas pessoas. A condição de parada do laço é o valor da idade igual a 0. Calcule a escreva a idade média deste grupo de pessoas.

Sua saída deverá ser parecida com:

Informe a idade: 19
Informe a idade: 30
Informe a idade: 21
Informe a idade: 45
Informe a idade: 0
A idade média é: 28.75
Resposta/Solução:

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 exercicios;

import java.util.Scanner;

public class Exercicios {
  public static void main(String[] args) {
    // vamos efetuar a leitura usando a classe Scanner
    Scanner entrada = new Scanner(System.in);
      
    int idade; // guarda a idade lida de cada indivíduo
    double idade_media; // a idade média calculada
    int soma = 0; // a soma das idades de cada indivíduo
    int contador = 0; // conta as idades lidas
    
    // laço do...while que repetirá até que o valor da idade seja 0
    do{
      System.out.print("Informe a idade: ");
      idade = Integer.parseInt(entrada.nextLine());
      
      // a idade lida é diferente de 0?
      if(idade != 0){
        soma = soma + idade; // soma mais esta idade
        contador++; // aumenta a quantidade de idades lidas
      }
    }while(idade != 0);
    
    // calcula a idade média
    // note que forcei contador para o tipo double antes da divisão
    // isso faz com que o resultado seja do tipo double
    idade_media = soma / (contador * 1.0);
    
    // finalmente mostramos o resultado
    System.out.println("A idade média é: " + idade_media);
  }
}



Java ::: Dicas & Truques ::: Matemática e Estatística

Como calcular juros compostos e montante usando a linguagem Java - Fórmula de juros compostos em Java - Revisado

Quantidade de visualizações: 20762 vezes
O regime de juros compostos é o mais comum no sistema financeiro e, portanto, o mais útil para cálculos de problemas do dia-a-dia. Os juros gerados a cada período são incorporados ao principal para o cálculo dos juros do período seguinte.

Chamamos de capitalização o momento em que os juros são incorporados ao principal. Assim, após três meses de capitalização, temos:

1º mês: M = P .(1 + i)
2º mês: o principal é igual ao montante do mês anterior: M = P x (1 + i) x (1 + i)
3º mês: o principal é igual ao montante do mês anterior: M = P x (1 + i) x (1 + i) x (1 + i)

Simplificando, obtemos a fórmula:

M = P . (1 + i)^n

Importante: a taxa i tem que ser expressa na mesma medida de tempo de n, ou seja, taxa de juros ao mês para n meses.

Para calcularmos apenas os juros basta diminuir o principal do montante ao final do período:

J = M - P

Vejamos um exemplo:

Considerando que uma pessoa empresta a outra a quantia de R$ 2.000,00, a juros compostos, pelo prazo de 3 meses, à taxa de 3% ao mês. Quanto deverá ser pago de juros?

Veja o código Java para a resolução:

----------------------------------------------------------------------
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 
----------------------------------------------------------------------

public class Estudos{
  public static void main(String args[]){
    double principal = 2000.00;
    double taxa = 0.03;
    int meses = 3;
   
    double montante = principal * Math.pow((1 + taxa), meses);  
    double juros = montante - principal;
 
    System.out.println("O total de juros a ser pago é: " 
      + juros);
    System.out.println("O montante a ser pago é: " 
      + montante);
 
    System.exit(0);
  }
}

Ao executarmos este código nós teremos o seguinte resultado:

O total de juros a ser pago é: 185.45400000000018
O montante a ser pago é: 2185.454

É claro que uma formatação para moeda deixaria os valores mais bonitos.

Uma outra aplicação interessante é mostrar mês a mês a evolução dos juros.

Veja o código a seguir:

----------------------------------------------------------------------
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 
----------------------------------------------------------------------

public class Estudos{
  public static void main(String args[]){
    double principal = 2000.00;
    double taxa = 0.03;
    int meses = 3;
    double anterior = 0.0;  
 
    for(int i = 1; i <= meses; i++){
      double montante = principal * Math.pow((1 + taxa), i);
      double juros = montante - principal - anterior;
       
      anterior += juros;
 
      System.out.println("Mês: " + i + " - Montante: " 
        + montante + " - Juros: " + juros);
    }     
 
    System.exit(0);
  }
}

Ao executarmos este código nós teremos o seguinte resultado:

Mês: 1 - Montante: 2060.0 - Juros: 60.0
Mês: 2 - Montante: 2121.7999999999997 - Juros: 61.79999999999973
Mês: 3 - Montante: 2185.454 - Juros: 63.65400000000045

Esta dica foi revisada e testada no Java 8.


Java ::: Java para Engenharia ::: Geometria Analítica e Álgebra Linear

Como calcular vetor unitário em Java - Java para Física e Engenharia

Quantidade de visualizações: 496 vezes
Um vetor unitário ou versor num espaço vetorial normado é um vetor (mais comumente um vetor espacial) cujo comprimento ou magnitude é 1. Em geral um vetor unitário é representado por um "circunflexo", assim: __$\hat{i}__$.

O vetor normalizado __$\hat{u}__$ de um vetor não zero __$\vec{u}__$ é o vetor unitário codirecional com __$\vec{u}__$.

O termo vetor normalizado é algumas vezes utilizado simplesmente como sinônimo para vetor unitário. Dessa forma, o vetor unitário de um vetor __$\vec{u}__$ possui a mesma direção e sentido, mas magnitude 1. Por magnitude entendemos o módulo, a norma ou comprimento do vetor.

Então, vejamos a fórmula para a obtenção do vetor unitário:

\[\hat{u} = \dfrac{\vec{v}}{\left|\vec{v}\right|}\]

Note que nós temos que dividir as componentes do vetor pelo seu módulo de forma a obter o seu vetor unitário. Por essa razão o vetor nulo não possui vetor unitário, pois o seu módulo é zero, e, como sabemos, uma divisão por zero não é possível.

Veja agora o código Java que pede as coordenadas x e y de um vetor 2D ou R2 e retorna o seu vetor unitário:

----------------------------------------------------------------------
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) {
    Scanner entrada = new Scanner(System.in);
     
    // vamos ler os valores x e y
    System.out.print("Informe o valor de x: ");
    double x = Double.parseDouble(entrada.nextLine());
    System.out.print("Informe o valor de y: ");
    double y = Double.parseDouble(entrada.nextLine());
     
    // o primeiro passo é calcular a norma do vetor
    double norma = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
    
    // agora obtemos as componentes x e y do vetor unitário
    double u_x = x / norma;
    double u_y = y / norma;
    
    // mostra o resultado
    System.out.println("O vetor unitário é: (x = " + 
      u_x + "; y = " + u_y);
  }
}

Ao executar este código Java nós teremos o seguinte resultado:

Informe o valor de x: -4
Informe o valor de y: 6
O vetor unitário é: (x = -0.5547001962252291; y = 0.8320502943378437

Veja agora uma modificação deste código para retornarmos o vetor unitário de um vetor 3D ou R3, ou seja, um vetor no espaço:

----------------------------------------------------------------------
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) {
    Scanner entrada = new Scanner(System.in);
     
    // vamos ler os valores x, y e z
    System.out.print("Informe o valor de x: ");
    double x = Double.parseDouble(entrada.nextLine());
    System.out.print("Informe o valor de y: ");
    double y = Double.parseDouble(entrada.nextLine());
    System.out.print("Informe o valor de z: ");
    double z = Double.parseDouble(entrada.nextLine());
     
    // o primeiro passo é calcular a norma do vetor
    double norma = Math.sqrt(Math.pow(x, 2) 
      + Math.pow(y, 2) + Math.pow(z, 2));
    
    // agora obtemos as componentes x, y e z do vetor unitário
    double u_x = x / norma;
    double u_y = y / norma;
    double u_z = z / norma;
    
    // mostra o resultado
    System.out.println("O vetor unitário é: (x = " + 
      u_x + "; y = " + u_y + "; z = " + u_z);
  }
}

Ao executarmos este novo código nós teremos o seguinte resultado:

Informe o valor de x: 3
Informe o valor de y: 7
Informe o valor de z: 5
O vetor unitário é: (x = 0.329292779969071; y = 0.7683498199278324; z = 0.5488212999484517


Vamos testar seus conhecimentos em AutoCAD Civil 3D

A paleta Toolspace

Qual aba da paleta Toolspace é usada para exibir os objetos do Civil 3D em uma lista resumida e expansível?

A) Settings

B) Prospector

C) Toolbox

D) Survey
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em Python

Analise o seguinte código Python

letras = ['ab', 'cd']

for i in range(len(letras)):
  letras[i].upper()

print(letras) 

Qual é o resultado de sua execução?

A) ['AB', 'CD']

B) ['ab', 'cd']

C) ['Ab', 'Cd']

D) ['aB', 'cD']
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em Ética e Legislação Profissional

Ética profissional, social, política

Várias profissões, principalmente aquelas que implicam os direitos humanos à vida, à justiça, à igualdade, seguem códigos de ética que são frutos precisamente da ética deontológica normativa: "um código de ética não poderá cobrir todas as situações que se levantam à medida que uma disciplina expande e tenta encontrar as necessidades em mudança de um tipo de serviço entre as pessoas na sociedade" (BLACKWELL et al. apud DIAS, 2008, p. 54).

De acordo com o trecho citado, assinale a alternativa correta:

A) A deontologia presume um código de ética universal para todas as profissões.

B) A deontologia abre espaços para que o profissional possa agir arbitrariamente.

C) A deontologia recusa mudanças em seus códigos de ética.

D) A deontologia serve como um guia reflexivo que orienta mesmo em situações inusitadas.

E) A deontologia responsabiliza o profissional pelas consequências de todo agir.
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em Engenharia Civil - Instalações Hidráulicas Prediais

Instalações prediais de águas pluviais

A chuva de projeto é o primeiro parâmetro a ser estimado para o projeto de instalações prediais. Como este é altamente probabilístico, uma abordagem a partir de um banco de dados consistente é utilizada na prática brasileira. Julgue as afirmações a seguir:

I. A chuva de projeto pode ser estimada a partir do ajuste das curvas IDF, que levam em conta a intensidade, a duração e a frequência com que ocorrem.

II. O tempo de retorno é um parâmetro que define o tempo para que a chuva retorne.

III. O coeficiente de deflúvio relaciona a porção de chuva incidente com o escoamento superficial gerado por esta.

IV. Os coeficientes de ajustes utilizados nas curvas IDF são frutos de pressupostos teóricos associados à mecânica dos fluidos.

Assinale a alternativa correta.

A) I e II são verdadeiras.

B) I e III são verdadeiras.

C) II e III são verdadeiras.

D) II e IV são verdadeiras.

E) III e IV são verdadeiras.
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em Engenharia Civil - Instalações Hidráulicas Prediais

Instalações prediais de águas pluviais

Normalmente, o projeto de calha é feito em duas etapas: primeiramente, estima-se o escoamento superficial a partir do método racional e, em sequência, consulta-se uma calha com capacidade hidráulica satisfatória. Em alguns casos, o projetista deve estar apto a calcular a seção necessária, fazendo, assim, a aplicação dos conhecimentos obtidos.

Uma calha em aço galvanizado com coeficiente de rugosidade n = 0,011 deverá ser instalada com declividade 0,5%. Sabendo que a seção adotada é retangular com base de 10cm e altura de 20cm, qual a capacidade hidráulica dessa calha em L/s?

A) 132,45L/s.

B) 165,25L/s.

C) 150,40L/s.

D) 180,61L/s.

E) 194,27L/s.
Verificar Resposta Estudar Cards Todas as Questões

Desafios, Exercícios e Algoritmos Resolvidos de Java

Veja mais Dicas e truques de Java

Dicas e truques de outras linguagens

E-Books em PDF

E-Book 650 Dicas, Truques e Exercícios Resolvidos de Python - PDF com 1.200 páginas
Domine lógica de programação e a linguagem Python com o nosso E-Book 650 Dicas, Truques e Exercícios Exercícios de Python, para você estudar onde e quando quiser.

Este e-book contém dicas, truques e exercícios resolvidos abrangendo os tópicos: Python básico, matemática e estatística, banco de dados, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book
E-Book 350 Exercícios Resolvidos de Java - PDF com 500 páginas
Domine lógica de programação e a linguagem Java com o nosso E-Book 350 Exercícios Exercícios de Java, para você estudar onde e quando quiser.

Este e-book contém exercícios resolvidos abrangendo os tópicos: Java básico, matemática e estatística, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: C
6º lugar: Delphi
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



© 2025 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 22 usuários muito felizes estudando em nosso site.