// vamos declarar um vetor de 10 inteiros
// sem repetição
int valores[] = {5, 1, 19, 7, 25, 8, 3, 40, 2, 6};

Valores do array: [5, 1, 19, 7, 25, 8, 3, 40, 2, 6]
Valores na árvores binária: 1 2 3 5 6 7 8 19 25 40

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

package estudos;

import java.util.Arrays;

// classe interna para representar os nós da
// árvore binária
class No {
  int valor; // valor armazenado no nó
  No esquerdo; // filho esquerdo
  No direito; // filho direito
  
  // construtor do nó
  public No(int valor){
    this.valor = valor;
    this.esquerdo = null;
    this.direito = null;
  }
}

public class Estudos { 
  // referência para a raiz da árvore
  static No raiz;
  
  public static void main(String args[]){
    // vamos declarar um vetor de 10 inteiros
    // sem repetição
    int valores[] = {5, 1, 19, 7, 25, 8, 3, 40, 2, 6};
    
    // vamos mostrar os valores do vetor
    System.out.println("Valores do array: " + 
      Arrays.toString(valores));
    
    // vamos percorrer os valores do vetor e adicioná-los
    // à arvore binária
    for (int i = 0; i < valores.length; i++) {
      inserir(valores[i]);
    }
    
    // agora vamos exibir os valores já inseridos na
    // árvore binária usando o percurso "Em Ordem", que
    // devolve os nós da árvore ordenados em ordem
    // crescente
    System.out.print("Valores na árvores binária: ");
    em_ordem();
    System.out.println();
  }
  
  // função usada 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 static 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 no_atual = raiz; // começa a busca pela raiz
   
      // enquanto o nó atual for diferente de null
      while(no_atual != null){
        // o valor sendo inserido é menor que o nó atual?
        if(valor < no_atual.valor) {
          pai = no_atual;
          // vamos inserir do lado esquerdo
          no_atual = no_atual.esquerdo;
        }
        // o valor sendo inserido é maior que o nó atual
        else if(valor > no_atual.valor){
          pai = no_atual;
          // vamos inserir do lado direito
          no_atual = no_atual.direito;
        }
        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.valor){
         pai.esquerdo = new No(valor);
      }
      else{
        pai.direito = new No(valor);
      }
    }
  
    // retorna true para indicar que o novo nó foi inserido
    return true; 
  }

  // função que permite disparar a travessia em-ordem
  public static void em_ordem(){
    em_ordem(raiz);
  }
  
  // sobrecarga da função em ordem com uma parâmetro (esta é a versão 
  // recursiva da função)
  private static void em_ordem(No raiz){
    if(raiz == null){ // condição de parada
      return;
    }
      
    // visita a sub-árvore da esquerda
    em_ordem(raiz.esquerdo);
    // visita o nó atual
    System.out.print(raiz.valor + " ");
    // visita a sub-árvore da direita
    em_ordem(raiz.direito);
  }
}

public static int quantRepeticoes(int indice, int valor, int[] vetor){
  // sua implementação aqui
}

Informe o 1 valor: 2
Informe o 2 valor: 7
Informe o 3 valor: 4
Informe o 4 valor: 7
Informe o 5 valor: 1

Informe o valor a ser pesquisado no vetor: 7
O valor informado se repete 2 vezes.

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

package exercicio;

import java.util.Scanner;

public class Exercicio {
  public static void main(String[] args) {
    // cria um novo objeto da classe Scanner
    Scanner entrada = new Scanner(System.in);
    
    // vamos declarar um vetor de 10 inteiros
    int valores[] = new int[5];
    
    // vamos pedir ao usuário que informe os valores do vetor
    for(int i = 0; i < valores.length; i++){
      System.out.print("Informe o " + (i + 1) + " valor: ");
      // efetua a leitura do valor informado para a posição atual do vetor
      valores[i] = Integer.parseInt(entrada.nextLine());
    }
    
    // agora vamos pedir para informar o valor a ser pesquisado
    System.out.print("\nInforme o valor a ser pesquisado no vetor: ");
    int valor = Integer.parseInt(entrada.nextLine());
    
    // e vamos ver a quantidade de repetições
    int repeticoes = quantRepeticoes(0, valor, valores);
    System.out.print("O valor informado se repete " + repeticoes + " vezes.");
    
    System.out.println("\n");
  }
  
  // método recursivo que recebe um valor
  public static int quantRepeticoes(int indice, int valor, int[] vetor){
    if(indice == vetor.length - 1){ // caso base...hora de parar a recursividade
      if(vetor[indice] == valor){
        return 1; // mais um repetição foi encontrada
      }
    }
    else{ // dispara mais uma chamada recursiva
      if(vetor[indice] == valor){ // houve mais uma repetição
        return 1 + quantRepeticoes(indice + 1, valor, vetor);
      }
      else{
        return 0 + quantRepeticoes(indice + 1, valor, vetor); // não repetiu
      }
    }
    
    return 0; // só para deixar o compilador satisfeito...esta linha nunca é executada
  }
}

// um vetor de inteiros contendo sete elementos
int valores[] = {4, 5, 1, 8, 2, 2, 10};

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

public static void main(String[] args){
  // um vetor de inteiros contendo sete elementos
  int valores[] = {4, 5, 1, 8, 2, 2, 10};
    
  // o primeiro passo é criar uma variável que vai receber a soma
  // dos valores dos elementos
  int soma = 0;

  // agora vamos usar uma laço for para percorrer todos os elementos
  // do vetor, obter o valor do elemento atual e adicionar ao valor atual
  // da variável soma
  for(int i = 0; i < valores.length; i++){
    soma = soma + valores[i];
    // poderia também ser escrito assim:
    // soma += valores[i];
  }

  // vamos exibir a soma dos valores do vetor
  System.out.println("A soma dos valores do vetor é: " + soma);
}

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

package arquivodecodigos;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
 
public class Estudos extends JFrame{
  public Estudos(){
    super("Eventos do Mouse e Teclado");
 
    Container c = getContentPane();
    PainelDesenho painel = new PainelDesenho();
    c.add(painel, BorderLayout.CENTER);
    c.add(new JLabel("Arraste o mouse para desenhar..." ),
      BorderLayout.SOUTH );
     
    setSize(350, 250);
    setVisible(true);
  }
   
  public static void main(String args[]){
    Estudos app = new Estudos();
    app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}
 
class PainelDesenho extends JPanel{
  private int quantPontos = 0;
  private Point pontos[] = new Point[10000];
 
  public PainelDesenho(){
    this.setBackground(Color.WHITE);    
 
    this.addMouseMotionListener(
      new MouseMotionAdapter(){
        public void mouseDragged(MouseEvent e){
          if(quantPontos < pontos.length){
            pontos[quantPontos] = e.getPoint();
            quantPontos++;
            repaint();
          }                                              
        }                                
      }
    );
  }
 
  @Override
  public void paintComponent(Graphics g){
    super.paintComponent(g);
     
    for(int i = 0 ; i < quantPontos; i++)
      g.fillOval(pontos[i].x, pontos[i].y, 4, 4);
  }
}

a = {5, 8, 2, 1}
b = {1, 4, 5, 3}
c = a.intersection(b)
print(c)