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

package estudos;

// definição da classe que representa uma aresta
// em um grafo. Aresta em inglês é edge. Uma aresta
// faz a ligação entre dois vértices (vertex em inglês)

public class Aresta {
  private Vertice origem;
  private Vertice destino;
  private int peso;

  // construtor da classe Aresta
  public Aresta(Vertice origem, Vertice destino, int peso) {
    this.origem = origem;
    this.destino = destino;
    this.peso = peso;
  }

  public Vertice getOrigem() {
    return origem;
  }

  public void setOrigem(Vertice origem) {
    this.origem = origem;
  }

  public Vertice getDestino() {
    return destino;
  }

  public void setDestino(Vertice destino) {
    this.destino = destino;
  }

  public int getPeso() {
    return peso;
  }

  public void setPeso(int peso) {
    this.peso = peso;
  }
}

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

package estudos;

// definição da classe que representa um vértice
// em um grafo. Vértice em inglês é vertex. Um
// vértice é ligado a outro vértice por meio de
// uma aresta (edge em inglês)

import java.util.ArrayList;

public class Vertice {
  private String cidade;
  private ArrayList<Aresta> arestas;

  // construtor da classe Vertice
  public Vertice(String nomeCidade){
    this.cidade = nomeCidade;
    this.arestas = new ArrayList();
  }
  
  // método que permite adicionar uma nova aresta a
  // este vértice
  public void adicionarAresta(Vertice destino, int peso){
    this.arestas.add(new Aresta(this, destino, peso));
  }
  
  // método que permite remover um aresta deste vértice
  public void removerAresta(Vertice destino){
    this.arestas.removeIf(aresta -> aresta.getDestino().equals(
      destino));
  }

  // método que exibe todas as arestas deste vértice
  public void exibir(boolean mostrarPeso){
    String resultado = "";
    
    // este vértice não possui arestas
    if (this.arestas.isEmpty()){
      System.out.println(this.getCidade()  + " --> (Vazio)");
    }
    // possui arestas
    else{
      // vamos percorrer as arestas deste vértice
      for(int i = 0; i < this.arestas.size(); i++){
        // é a primeira aresta?
        if(i == 0){
          // guardamos a origem
          resultado += this.arestas.get(i).getOrigem().getCidade() + " --> ";
        }
      
        // guardamos os destinos   
        resultado += this.arestas.get(i).getDestino().getCidade();
      
        // devemos mostrar os pesos das arestas? 
        if(mostrarPeso){
          resultado += " (" + this.arestas.get(i).getPeso() + ")";
        }
      
        // ainda não é a última aresta
        if(i != this.arestas.size() - 1){
          resultado += ", ";
        }
      }
      
      // e mostramos todas as arestas deste vértice
      System.out.println(resultado);
    }
  }

  public String getCidade() {
    return cidade;
  }

  public void setCidade(String cidade) {
    this.cidade = cidade;
  }

  public ArrayList<Aresta> getArestas() {
    return arestas;
  }

  public void setArestas(ArrayList<Aresta> arestas) {
    this.arestas = arestas;
  }
}

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

package estudos;

// Definição da classe Grafo, que possui uma ArrayList de
// vértices e duas variáveis boleanas indicando se ele
// possui pesos (é valorado) e se é ou não dirigido

import java.util.ArrayList;

public class Grafo {
  private ArrayList<Vertice> vertices;
  private boolean valorado;
  private boolean dirigido;

  // construtor da classe Grafo
  public Grafo(boolean valorado, boolean dirigido) {
    this.vertices = new ArrayList();
    this.valorado = valorado;
    this.dirigido = dirigido;
  }
  
  // método que permite adicionar um novo vértice e
  // e retorná-lo ao chamador
  public Vertice adicionarVertice(String cidade){
    // cria o novo vértice
    Vertice novo = new Vertice(cidade);
    // adiciona o vértice na lista de vértices
    this.vertices.add(novo);
    // retorna o novo vértice
    return novo;
  }
  
  // método que permite adicionar uma aresta entre dois
  // vértices
  public void adicionarAresta(Vertice v1, Vertice v2, int peso){
    // adicionamos a aresta no primeiro vértice
    v1.adicionarAresta(v2, peso);
    
    // é um digrafo?
    if(!this.isDirigido()){
      // adicionamos a aresta no segundo vértice também
      v2.adicionarAresta(v1, peso);
    }
  }
  
  // método que permite remover uma aresta entre dois
  // vértices
  public void removerAresta(Vertice v1, Vertice v2){
    // remove a aresta do primeiro vértice
    v1.removerAresta(v2);
    
    // é um grafo dirigido?
    if(!this.isDirigido()){
      // remove a aresta do segundo vértice também
      v2.removerAresta(v1);
    }
  }
  
  // remove um vértice da lista de vértices
  public void removerVertice(Vertice v){
    this.vertices.remove(v);
  }

  // método que busca e retorna um vértice baseado
  // em seu valor
  public Vertice buscarVerticeValor(String cidade){
    for(Vertice v : this.vertices){
      if(v.getCidade() == cidade){
        return v;
      }
    }
    
    return null;
  }
  
  // método que exibe os vértices deste grafo
  public void exibirVertices(){
    for(Vertice v : this.vertices){
      v.exibir(this.valorado);
    }
  }
  
  public ArrayList<Vertice> getVertices() {
    return vertices;
  }

  public void setVertices(ArrayList<Vertice> vertices) {
    this.vertices = vertices;
  }

  public boolean isDirigido() {
    return dirigido;
  }

  public void setDirigido(boolean dirigido) {
    this.dirigido = dirigido;
  }

  public boolean isValorado() {
    return valorado;
  }

  public void setValorado(boolean valorado) {
    this.valorado = valorado;
  }
}

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

package estudos;

public class Estudos {
  public static void main(String[] args) {
    // vamos criar um grafo valorado e dirigido
    Grafo grafo = new Grafo(true, true);
    
    // vamos adicionar os vértices
    Vertice goiania = grafo.adicionarVertice("Goiânia");
    Vertice cuiaba = grafo.adicionarVertice("Cuiabá");
    Vertice manaus = grafo.adicionarVertice("Manaus");
    Vertice belem = grafo.adicionarVertice("Belém");
    
    // agora ligamos os vértices por meio de suas arestas
    grafo.adicionarAresta(goiania, cuiaba, 850);
    grafo.adicionarAresta(goiania, belem, 1740);
    grafo.adicionarAresta(manaus, goiania, 730);
    grafo.adicionarAresta(belem, manaus, 420);
    
    // e exibimos o grafo
    grafo.exibirVertices();
  }
}

public E push(E item)

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

package arquivodecodigos;

import java.util.*;
 
public class Estudos{ 
  public static void main(String args[]){ 
    // Cria uma Stack de String
    Stack<String> pilha = new Stack<>();
    System.out.println("Tamanho da pilha antes: " +
      pilha.size());
    
    // adiciona três elementos na pilha
    pilha.push("Cuiabá");
    pilha.push("Goiânia");
    pilha.push("Belo Horizonte");
    
    System.out.println("Tamanho da pilha agora: " +
      pilha.size());
  } 
}

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

package estudos;

import java.awt.*;
import javax.swing.*;
import java.util.*;

public class Estudos extends JFrame{
  public Estudos(){
    super("A classe JComboBox");
    
    Container c = getContentPane();
    c.setLayout(new FlowLayout(FlowLayout.LEFT));
    
    // Cria o array que armazenará os itens do
    // combo box
    String[] nomes = {"Osmar", "Cristina", "Antônio",
      "Marcela", "Joaquim"};  
 
    // ordena os itens
    Arrays.sort(nomes);

    // Cria o JComboBox
    JComboBox combo = new JComboBox(nomes);

    // Adiciona o JComboBox à janela
    c.add(combo);

    setSize(350, 250);
    setVisible(true);
  }
  
  public static void main(String args[]){
    Estudos app = new Estudos();
    app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}

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

public void add(int index, E element)

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

package estudos;

import java.util.ArrayList;

public class Estudos{
  public static void main(String[] args){
    // cria uma ArrayList que conterá strings
    ArrayList<String> pessoas = new ArrayList<>();
    
    // adiciona itens na lista
    pessoas.add("Alberto");
    pessoas.add("Victor");
    pessoas.add("João");
    	
    // adiciona um item na posição 2, depois de Victor    
    pessoas.add(2, "Ricardo");
   
    // exibe os itens da lista	
    for(int i = 0; i < pessoas.size(); i++){
      System.out.println(pessoas.get(i));
    }  

    System.exit(0);
  }
}