Manipulando Arrays

Compara com char, seu código fica mais rápido…

String texto = jTextField1.getText();
char[] matriz = texto.toCharArray();
int soma = 0;

for (char c : matriz) {
    if (c == 'Y') {
        soma += 5;
    }
    if (c == 'X' || c == '2') {
        soma += 10;
    }
}
System.out.println(soma);

Veja se ajuda…

Então, até pensei nisso. Mas queria algo genérico, que funcionasse pra qualquer dígito 3, 8, 25… Seria massante fazer na mão. No caso, eu quero, generalizar inclusive as váriáveis, pra não ficar preso só no X Y.

Hummm, ai são outros quinhentos…

Como seria a entrada, X 6 Y por exemplo? o que muda seria sempre o dígito? X e Y são fixos mesmo cada um com seu valor “travado”?

Se sim, você pode fazer assim…

String texto = jTextField1.getText();
char[] matriz = texto.toCharArray();
int soma = 0;

for (char c : matriz) {
    if (c == 'Y') {
        soma += 5;
    }
    if (c == 'X') {
        soma += 10;
    }
    if (Character.isDigit(c)) {
        soma += 10 * Character.getNumericValue(c);
    }
}
System.out.println(soma);

Então, os valores são fixos.
Aí eu queria que se modificasse meu array se a entrada é X 6 Y, o array fica X X X X X X Y,

A entrada também poderia ser X 2 Z 2 Y 3, que no array ficaria X X Z Z Y Y Y

Na minha opinião não acho que ficaria legal você multiplicar as letras e colocá-las no array dessa forma, o array pode ficar gigante!

Como as letras podem ser várias, X, Y, Z, etc… sugiro mapeá-las:

Map<Character, Integer> mapa = new HashMap<>();
 mapa.put('X', 10);
 mapa.put('Y', 5);
 mapa.put('Z', 15); // por exemplo...

E você pode criar uma variável para guardar a letra anterior para usar no calculo quando for digito…

int soma = 0;
char letraAnterior = ' ';

Depois no for, você pode compará-las e resgatar o valor dinamicamente…

if (mapa.contains(c)) {
    soma += mapa.get(c);
    letraAnterior = c;
} else if (Character.isDigit(c)) {
    soma += mapa.get(letraAnterior) * Character.getNumericValue(c);
}

Assim dessa forma o array não fica gigante, você ainda tem poucos if’s no laço e ainda deixa tudo dinamico, se outra letra nova surgir, basta mapeá-la com o valor do cálculo…

Posso ter errado alguma coisinha no cálculo, mas a idéia seria essa…

Então, eu sou um pouco teimoso e mantive comparando com Strings.
Já tenho um “mapeamento” com um array bidimensional [ ] [ ]
Consegui montar uma lógica baseado nas suas dicas Lost. E ficou assim:

String texto = jTextField1.getText();
String[] matriz = texto.split(" ");
String[][] mapa = {{"X","2"},{"Y","1.5"},{"Z","2.08"}};
double soma=0;.

for(String i: matriz){
    for(int o = 0; o < mapa.length; o++){
        if(mapa[o][0].equals(i)){          
            soma += Double.parseDouble(mapa[o][1]);

        }else if(isNumber(i)){ //Falam que o isNumber é obsoleto, mas não achei outro forma de comparar o string
            System.out.println(i);
            soma *= Double.parseDouble(i);
            break; //Só com o uso do break eliminou saídas desnecessárias

       }
}
System.out.println("soma: "=soma);

Mudou bastante de figura né ^^’

Agora eu quero adicionar outros operadores ( +, -) no textfild e realizar a operação X 2 Y + X Z 2, tive que adicionar um break no meu else if, porque na saída os numeros saíam na quantidade do tamanho da array, se não me engano.
Mas continuo aceitando dicas, sempre bom mais de uma opinião

A questão não é ser teimoso ou não, mas o custo computacional que o algoritmo vai gerar pegou?

Para projetinhos pequenos, com entradas pre definidas ou configuradas é uma coisa, mas em projetos grandes, a lógica aplicada pode e muito afetar o andamento da aplicação…

Mas foi apenas uma sugestão, bom que encontrou uma lógica diferente e melhor ainda conseguir solucionar o problema.

Um artigo legal falando um pouco sobre string só pra você ter uma noção…

Obrigado, vou me aprofundar nessa questão de desempenho, deixar meus códigos mais enxuto.
Vou começar minha faculdade de computação espero aprender muito, melhorar as técnicas de programação e engenharia de software. Ainda sou apenas um curioso apaixonado por inteligência artificial