Recalcular operações num array

Sou iniciante em java e POO, e estou a fazer um projeto que consiste em uma calculadora de números complexos, e todas as operações feitas vão parar a um histórico que contem um array de operações. Esse histórico pode ser alterado e quando isso acontece tem de se recalcular as operações e esse é o meu problema, não sei como fazer isso. A classe complexo tem lá dois doubles (parte real, e imaginária) e os métodos que calculam(soma,subtração, etc).

Classe operações:

public class OpCalculadora {
    private char operador;
    private Complexo visor=new Complexo(0,0);

    public OpCalculadora(){
        this.operador = operador;
        this.visor = visor;
    }

    public OpCalculadora(char operador, Complexo visor) {
        this.operador = operador;
        this.visor = visor;
    }

    public char getOperador() {
        return operador;
    }   //Getters e Setters necessários para a realização de operações

    public void setOperador(char operador) {
        this.operador = operador;
    }

    public Complexo getVisor() {
        return visor;
    }

    public void setVisor(Complexo visor) {
        this.visor = visor;
    }

    public void contas(){   //início do método principal desta classe
        Scanner input = new Scanner(System.in);
        operador = input.next().charAt(0);
        switch (operador) {
                    case 's':  //Realização da operação escolhida pelo utilizador
                                  visor=visor.simetrico();break;
                    case '+':
                                Complexo csoma = new Complexo(0,0);
                                csoma.setA(input.nextDouble());
                                csoma.setB(input.nextDouble());
                                visor=visor.soma(csoma);break;

Classe Calculadora:

private int opcao;  //Variáveis necessárias ao funcionamento da calculadora

private Historico historico=new Historico();

private OpCalculadora[] array=new OpCalculadora[25];

private OpCalculadora aux=new OpCalculadora();

public Historico getHistorico() { return historico; }

public void setHistorico(Historico historico) { this.historico = historico; }

public OpCalculadora[] getArray() { return array; }

public void setArray(OpCalculadora[] array) { this.array = array; }

public OpCalculadora getAux() { return aux; }

public void setAux(OpCalculadora aux) { this.aux = aux; }

public void calculadora(){  //Início do método principal da calculadora
    Scanner input=new Scanner(System.in);
    int i=0;

    do {
        System.out.println("\t\t---Menu---");
        System.out.println("1. Efetuar cálculos com números complexos");
        System.out.println("2. Limpar histórico");
        System.out.println("3. Apagar operação do histórico");
        System.out.println("4. Mudar a ordem das operações");
        System.out.println("5. Ver histórico");
        System.out.println("6. Sair");
        opcao = input.nextInt();

        historico.setOperacoes(array);  //Encher o histórico com o array de operações realizadas
        switch (opcao) {
            case 1:
                System.out.println("Instruções:");
                System.out.println("s -> simetrico\t c -> conjugado\t i -> inverso\t p -> potenciação");
                System.out.println("+ -> soma\t - -> subtração\t * ->multiplicação\t / -> divisão");
                System.out.println("Digite sempre na seguinte ordem: operador, parte real, parte imaginária do complexo");
                System.out.println("Para terminar as operações clique na tecla z");
                do {

                    if(i==0){  //Criação das 25 operações a realizar
                        aux=new OpCalculadora();
                        for (int j=0;j<25;j++){
                            array[j]=new OpCalculadora();
                        }
                    }

                    aux.contas(); //Realização das contas

                    array[i].setOperador(aux.getOperador()); //Enviar para o array a operação e os argumentos
                    array[i].setVisor(aux.getVisor());
                    i++;

                } while (aux.getOperador() != 'z' || i > 25);break;
            case 2:
                historico.limpar();
                i=0;break;
            case 3:
                historico.mostrar();
                historico.apagar();
                historico.mostrar();break;

Classe Histórico:

public class Historico {
   private OpCalculadora[] operacoes = new OpCalculadora[25];

   public OpCalculadora[] getOperacoes() {
     return operacoes;
   }

   public void setOperacoes(OpCalculadora[] operacoes) {
     this.operacoes = operacoes;
   }

Se eu entendi corretamente, você pode alterar o histórico através da definição de outros valores e/ou operação (soma, subtração, etc), isso?
Se for, você precisa usar os métodos setters para definir o novo valor e, após isso, invocar o método que efetua o cálculo necessário.

Olá, eu estou a fazer um projeto semelhante e gostaria de saber se podias pôr a parte da solução da recalculação das operações e histórico.