Algoritmo para localizar seqüências fixas e varíaveis de texto?

Programação Java
#1

Bom dia,

Gostaria de saber se alguém conhece um algoritmo que permita identificar em um determinado texto:
[list]Trechos de texto repetidos[/list][list]Trechos de texto varíaveis[/list][list]Separar ambos em um mapa onde a chave é a ordem (índice) em que os trechos estão no texto, e o valor do Map é o objeto que representa o trecho repetido/varíavel[/list]

A idéia é quebrar linhas de texto em estruturas onde eu possa extrair o texto repetido e o que varia e saber a ordem em que eles aparecem no texto original.

#2

Talvez seu problema possa ser resolvido com expressões regulares, cuja função é identificar padrões em textos:

http://download.oracle.com/javase/tutorial/essential/regex/
http://www.regular-expressions.info/java.html

O projeto Apache Lucene permite fazer buscas em textos, talvez seja útil também:

http://lucene.apache.org/java/docs/index.html

#3

voce pode tentar usar o pacote regex…

Como por exemplo as classes Pattern e Matcher…


Pattern p = Pattern.compile("xpto");
		
Matcher m = p.matcher("dsdljkixptodfdwewqxpto");
		
while(m.find()){
			
  String result = m.group() ;
		
}

onde como o roger_rf disse vc pode usar expessões regex no lugar da string xpto para procurar por padrões e criar sua logica para colocar no map os resultados dentro do while.

#4

O primeiro testes que fiz, para ver se dá certo, foi com o StringTokenizer, desta forma:

import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import org.apache.commons.lang.StringUtils;

public class Teste {

    private List<String> listStringsSeparadas;
    private final String stringOriginal;
    private int contStringsVariaveis;

    public Teste (String stringOriginal) {
        listStringsSeparadas = new ArrayList<> ();
        this.stringOriginal = stringOriginal;
        contStringsVariaveis = 0;
    }

    public void gerarStringsSeparadas() {
        
        StringTokenizer token = new StringTokenizer(stringOriginal);
        StringBuilder expressaoFixa = new StringBuilder();
        
        while (token.hasMoreTokens()) {
            String str = token.nextToken();
            int contStr = StringUtils.countMatches(stringOriginal, str);
            if (contStr > 1) {
                expressaoFixa.append(String.format("%s ", str));
            } else {
                listStringsSeparadas.add(expressaoFixa.toString());
                contStringsVariaveis++;
                listStringsSeparadas.add(String.format("[Variable String %d]", contStringsVariaveis));
                expressaoFixa.setLength(0);
            }
        }
        
    }

}

Embora tenha até conseguido separar vários trechos, para outros, não detectou corretamente, colocando String Fixa como String Varíavel e gerando várias String Varíaveis que não têm nada a ver (espaços em branco).
O problema é que para expressões regulares, teria que gerá-las dinamicamente…
Teria que ir extraindo as palavras, montar as expressões e procurar padrões?
Como ficaria, mais ou menos?

Para cadeias de string´s mais simples funcionou:

String codigo = "as barbas do rei careca\nas barbas do rei cabeludo"; /* Gerou a saída: as barbas do rei [Variable String 1] as barbas do rei [Variable String 2] */

No entanto, para cadeias complexas (segue exemplo com instruções sql):

        codigo = 
	" INSERT INTO [Teste] ( " + 
	" 	 Cod,	Ident, Ordem, Txt, Ajuda) VALUES ( " + 
	" 	 @Cod, \"Mãe - Nome\",  380  /*ordem */, null, null) " + 
	"  " + 
	"  " + 
	" INSERT INTO [Teste] ( " + 
	" 	 Cod,	Ident, Ordem, Txt, Ajuda) VALUES ( " + 
	" 	 @Cod, \"Mãe - Sobrenome\",  390  /*ordem */, null, null) ";

/*
Saída:
INSERT INTO [Teste] ( Cod, Ident, Ordem, Txt, Ajuda) VALUES ( @Cod, "Mãe - 
[Variable String 1]

[Variable String 2]
/*ordem */, null, null) INSERT INTO [Teste] ( Cod, Ident, Ordem, Txt, Ajuda) VALUES ( @Cod, "Mãe - 
[Variable String 3]

[Variable String 4]
*/

Este pode ser o caminho certo? Ou agrego expressões regulares aí?

#5