Lógica em ArrayList

Programação Java
#1

Estou aprendendo java na faculdade e estou com dificuldades de desenvolver a lógica para fazer busca em um Arraylist. Quero saber se existe senha cadastrada pelo atributo tipo, as senhas foram geradas com um valor char(tipo) e um valor int(numero) e concatenados dentro do ArrayList. Ex senhas: R-1,P-1,C-1.

Quero pesquisar através do metodo Caixa1 primeiramente na lista, apenas as senhas iniciadas com P respeitando a fila, da primeira cadastrada até a última, e depois de todas encontradas e eliminadas, então pesquisar por C e R sem necessidade de prioridade, essas duas últimas serão aleatórias de acordo com a posição na fila.

Deixa exemplificar de outra forma:
Digamos que eu adiciono senhas nessa sequência no ArrayList: C-1, P-2, C-3, R-4, P-5, P-6, R-7.

Aí suponha que desejo extrair todas senhas do ArrayList pelo caixa 1, mas o caixa1 deve priorizar as senhas P(Prioritárias) que deve seguir o seguinte processo, remover na ordem de inserção: P-2, P-5, P-6.

Depois continuando a remoção através do metodo caixa1, ele deve continuar e remover na ordem que sobrou sem prioridade: C-1, C-3, R-4, R-7.

Código fonte do Jframe para atribuir o tipo e número ao ArrayList.

public class Atendimento extends javax.swing.JFrame {
    List<Senha> listaSenhas;
    int numero;
             
    public Atendimento() {
        initComponents();
        numero = 0;
        listaSenhas = new ArrayList<Senha>();
    }

    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">                        
    private void initComponents() {

     
//Inserção das senhas no Arraylist através da Classe Senha com atributos Tipo e Numero concatenados para dentro do Arraylist



  private void clienteComumActionPerformed(java.awt.event.ActionEvent evt) {         

         numero++;
        Senha senha = new Senha('C', numero);      
        listaSenhas.add(senha);      
        senhaGerada.setText(String.valueOf(senha.getTipo())+'-'+String.valueOf(senha.getNumero()));
    }                                          

    private void clientePrioritarioActionPerformed(java.awt.event.ActionEvent evt) {   

        numero++;
        Senha senha = new Senha('P', numero);      
        listaSenhas.add(senha);      
        senhaGerada.setText(String.valueOf(senha.getTipo())+'-'+String.valueOf(senha.getNumero()));
    }
           
    private void clienteRapidoActionPerformed(java.awt.event.ActionEvent evt) {        

        numero++;
        Senha senha = new Senha('R', numero);      
        listaSenhas.add(senha);
        System.out.println("lista depois"+listaSenhas);
        senhaGerada.setText(String.valueOf(senha.getTipo())+'-'+String.valueOf(senha.getNumero()));
    }                                            

//Busca, apresentação e remoção  
   
    private void jbcaixa1ActionPerformed(java.awt.event.ActionEvent evt) {             

        saidaCaixa.setText("Caixa 1");      
             
        IIterator<Senha> itr = listaSenhas.iterator();                      
        
         while(itr.hasNext()){
            Senha s = itr.next();            
                if (s.getTipo() == 'P') {                
                saidaSenha.setText(String.valueOf(s.getTipo())+'-'+String.valueOf(s.getNumero())); 
                itr.remove();
                    break;
                }                
        } // Após isso preciso criar lógica para apresentar/remover as senhas iniciadas em C e R sem necessidade de priorizar ordem, apenas respeitando a ordem que foram adicionadas na lista.

    }                                      

    private void jbcaixa2ActionPerformed(java.awt.event.ActionEvent evt) {             

        saidaCaixa.setText("Caixa 2");
       
        Iterator<Senha> itr = listaSenhas.iterator();
        while(itr.hasNext()) {
            Senha s = itr.next();
            itr.remove();
            saidaSenha.setText(String.valueOf(s.getTipo())+'-'+String.valueOf(s.getNumero()));
            break;
        }  
    }
#2

Eu pensei numa solução em que vc deve implementar a interface Comparable e vc usa o método Collections.sort sempre que uma nova senha é criada.

Eu fiz um exemplo pra demonstrar:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class Senha implements Comparable<Senha> {
  public final char tipo;
  public final int numero;

  Senha(final char tipo, final int numero) {
    this.tipo = tipo;
    this.numero = numero;
  }

  @Override
  public String toString() {
    return this.tipo + "-" + this.numero;
  }

  @Override
  public int compareTo(final Senha o) {
    return this.tipo == 'P' && o.tipo != 'P' ? -1 : 0;
  }
}

class Atendimento {
  private final List<Senha> senhas = new ArrayList<>();

  private int contador = 1;

  public void adicionarSenha(final char tipo) {
    this.senhas.add(new Senha(tipo, contador++));
    Collections.sort(this.senhas);
  }

  public void adicionarSenhaComum() {
    this.adicionarSenha('C');
  }

  public void adicionarSenhaRapida() {
    this.adicionarSenha('R');
  }

  public void adicionarSenhaPrioritaria() {
    this.adicionarSenha('P');
  }

  public Senha pegarProximaSenha() {
    return this.senhas.remove(0);
  }

  public boolean temSenha() {
    return !this.senhas.isEmpty();
  }
}

public class Main {
  public static void main(String... args) {
    final Atendimento atendimento = new Atendimento();

    atendimento.adicionarSenhaComum();
    atendimento.adicionarSenhaPrioritaria();
    atendimento.adicionarSenhaComum();
    atendimento.adicionarSenhaRapida();
    atendimento.adicionarSenhaPrioritaria();
    atendimento.adicionarSenhaPrioritaria();
    atendimento.adicionarSenhaRapida();
    atendimento.adicionarSenhaComum();

    while (atendimento.temSenha()) {
      System.out.println(atendimento.pegarProximaSenha());
    }
  }
}
1 curtida