1. Prefácio
Durante o desenvolvimento, os envios dos textos de alguns usuários são frequentemente processados, por isso envolve a função de filtrar palavras sensíveis. A implementação do algoritmo de máquina de estado finita do DFA em materiais de referência é usada para criar gráficos direcionados. A filtragem de palavras sensíveis e slogans de publicidade foi concluída e a eficiência é boa, então compartilhe -a.
Implementação específica:
1. Filtragem da caixa de correspondência
2. Combine o filtro de largura de largura total
3. Filtragem de palavras de pausa do filtro de combinação.
4. Repita a filtragem de palavras para palavras sensíveis.
Por exemplo:
Suporta o seguinte tipo de detecção de filtragem:
Porra
Caso de foda
Foda-se meia largura de largura completa
f !!! u & c ### k Palavra de pausa
FFUUUUCCCCCKKK PALAVRAS DE REPETIÇÃO
Existem muitas maneiras de filtrar palavras sensíveis. Descreverei brevemente vários tipos que entendo agora:
① Consulte as palavras sensíveis no banco de dados, loop cada palavra sensível e, em seguida, pesquise do começo ao fim no texto de entrada para ver se existe essa palavra sensível.
Para ser franco, esse método é encontrar um para lidar com o outro.
Vantagens: tão fácil. Basicamente, não há dificuldade em implementá -lo com o código Java.
Desvantagens: Essa eficiência me faz correr mais de 100.000 cavalos de lama de grama em meu coração, e a correspondência é um pouco dolorosa? Se estiver em inglês, você encontrará uma coisa muito sem palavras, como o inglês.
A é uma palavra sensível. Se eu sou um documento em inglês, quantas vezes ele precisa processar palavras sensíveis? Alguém pode me dizer?
②O lendário algoritmo DFA (automata ruim) é exatamente o que eu quero compartilhar com você. Afinal, parece mais geral. Espero que todos possam verificar os princípios do algoritmo sozinhos.
As informações não serão explicadas em detalhes aqui.
Vantagens: pelo menos é mais eficiente que o SB acima.
Desvantagens: não deve ser difícil para aqueles que aprenderam algoritmos, mas não é difícil usá -los. É um pouco doloroso de entender, a eficiência correspondente não é alta e consome memória.
Quanto mais palavras sensíveis, mais memória ele consome.
③O terceiro tipo é explicado especificamente aqui, ou seja, você deve escrever um algoritmo ou otimizá -lo com base nos algoritmos existentes. É também o que Xiao Alan persegue.
Um dos reinos altos, se algum irmão obsceno tiver suas próprias idéias, não se esqueça de Xiao Alan. Você pode adicionar QQ de Xiao Alan: 810104041 para ensinar a Xiao Alan dois truques para jogar.
2. Implementação de código
Sua estrutura de diretório é a seguinte:
No diretório de recursos de recursos:
Stopwd.txt: Pause a palavra, o tempo de correspondência é filtrado diretamente.
WD.TXT: Thesaurus sensível.
1. Categoria de filtragem de palavras sensíveis ao Wordfilter
pacote org.andy.sensitivewdfilter; importar java.io.bufferedReader; importar java.io.ioException; importar java.io.inputStreamReader; importar java.util.arraylist; importar java.util.hashmap; importar java.util.hashset; importar java.util.list; importar java.util.map; importar java.util.set; importar org.andy.sensitivewdfilter.util.bcconvert; /** * Tempo de criação: 30 de agosto de 2016 às 15:01:12 * * IDEIA: Crie um filtro, enumerando se todos os chars de 0 ~ 65535 começam no início de uma palavra sensível * * Determine se eles começam em uma palavra sensível | | Não há problema em obter o nó da cabeça-a próxima palavra e depois atravessar passo a passo, algoritmo DFA * * @Author Andy * @version 2.2 */ public class WordFilter {private Static Final Filterset set = new Filterset (); // armazenar a primeira palavra mapa final estático privado <inteiro, wordNode> nós = new hashmap <Inteiro, wordNode> (1024, 1); // Nó de armazenamento Conjunto final estático privado <TEGER> stopWdSet = new HashSet <> (); // pausa word private static final char sinal = '*'; // filtragem de palavras sensíveis substitua estática {try {long a = system.nanotime (); init (); a = system.nanotime () - a; System.out.println ("Tempo de carregamento:" + a + "ns"); System.out.println ("Tempo de carregamento:" + A / 1000000 + "MS"); } Catch (Exceção e) {lança nova RunTimeException ("Falha no filtro de inicialização"); }} private estático void init () {// obtenha a palavra sensível AddSensitiveword (readwordfromfile ("wd.txt")); addstopword (readwordfromfile ("stopwd.txt")); } / ** * Adicione palavra sensível * @param caminho * @return * / lista estática privada <string> readwordFromFile (String Path) {list <string> words; BufferErader Br = null; tente {Br = new BufferredReader (new InputStreamReader (wordfilter.class.getclassloader (). getResourceasStream (path))); palavras = novo ArrayList <String> (1200); for (string buf = ""; (buf = Br.readline ())! = null;) {if (buf == null || buf.trim (). Equals ("")) continue; words.add (BUF); }} Catch (Exceção e) {lança nova RunTimeException (e); } finalmente {tente {if (br! = null) Br.Close (); } catch (ioexception e) {}} retornar palavras; } / ** * Adicionar palavras de pausa * * @param palavras * / private estático void addstopword (list final <string> words) {if (words! = Null && words.size ()> 0) {char [] chs; for (string curr: words) {chs = curr.toCharArray (); para (char c: chs) {stopwdset.add (charconvert (c)); }}}}} / *** Adicione o nó dfa* @param palavras* / private estático void addSensitiveword (list final <string> words) {if (words! = Null && words.size ()> 0) {char [] chs; int fchar; int lastIndex; WordNode fnode; // Primeira letra nó para (String curr: palavras) {chs = curr.toCharArray (); fchar = charconvert (chs [0]); if (! set.contains (fchar)) {// Nenhuma definição inicial set.add (fchar); // O primeiro sinalizador pode ser repetido adicionar. De qualquer forma, é julgado, por isso não será repetido fnode = new WordNode (fchar, chs.length == 1); modes.put (fchar, fnode); } else {fnode = nós.get (fchar); if (! fnode.islast () && chs.length == 1) fnode.setLast (true); } lastIndex = chs.length - 1; for (int i = 1; i <chs.length; i ++) {fnode = fnode.addifnoexist (CharConvert (chs [i]), i == LastIndex); }}}} / ** * O julgamento da filtragem converte palavras sensíveis em palavras mascaradas * @param src * @return * / public static final string dofilter (string final src) {char [] chs = src.toCharArray (); int length = chs.length; int curr; int k; Nó do WordNode; for (int i = 0; i <comprimento; i ++) {currc = charConvert (chs [i]); if (! set.contains (currc)) {continua; } node = nós.get (currc); // Dia 2 if (node == null) // Na verdade, não acontecerá, você está acostumado a escrevê -lo na continuidade; boolean poderia marcar = false; int marknum = -1; if (node.islast ()) {// com correspondência única de palavra (dia) poderia marcar = true; marknum = 0; } // Continue a corresponder (dia/dia) com prioridade de longo prazo // you-3 irmã-4 marido-5 k = i; para (; ++ k <comprimento;) {int temp = charConvert (chs [k]); if (stopwdset.contains (temp))) continue; node = node.QuerySub (temp); if (node == null) // sem quebra; if (node.islast ()) {poderia marcar = true; marknum = k - i; // 3-2}} if (poderia marcar) {for (k = 0; k <= marknum; k ++) {chs [k+i] = sinal; } i = i + marknum; }} Retorne nova string (chs); } / ** * Palavras sensíveis contêm * @param src * @return * / public static final boolean iSContains (string final src) {char [] chs = src.toCharArray (); int length = chs.length; int curr; int k; Nó do WordNode; for (int i = 0; i <comprimento; i ++) {currc = charConvert (chs [i]); if (! set.contains (currc)) {continua; } node = nós de nós (currc); // dia 2 if (node == null) // Isso não acontece, está habitualmente escrito em continuar; boolean poderia marcar = false; if (node.islast ()) {// com correspondência única de palavra (dia) poderia marcar = true; } // Continue combinando (dia você/dia sua irmã), com a prioridade da longevidade // you-3 irmã-4 marido-5 k = i; para (; ++ k <comprimento;) {int temp = charConvert (chs [k]); if (stopwdset.contains (temp))) continue; node = node.QuerySub (temp); if (node == null) // sem quebra; if (node.islast ()) {poderia marcar = true; }} if (poderia marcar) {return true; }} retornar false; } / ** * OUPERCASE para uma conversão de largura baixa em baixa largura em meia largura * * @param src * @return * / private static int charConvert (char src) {int r = bcconvert.qj2bj (src); return (r> = 'a' && r <= 'z')? r + 32: r; }} em:
ISContains: se deve incluir palavras sensíveis
Dofilter: Palavras sensíveis ao filtro
2. WordNode Sensitive Word nós
pacote org.andy.sensitivewdfilter; importar java.util.LinkedList; importar java.util.list; / ** * Criado: 30 de agosto de 2016 às 15:07:45 * * @Author Andy * @Version 2.2 */ public class WordNode {private int Value; // Nome do nó Lista privada <WordNode> subnodos; // Nó da criança private boolean islast; // padrão false public wordNode (int vale) {this.value = value; } public wordNode (int vale, boolean islast) {this.value = value; this.islast = islast; } / ** * * @param subnode * @return é o subnodo de entrada * / private wordNode AddSubNode (subnodes final do wordNode) {if (subnodes == null) subnodes = new LinkedList <WordNode> (); subnodes.add (subnodo); subnodo de retorno; } /*** Se houver, retorne o nó filho diretamente. Se não houver, crie e adicione e retorne o nó filho * * @param valor * @return */ public wordNode addifnoexist (valor final int, final booleano islast) {if (subnodes == null) {return addSubnode (new wordNode (value, islast)); } para (Subnode WordNode: Subnodes) {if (subnode.value == value) {if (! subnode.islast && islast) subnode.islast = true; subnodo de retorno; }} return addSubNode (new wordNode (value, islast)); } public wordNode querysub (value final int) {if (subnodes == null) {return null; } para (Subnode WordNode: Subnodes) {if (subnode.value == value) retornar subnode; } retornar nulo; } public boolean islast () {return islast; } public void setLast (boolean islast) {this.islast = islast; } @Override public int hashCode () {return value; }}3. Resultados dos testes
O projeto inclui sinário sensível, código -fonte, pausa de sinônimos, etc. Basta executar o pacote Maven e Jar para ser executado diretamente.
Código fonte do projeto: sensívelwd-filter_jb51.rar
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.