Criptografar uma senha usando Pilha em Java

Programação
#1

Um a administrador de um sistema de computadores precisa memorizar muitas senhas de acesso usadas em
cada uma das máquinas que gerencia. Por uma questão de segurança cada máquina tem que ter uma senha de
acesso diferente.
A fim de salvar as senhas em um arquivo e não colocar em risco a segurança do sistema, este administrador
convencionou gerar senhas de acesso usando apenas palavras com letras minúsculas e números separados por
_ ou por #.
Antes de armazenar cada senha, cada palavra da senha separada por _ ou por # tem a ordem dos caracteres
invertidos. Exemplos:
• codigo_alta#123 seria trocado por ogidoc_atla#321
• trab#1_2020_cap ficaria bart#1_0202_pac
Além disso, algumas letras são trocadas por símbolos, são elas:
Original a s r e i o u
Trocado por @ $ * & ! ( +
Ainda mais uma alteração deve ser feita: todas as letras minúsculas são trocadas para maiúsculas.
Finalmente, as senhas do exemplo depois de todos os processos ficam armazenadas da seguinte forma:
(G!D(C_@TL@#321 e B@*T#1_0202_P@C.
Elabore um programa em linguagem JAVA que faça as alterações descritas nas senhas a serem armazenadas.
Sendo OBRIGATÓRIO:
• Criar uma classe PilhaChar que implemente o tipo dado pilha seqüencial com dados do tipo char
(esta pilha deve ser usada a fim de fazer as inversões das palavras da senha);
• Criar uma classe SalvaSenha que contenha o método main() que leia uma senha do teclado e utiliza
a pilha de caracteres implementada na classe PilhaChar para inverter a ordem das palavras da senha
e que faça as alterações dos caracteres descritas anteriormente.

#2

@AnnaGiuliaGatti
Boa tarde. Segue um exemplo de como implementar esse algoritmo. Espero que ajude.

import java.util.Scanner;

public class SalvaSenha {

public static void main(String[] args) {
    new SalvaSenha().cryptography();
}

private void cryptography() {
    try {
        String exemplo1 = "codigo alta 123";
        PilhaChar pilhaChar1 = new PilhaChar(exemplo1.toLowerCase().toCharArray());
        pilhaChar1.cryptography();

        String exemplo2 = "trab 1_2020 cap";
        PilhaChar pilhaChar2 = new PilhaChar(exemplo2.toLowerCase().toCharArray());
        pilhaChar2.cryptography();

        System.out.println(String.format("Exemplo 1: %s\nResultado: %s\n", exemplo1, pilhaChar1));
        System.out.println(String.format("Exemplo 2: %s\nResultado: %s\n", exemplo2, pilhaChar2));

        Scanner scanner = new Scanner(System.in);
        System.out.println("Digite uma senha");
        String charSequence = scanner.nextLine().toLowerCase();

        PilhaChar pilhaChar3 = new PilhaChar(charSequence.toCharArray());
        pilhaChar3.cryptography();

        System.out.println(String.format("Entrada: %s\nResultado: %s\n", charSequence, pilhaChar3));
    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

}

import java.util.Arrays;

public class PilhaChar implements CharSequence {

private char[] charSequence;

public PilhaChar(char[] charSequence) {
    this.charSequence = charSequence;
}

public void cryptography() {
    int s = 0;
    int lastIndex = 0;
    char[] separators = {95, 35};
    char[] newCharSequence = new char[length()];

    for (int index = 0; index < length(); index++) {
        switchKeyChars(index);
        upperCase(index);
        if (charSequence[index] == 32) {
            charSequence[index] = separators[s];
            s = s == 0 ? 1 : 0;
            lastIndex = invertSequence(index, lastIndex, newCharSequence);
        } else if (index == length() - 1) {
            invertSequence(length(), lastIndex, newCharSequence);
        }
    }
    charSequence = newCharSequence;
}

private void upperCase(int index) {
    //65 - 90 A - Z
    //97 - 122 a - z
    if ((charSequence[index] >= 97 && charSequence[index] <= 122)) {
        charSequence[index] = (char) (charSequence[index] - 32);
    }
}

private void switchKeyChars(int index) {
    char chr = 0;
    switch (charSequence[index]) {
        case 97: //a
            chr = 64; //@
            break;
        case 115: //s
            chr = 36; //$
            break;
        case 114: //r
            chr = 42; //*
            break;
        case 101: //e
            chr = 38; //&
            break;
        case 105: //i
            chr = 33; //!
            break;
        case 111: //o
            chr = 40; //(
            break;
        case 117:
            chr = 43; //+
            break; //u
    }
    if (chr != 0) charSequence[index] = chr;
}

private int invertSequence(int index, int lastIndex, char[] newCharSequence) {
    int count = 1;
    for (int i = (lastIndex == 0 ? lastIndex : lastIndex + 3); i < index; i++) {
        newCharSequence[i] = charSequence[index - count++];
    }
    if (index != length()) {
        newCharSequence[index] = charSequence[index];
    }
    return index - 2;
}

@Override
public int length() {
    return charSequence.length;
}

@Override
public char charAt(int index) {
    return charSequence[index];
}

@Override
public CharSequence subSequence(int start, int end) {
    char[] subSequence = new char[(end - start) + 1];
    for (int count = 1; count < end; count++) {
        subSequence[count - 1] = charSequence[start++];
    }
    return new PilhaChar(subSequence);
}

@Override
public String toString() {
    return Arrays.toString(charSequence);
}

}