Como usar vários replace no java

Programação
#1

Galerinha, boa tarde,

Mais uma vez estou por aqui pedindo uma ajuda, tenho 2 problemas para terminar o meu programa em java que só estou conseguindo terminar por causa da ajuda de vcs, tô tentando.

Seguinte;

Tenho em um JTextarea o texto de uma musica com cifras (notas) conforme mostro abaixo.

Am Dm
Hoje eu quero a rosa mais linda que houver
E7 Am Dm E7
E a primeira estrela que vier para enfeitar a noite do meu bem
Am Dm
Hoje eu quero paz de criança dormindo

Fiz um código para trocar as notas da musica, que esta na nota A e eu quero tocar em B, logo.
quando o programa lê a nota A, ele troca para B, quando toca D ele troca para E, quando toca E ele troca para F#, até ai tudo bem, fiz um código, comprido, feio, usando vários cases e replaces, mas que pretendo mudar quando aprender a trabalhar com Programação Orientada a Objeto, minha duvida é como usar o replace para as trocas das notas, abaixo segue o que tentei fazer sem exito, não da erro, mas ele troca todas as notas por A##########################, acho que ele só valida o ultimo replace, falta de conhecimento do uso do replace ou do replaceAll

Parte do Código;

private void btnAlterarActionPerformed(java.awt.event.ActionEvent evt) {
// Cliquei no botão alterar
if ((txtTomAtual.getText() .equals (txtNovoTom.getText()))) {
JOptionPane.showMessageDialog(null, “Tom atual e Novo tom, não podem ser iguais “);
}else{
String tomAtual = txtTomAtual.getText();
String tomNovo = txtNovoTom.getText();
String texto = txtArea.getText(); //pego o texto da jTextArea
String[] linhas = texto.split(”\n”);
for (int i = 0; i < linhas.length; i += 2) { leio somente as linhas onde tenho as cifras(notas) .
switch (tomAtual + tomNovo) {
case “AB”:
txtArea.setText(txtArea.getText().replace(“A”, “B”));
txtArea.setText(txtArea.getText().replace(“B”, “C#”));
txtArea.setText(txtArea.getText().replace(“C”, “D”));
txtArea.setText(txtArea.getText().replace(“C#”, “D#”));
txtArea.setText(txtArea.getText().replace(“D”, “E”));
txtArea.setText(txtArea.getText().replace(“D#”, “F”));
txtArea.setText(txtArea.getText().replace(“E”, “F#”));
txtArea.setText(txtArea.getText().replace(“F”, “G”));
txtArea.setText(txtArea.getText().replace(“F#”, “G#”));
txtArea.setText(txtArea.getText().replace(“G”, “A”));
txtArea.setText(txtArea.getText().replace(“G#”, “A#”));
break;
case “AC”:
JOptionPane.showMessageDialog(null, "Passei por AC ");
break;
case “AD”:
break;
case “A#F”:
break;
JOptionPane.showMessageDialog(null, "Passei A#G ");
break;
default:
JOptionPane.showMessageDialog(null, “Novo tom, so aceita A,B,C,D,E,F,G ou
A#,C#,D#,E,F#,G#”);
} // Fim do Suitch

Se alguém puder ajudar, eu agradeço muito,

Obrigado,

Armando.

#2

@filosi
Boa noite campeão.

Sei que já faz muito tempo, mas aqui está um trecho de código que funciona, mas ainda precisa de ajustes e refatoração. Talvez esse post ajude outras pessoas.

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class DataFormatTest {

public static void main(String[] args) {
    try {
        DataFormatTest dataFormatTest = new DataFormatTest();
        dataFormatTest.btnAlterarActionPerformed(new ActionEvent(dataFormatTest, 1, ""));
    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

private JTextField txtTomAtual = new JTextField("A");
private JTextField txtNovoTom = new JTextField("B");
private JTextArea txtArea = new JTextArea("Am Dm\n"
        + "Hoje eu quero a rosa mais linda que houver\n"
        + "E7 Am Dm E7\n"
        + "E a primeira estrela que vier para enfeitar a noite do meu bem\n"
        + "Am Dm\n"
        + "Hoje eu quero paz de criança dormindo"
);

private void btnAlterarActionPerformed(java.awt.event.ActionEvent evt) {
    System.out.println(trocarTom(txtTomAtual.getText(), txtNovoTom.getText(), txtArea.getText()));
}

/**
 * Troca as notas da música:
 * <p>
 * 1- A to B;
 * 2- B to C#;
 * 3- C to D;
 * 4- C# to D#;
 * 5- D to E;
 * 6- D# to F;
 * 7- E to F#;
 * 8- F to G;
 * 9- F# to G#;
 * 10- G to A;
 * 11- G# to A#;
 */
public String trocarTom(String tomAtual, String tomNovo, String musica) {
    Map<String, String[][]> notas = new HashMap() {
        {
            put("AB", new String[][]{
                    {"A", "B"},
                    {"B", "C#"},
                    {"C", "D"},
                    {"C#", "D#"},
                    {"D", "E"},
                    {"D#", "F"},
                    {"E", "F#"},
                    {"F", "G"},
                    {"F#", "G#"},
                    {"G", "A"},
                    {"G#", "A#"},
            });
            put("AC", null);
            put("AD", null);
            put("A#F", null);
            put("A#G", null);
        }
    };

    //valida troca de tom
    if (tomAtual.equals(tomNovo)) {
        JOptionPane.showMessageDialog(null, "Tom atual e Novo tom, não podem ser iguais");
        return musica;
    }

    //valida existência da combinação no map para troca
    if (!notas.containsKey(tomAtual.concat(tomNovo))) {
        JOptionPane.showMessageDialog(null, "Novo tom, so aceita A, B, C, D, E, F, G ou A#, C#, D#, E, F#, G#");
        return musica;
    }

    String[] lines = musica.split("\n");

    //itera as linhas
    for (int i = 0; i < lines.length; i++) {
        //verifica se é a linha das notas
        if (i % 2 != 0) {
            continue;
        }
        //pega as notas antigas, novas e aloca um array bidimensional para guardar os replaces
        String[] notasAntigas = lines[i].split("\\s+");
        String[][] notasNovas = notas.get(tomAtual + tomNovo);
        String[][] replaces = new String[notasAntigas.length][notasAntigas.length];

        //verifica as notas que precisam ser trocadas e insere no array replaces
        for (int na = 0; na < notasAntigas.length; na++) {
            for (int n = 0; n < notasNovas.length; n++) {
                if (notasAntigas[na].contains(notasNovas[n][0])) {
                    replaces[na][0] = notasAntigas[na];
                    replaces[na][1] = notasAntigas[na].replaceAll(String.format("[%s]", notasNovas[n][0]), notasNovas[n][1]);
                    break;
                }
            }
        }

        //troca as notas contidas no replace da linha atual
        for (int n = 0; n < replaces.length; n++) {
            lines[i] = lines[i].replace(replaces[n][0], replaces[n][1]);
        }
    }
    //junta a linhas novamente em uma única String
    return Stream.of(lines).collect(Collectors.joining("\n"));
}

}