1. Prefacio
Durante el desarrollo, las presentaciones de los textos de algunos usuarios a menudo se procesan, por lo que implica la función de filtrar palabras sensibles. La implementación del algoritmo de máquina de estado finito DFA en materiales de referencia se utiliza para crear gráficos dirigidos. El filtrado de palabras sensibles y lemas publicitarios se ha completado, y la eficiencia es buena, así que compártala.
Implementación específica:
1. Filtrado de casos de coincidencia
2. Haga coincidir el filtro de medio ancho de ancho completo
3. Filtrado de palabras de pausa de filtro de combinación.
4. Repita el filtrado de palabras para palabras sensibles.
Por ejemplo:
Admite la siguiente detección de filtrado de tipo:
Mierda
Caso de joder
Joder ancho completo medio ancho
f !!! u & c ### k PAUSA PALABRA
palabras de repetición ffuuuucccckkk
Hay muchas formas de filtrar palabras sensibles. Describiré brevemente varios tipos que entiendo ahora:
① Consulte las palabras confidenciales en la base de datos, enrleje cada palabra confidencial y luego busque de comenzar a terminar en el texto de entrada para ver si esta palabra confidencial existe.
Para decirlo sin rodeos, este método es encontrar uno para tratar con el otro.
Ventajas: Muy fácil. Básicamente no es dificultad implementarlo con el código Java.
Desventajas: ¿Esta eficiencia me hace correr más de 100,000 caballos de barro de hierba en mi corazón, y el partido es un poco doloroso? Si está en inglés, encontrará algo muy sin palabras, como el inglés.
A es una palabra sensible. Si soy un documento en inglés, ¿cuántas veces tiene que procesar palabras confidenciales? ¿Alguien puede decirme?
② El legendario algoritmo DFA (autómatas pobres) es exactamente lo que quiero compartir con ustedes. Después de todo, se siente más general. Espero que todos puedan verificar los principios del algoritmo por sí mismos.
La información no se explicará en detalle aquí.
Ventajas: al menos es más eficiente que el SB anterior.
Desventajas: no debería ser difícil para aquellos que han aprendido algoritmos, pero no es difícil usarlos. Es un poco doloroso de entender, la eficiencia correspondiente no es alta y consume memoria.
Cuantas más palabras sensibles, más memoria consume.
③ El tercer tipo se explica específicamente aquí, es decir, debe escribir un algoritmo usted mismo u optimizarlo en función de los algoritmos existentes. Esto es también lo que busca Xiao Alan.
Uno de los reinos altos, si algún hermano lascivo tiene sus propias ideas, no olvides a Xiao Alan. Puede agregar el QQ de Xiao Alan: 810104041 para enseñarle a Xiao Alan dos trucos para jugar.
2. Implementación del código
Su estructura de directorio es la siguiente:
En el directorio de recursos de recursos:
stopwd.txt: PAUSE Word, Match Time se filtra directamente.
WD.TXT: Tesauro sensible.
1. Categoría de filtrado de palabras sensible a WordFilter
paquete org.andy.sensitiveWdFilter; import java.io.bufferedReader; import java.io.ioException; import java.io.inputstreamreader; import java.util.arrayList; import java.util.hashmap; import java.util.hashset; import java.util.list; import java.util.map; import java.util.set; importar org.andy.sensitivewdfilter.util.bcconvert; /** * Tiempo de creación: 30 de agosto de 2016 a las 3:01:12 pm * * Idea: Crear una línea de filtros, enumerando si todos los caracteres de 0 ~ 65535 comienzan al comienzo de una palabra sensible * * Determinar si comienzan con una palabra sensible | | ¿Está bien obtener el nodo de cabeza? La siguiente palabra y luego atravesar paso a paso, algoritmo DFA * * @author andy * @version 2.2 */ public class WordFilter {private static final filterset set = new filterset (); // Almacene la primera palabra mapa final estático privado <Integer, wordnode> nodos = new Hashmap <Integer, WordNode> (1024, 1); // Nodo de almacenamiento Estatico Private Static Final Set <Integer> stopWDSET = new Hashset <> (); // Pausa Word Private Static Static Final Char signo = '*'; // filtrado de palabras sensible reemplazar estático {try {long a = system.nanotime (); init (); a = system.nanotime () - a; System.out.println ("Tiempo de carga:" + a + "ns"); System.out.println ("Tiempo de carga:" + A / 1000000 + "MS"); } catch (Exception e) {Throw New RuntimeException ("Falló el filtro de inicialización"); }} private static void init () {// Obtenga la palabra sensible addsensitiveword (leewordFromFile ("wd.txt")); addStOpWord (leewordFromFile ("stopwd.txt")); } / ** * Agregar palabra sensible * @param ruta * @return * / private static list <String> leewordFile (string ruta) {list <string> palabras; BufferedReader BR = NULL; intente {br = new BufferedReader (new InputStreamReader (wordfilter.class.getClassLoader (). getResourceasstream (ruta))); palabras = new ArrayList <String> (1200); for (string buf = ""; (buf = br.readline ())! = null;) {if (buf == null || buf.trim (). Equals ("")) Continuar; palabras.add (buf); }} Catch (Exception e) {Throw New RuntimeException (e); } finalmente {try {if (br! = null) br.close (); } catch (ioException e) {}} devuelve palabras; } / ** * Agregar palabras de pausa * * @param palabras * / private static void addStopword (Lista final <string> palabras) {if (palabras! = Null && words.size ()> 0) {char [] chs; for (String Curr: Words) {CHS = Curr.ToCarArray (); para (char c: chs) {stopwdset.add (charconvert (c)); }}}}} / *** Agregar nodo dfa* @param palabras* / private static void addsensitiveword (lista final <string> palabras) {if (words! = Null && words.size ()> 0) {char [] chs; int fchar; int LastIndex; Wordnode fnode; // Nodo de primera letra para (String Curr: Words) {CHS = Curr.ToCarArray (); fchar = charconvert (chs [0]); if (! set.contains (fchar)) {// sin definición inicial set.add (fchar); // El primer indicador puede repetirse. De todos modos, se juzga, por lo que no se repetirá fnode = new WordNode (fchar, chs.length == 1); nodos.put (fchar, fnode); } else {fnode = nodo.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); }}}} / ** * Filtrado del juicio convierte palabras sensibles en palabras enmascaradas * @param src * @return * / public static final string dofilter (string final src) {char [] chs = src.toCarArray (); int longitud = chs.length; int Currc; int k; WordNode Node; for (int i = 0; i <longitud; i ++) {currc = charconvert (chs [i]); if (! set.contains (currc)) {continuar; } nodo = nodo.get (Currc); // Día 2 if (node == null) // En realidad no sucederá, está acostumbrado a escribirlo en la continuidad; boolean podría marcar = falso; int marknum = -1; if (node.islast ()) {// coincidencia de una sola palabra (día) podría marcar = true; Marknum = 0; } // Continuar coincidiendo (día/día) con prioridad a largo plazo // usted-3 hermana-4 marido-5 k = i; for (; ++ k <longitud;) {int temp = charconvert (chs [k]); if (stopwdset.contains (temp))) continuar; nodo = node.querySub (temp); if (nodo == null) // sin descanso; if (node.isLast ()) {podría marcar = true; marknum = k - i; // 3-2}} if (podría marcar) {for (k = 0; k <= marknum; k ++) {chs [k+i] = signo; } i = i + marknum; }} return New String (CHS); } / ** * Las palabras sensibles contienen * @param src * @return * / public static final boolean isContains (String final src) {char [] chs = src.toCarArray (); int longitud = chs.length; int Currc; int k; WordNode Node; for (int i = 0; i <longitud; i ++) {currc = charconvert (chs [i]); if (! set.contains (currc)) {continuar; } nodo = nodo.get (Currc); // Día 2 if (node == null) // No sucede, se escribe habitualmente en continuar; boolean podría marcar = falso; if (node.islast ()) {// coincidencia de una sola palabra (día) podría marcar = true; } // Continúa coincidiendo (Día de tu hermana), con la prioridad de la longevidad // You-3 hermana-4 marido-5 k = i; for (; ++ k <longitud;) {int temp = charconvert (chs [k]); if (stopwdset.contains (temp))) continuar; nodo = node.querySub (temp); if (nodo == null) // sin descanso; if (node.isLast ()) {podría marcar = true; }} if (podría marcar) {return true; }} return false; } / ** * upcase a la conversión de ancho completo en minúsculas en medio ancho * * @param src * @return * / private static int charconvert (char src) {int r = bcconvert.qj2bj (src); return (r> = 'a' && r <= 'z')? r + 32: r; }} en:
iSContains: si incluir palabras sensibles
Dofilter: palabras sensibles al filtro
2. Nodos de palabras sensibles a WordNode
paquete org.andy.sensitiveWdFilter; import java.util.linkedlist; import java.util.list; / ** * Creado: 30 de agosto de 2016 a las 3:07:45 pm * * @author Andy * @version 2.2 */ public class WordNode {private int value; // Nombre del nodo Lista privada <SdodeDode> subnodes; // Nódigo infantil privado boolean islast; // falso público predeterminado wordnode (int value) {this.value = value; } public WordNode (int value, boolean islast) {this.value = valor; this.islast = islast; } / ** * * @param subnode * @return es el subnode entrante * / private wordnode addSubnode (final de WordNode subnode) {if (subnodes == null) subNodes = new LinkedList <DordNode> (); subnodes.add (subnode); return subnode; } /*** Si hay, devuelve el nodo infantil directamente. Si no hay, cree y agregue y devuelva el nodo infantil * * @param valor * @return */ public wordnode addifNoExist (value final int, final boolean islast) {if (subnodes == null) {return addsubNode (new WordNode (valor, islast)); } for (wordnode subnode: subnodes) {if (subnode.value == value) {if (! subnode.islast && islast) subnode.islast = true; return subnode; }} return addSubNode (nuevo WordNode (valor, islast)); } public WordNode QuerySub (final de valor int) {if (subnodes == null) {return null; } for (wordnode subnode: subnodes) {if (subnode.value == value) return subnode; } return null; } public boolean islast () {return islast; } public void setLast (boolean islast) {this.islast = islast; } @Override public int hashcode () {Valor de retorno; }}3. Resultados de la prueba
El proyecto incluye el tesauro sensible, el código fuente, la pausa del tesauro, etc. Simplemente ejecute el paquete Maven y JAR para ejecutar directamente.
Código fuente del proyecto: SensitiveWD-Filter_JB51.rar
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.