Informe a Unidade Consumidora: 1
Quantidade de kWh consumidos: 300
Residencial, Comercial ou Industrial [1, 2, 3] : 1

Unidade Consumidora: 1
Conta Mensal: 159.67200000000003
Categoria: Residencial

Informe a Unidade Consumidora: 2
Quantidade de kWh consumidos: 150
Residencial, Comercial ou Industrial [1, 2, 3] : 2

Unidade Consumidora: 2
Conta Mensal: 109.821
Categoria: Comercial

Informe a Unidade Consumidora: 3
Quantidade de kWh consumidos: 250
Residencial, Comercial ou Industrial [1, 2, 3] : 3

Unidade Consumidora: 3
Conta Mensal: 210.80499999999998
Categoria: Industrial

Informe a Unidade Consumidora: 4
Quantidade de kWh consumidos: 280
Residencial, Comercial ou Industrial [1, 2, 3] : 3

Unidade Consumidora: 4
Conta Mensal: 236.1016
Categoria: Industrial

Informe a Unidade Consumidora: 5
Quantidade de kWh consumidos: 320
Residencial, Comercial ou Industrial [1, 2, 3] : 2

Unidade Consumidora: 5
Conta Mensal: 234.28480000000002
Categoria: Comercial

Informe a Unidade Consumidora: 0

Média Consumo Industrial: 223.45329999999998
Unidade Maior Consumo Comercial: 5
Valor total a ser recebido: 950.6844

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package estudos;

import java.util.Scanner;

public class Estudos {
  public static void main(String[] args) {
    // variáveis usadas na resolução do problema
    int unidade, quant_kwh_consumidos, tipo_consumidor;
    int unid_maior_consumo_comer = 0, quant_industriais = 0;
    double conta_mensal, media_industriais, soma_industriais = 0;
    double maior_consumo_comercial = 0;
    double valor_total = 0;
    
    // para a leitura da entrada do usuário
    Scanner entrada = new Scanner(System.in);
    
    do {
      // vamos ler os dados de cada consumidor
      System.out.print("\nInforme a Unidade Consumidora: ");
      unidade = Integer.parseInt(entrada.nextLine());
      
      // a unidade é diferente de 0?
      if(unidade != 0){
        System.out.print("Quantidade de kWh consumidos: ");
        quant_kwh_consumidos = Integer.parseInt(entrada.nextLine());
        System.out.print("Residencial, Comercial ou Industrial [1, 2, 3] : ");
        tipo_consumidor = Integer.parseInt(entrada.nextLine());
        
        // vamos calcular a conta mensal e exibir os dados desse consumidor
        System.out.println("\nUnidade Consumidora: " + unidade);
        if(tipo_consumidor == 1){ // Residencial
          conta_mensal = quant_kwh_consumidos * 0.53224;
          System.out.println("Conta Mensal: " + conta_mensal);
          System.out.println("Categoria: Residencial");
        }
        else if(tipo_consumidor == 2){ // Comercial
          conta_mensal = quant_kwh_consumidos * 0.73214;
          System.out.println("Conta Mensal: " + conta_mensal);
          System.out.println("Categoria: Comercial");
          
          // temos que registrar a unidade de maior consumo
          // comercial
          if(conta_mensal > maior_consumo_comercial){
            unid_maior_consumo_comer = unidade;
            maior_consumo_comercial = conta_mensal;  
          }
        }
        else { // Industrial
          conta_mensal = quant_kwh_consumidos * 0.84322;
          System.out.println("Conta Mensal: " + conta_mensal);
          System.out.println("Categoria: Industrial");
          
          // vamos contar mais este cliente industrial
          quant_industriais = quant_industriais + 1;
          // temos também que somar mais essa conta
          soma_industriais = soma_industriais + conta_mensal;
        }
        
        // vamos somar mais esta conta ao valor total
        valor_total = valor_total + conta_mensal;
      }
    } while(unidade != 0);
    
    // vamos mostrar a média de consumo dos clientes industriais
    if(quant_industriais > 0){
      media_industriais = soma_industriais / quant_industriais;
      System.out.println("\nMédia Consumo Industrial: " + media_industriais);
    }
    else{
      System.out.println("\nNão houve consumo industrial");
    }
    
    // vamos mostrar o número da unidade consumidora de maior
    // consumo entre os consumidores comerciais;
    System.out.println("Unidade Maior Consumo Comercial: " + 
      unid_maior_consumo_comer);
    
    // vamos mostrar o valor total
    System.out.println("Valor total a ser recebido: " + valor_total);
  }
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

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

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

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

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

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");
  }
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

public class Estudos{
  static int valor = 1500; 
  
  public static void main(String args[]){
    System.out.println("O valor da variável é: "
      + valor);
    System.exit(0);
  }
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

int -> long -> float -> double

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

short valor2 = (short)(valor);

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package arquivodecodigos;

public class Estudos{
  public static void main(String args[]){
    // energia cinética
    double energia_cinetica = 400; // em joule
    // massa do corpo
    double massa = 20; // em kg
    
    // e então calculamos a velocidade do corpo
    double velocidade = Math.sqrt(energia_cinetica / (0.5 * massa));
  
    // mostramos o resultado
    System.out.println("A velocidade do corpo é: " + velocidade + "m/s");     
  }
}