Informe o número da porta a ser pesquisada: 3306
Há um serviço na porta informada

Informe o número da posta a ser pesquisada: 2040
Não há nenhum serviço na porta informada

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

package estudos;

import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class Main {
  public static void main(String[] args){
    Socket socket; // vamos declarar um objeto da classe Socket
    String host = "localhost"; // define o nome da máquina host

    // vamos pedir ao usuário que informe a porta a ser pesquisada
    Scanner entrada = new Scanner(System.in);
    System.out.print("Informe o número da posta a ser pesquisada: ");
    int porta = Integer.parseInt(entrada.nextLine());

    // vamos verificar se há algum serviço na porta informada
    try{
      socket = new Socket(host, porta);
      System.out.println("Há um serviço na porta informada");
    }
    catch (UnknownHostException e) { // não foi possível encontrar a máquina host
       System.out.println("Não foi possível encontrar a máquina host: " + e);
    }
    catch (IOException e) {
      System.out.println("Não há nenhum serviço na porta informada");
    }
  }
}

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

package arquivodecodigos;

import java.lang.reflect.*;
 
public class Estudos{
  public static void main(String args[]){
    // vamos carregar a classe JButton
    try{
      Class c = Class.forName(
        "javax.swing.JButton");
 
      // obtém os nomes dos métodos
      Method[] metodos = c.getMethods(); 
 
      for(int i = 0; i < metodos.length; i++){
        // obtém o nome do método
        String nome = metodos[i].getName();
 
        // obtém os modificadores
        int modificador = 
          metodos[i].getModifiers();
 
        String modificadores = "";
 
        if(Modifier.isPublic(modificador))
          modificadores += "public "; 
        if(Modifier.isPrivate(modificador))
          modificadores += "private ";          
        if(Modifier.isProtected(modificador))
          modificadores += "protected ";
        if(Modifier.isStatic(modificador))
          modificadores += "static ";
        if(Modifier.isFinal(modificador))
          modificadores += "final ";
 
        System.out.println(nome + " - " + 
          modificadores); 
      }
    }
    catch(ClassNotFoundException e){
      System.out.println(e.getMessage()); 
    }
 
    System.exit(0);
  }
}