Deletar elemento da Fila(RESOLVIDO)

[Luan_Magalhaes]

Tenho um código de deletar o primeiro elemento da fila, mais quando realizo a deleção dos dois primeiros números da fila, ele acaba duplicando os dois últimos elementos da minha fila mesclada. Agradeço qualquer ajuda

public class Fila {

private int max = 0;
public int dado[];

public Fila(int tamanhoFila) {
    this.dado = new int[tamanhoFila];
}

public void insere(int elemento) {
    if (this.max < this.dado.length) {
        this.dado[this.max] = elemento;
        this.max++;
    }
}



public void mostrarElementosDaFila() {
    for (int elemento : dado) {
        System.out.print(elemento + " ");
    }
    System.out.println();
}

public void cheia() {
    if (this.max == this.dado.length) {
        System.out.println("A Fila esta cheia");
    } else {
        System.out.println("A Fila não esta cheia");
    }
}

public boolean vazia() {
    if (this.max == 0) {
        return true;
    }
    return false;
}

public Object primeiro() {
    if (this.vazia()) {
        return "A fila esta vazia !";
    }

    return this.dado[0];
}

public Object ultimo() {
    return this.dado[--max];
}

public Object remove() {

    if (vazia()) {
        System.out.println(" Fila vazia, não há como remover");
    }

    int removeElemento = this.dado[0];

    this.max--;
    for (int i = 0; i < this.max; i++) {
        dado[i] = dado[i + 1];
    }
    
    

    return removeElemento;

}

@Override
public String toString() {
    StringBuilder s = new StringBuilder();

    for (int i = 0; i < this.max; i++) {
        s.append(this.dado[i]);
        s.append(" ");
    }
    return s.toString();

}

 public static Fila merge(Fila filaA, Fila filaB) {
    Fila filaC = new Fila(filaA.dado.length + filaB.dado.length);

    int proximoA = 0;
    int proximoB = 0;
    int proximoC = 0;

    while (proximoA < filaA.dado.length && proximoB < filaB.dado.length) {
        if (filaA.dado[proximoA] <= filaB.dado[proximoB]) {
            filaC.dado[proximoC++] = filaA.dado[proximoA++];
        } else {
            filaC.dado[proximoC++] = filaB.dado[proximoB++];
        }
    }

    while (proximoA < filaA.dado.length) {
        filaC.dado[proximoC++] = filaA.dado[proximoA++];
    }

    while (proximoB < filaB.dado.length) {
        filaC.dado[proximoC++] = filaB.dado[proximoB++];
    }
    
   
    
    

    return filaC;

}

public class Executa {

public static void main(String[] args) {

       Fila filaA = new Fila(4);

    filaA.insere(12);
    filaA.insere(35);
    filaA.insere(52);
    filaA.insere(64);

    Fila filaB = new Fila(5);

    filaB.insere(5);
    filaB.insere(15);
    filaB.insere(23);
    filaB.insere(55);
    filaB.insere(75);
    
    filaA.mostrarElementosDaFila();
    filaB.mostrarElementosDaFila();
    System.out.println("");
    
    System.out.println("Elemento removido: "+filaA.remove());
    System.out.println("Elemento removido: "+filaB.remove());
    System.out.println("");

    Fila filaMergeada = Fila.merge(filaA, filaB);

    filaMergeada.mostrarElementosDaFila();


}

}

Resultado do terminal

[confuso]

É porque o seu método remove() faz isso:

Original: [12, 35, 52, 64]
Removendo:
   Passo 1: [35, 35, 52, 64]
   Passo 2: [35, 52, 52, 64]
   Passo 3: [35, 52, 64, 64] // estado final, max = 3

Pelo que eu entendi o último elemento continua no array e você sabe até onde vai a fila usando a variável max. Então, o próximo elemento seria inserido no lugar do último 64.

Quando eu te sugeri o método merge, ontem não sabia que funcionava assim. Sabendo disso, é só corrigir o método merge pra usar essa variável max:

public static Fila merge(Fila filaA, Fila filaB) {
    Fila filaC = new Fila(filaA.max + filaB.max);

    int proximoA = 0;
    int proximoB = 0;
    int proximoC = 0;

    while (proximoA < filaA.max && proximoB < filaB.max) {
        if (filaA.dado[proximoA] <= filaB.dado[proximoB]) {
            filaC.dado[proximoC++] = filaA.dado[proximoA++];
        } else {
            filaC.dado[proximoC++] = filaB.dado[proximoB++];
        }
    }

    while (proximoA < filaA.max) {
        filaC.dado[proximoC++] = filaA.dado[proximoA++];
    }

    while (proximoB < filaB.max) {
        filaC.dado[proximoC++] = filaB.dado[proximoB++];
    }


    return filaC;

}

Agora a saída fica como esperado:

[Luan_Magalhaes]

Funcionou certinho, muito obrigado.