1. Préface
Pendant le développement, les soumissions de textes de certains utilisateurs sont souvent traitées, donc elle implique la fonction de filtrage des mots sensibles. L'implémentation de l'algorithme de machine à états finis DFA dans les matériaux de référence est utilisée pour créer des graphiques dirigés. Le filtrage des mots sensibles et des slogans publicitaires a été achevé et l'efficacité est bonne, alors partagez-la.
Implémentation spécifique:
1. Filtrage de boîtier de correspondance
2. Faites correspondre le filtre à demi-largeur pleine largeur
3. Filtrage des mots en pause de filtre correspondant.
4. Répéter le filtrage des mots pour les mots sensibles.
Par exemple:
Prend en charge la détection de filtrage de type suivant:
Putain
Casse de baise
Baise la large largeur de largeur
F !!! U & C ### K PAUSE MOT
FFUUUUCCCCCKKK MOTS DE RÉPÉTITION
Il existe de nombreuses façons de filtrer les mots sensibles. Je vais brièvement décrire plusieurs types que je comprends maintenant:
① Interrogez les mots sensibles de la base de données, bouclez chaque mot sensible, puis recherchez depuis le début du texte d'entrée pour voir si ce mot sensible existe.
Pour le dire franchement, cette méthode consiste à en trouver l'une pour faire face à l'autre.
Avantages: si facile. Ce n'est essentiellement aucune difficulté de l'implémenter avec du code Java.
Inconvénients: cette efficacité me fait courir plus de 100 000 chevaux de boue d'herbe dans mon cœur, et le correspondant est un peu douloureux? Si c'est en anglais, vous trouverez une chose très sans voix, comme l'anglais.
A est un mot sensible. Si je suis un document anglais, combien de fois doit-il traiter des mots sensibles? Quelqu'un peut-il me le dire?
② L'algorithme DFA légendaire (pauvre automate) est exactement ce que je veux partager avec vous. Après tout, cela semble plus général. J'espère que tout le monde pourra vérifier les principes de l'algorithme par eux-mêmes.
Les informations ne seront pas expliquées en détail ici.
Avantages: Au moins, il est plus efficace que celle ci-dessus.
Inconvénients: Cela ne devrait pas être difficile pour ceux qui ont appris des algorithmes, mais il n'est pas difficile de les utiliser. C'est juste un peu douloureux à comprendre, l'efficacité de correspondance n'est pas élevée et elle consomme de la mémoire.
Plus il y a de mots sensibles, plus il consomme de mémoire.
③Le troisième type est spécifiquement expliqué ici, c'est-à-dire que vous devez écrire vous-même un algorithme, ou l'optimiser en fonction des algorithmes existants. C'est aussi ce que poursuit Xiao Alan.
L'un des domaines élevés, si un frère obscène a ses propres idées, n'oubliez pas Xiao Alan. Vous pouvez ajouter QQ: 810104041 de Xiao Alan pour enseigner à Xiao Alan deux astuces à jouer.
2. Implémentation du code
Sa structure d'annuaire est la suivante:
Dans le répertoire des ressources de ressources:
stopwd.txt: le mot de pause, le temps de correspondance est filtré directement.
wd.txt: thésaurus sensible.
1. Catégorie de filtrage des mots sensible à WordFilter
Package org.andy.SensitiveWdFilter; Importer java.io.bufferedReader; Importer java.io.ioException; Importer java.io.inputStreamReader; import java.util.arraylist; import java.util.hashmap; import java.util.hashset; Importer java.util.list; importation java.util.map; import java.util.set; Import org.andy.sensitivewdfilter.util.bcConvert; / ** * Temps de création: 30 août 2016 à 15:01:12 PM * * IDEA: Créez un filtret, énumérant si tous les caractères de 0 ~ 65535 commencent au début d'un mot sensible * * Déterminez s'ils commencent par un mot sensible | | Est-il acceptable d'obtenir le nœud de tête - le mot suivant puis de traverser étape par étape, algorithme DFA * * @author Andy * @version 2.2 * / public class wordFilter {private static final FilterSet Set = new FilterSet (); // Stockez le premier mot carte finale statique privée <Integer, wordnode> nœuds = new hashmap <Integer, wordnode> (1024, 1); // Node de stockage Set final statique privé <Integer> stopwdSet = new HashSet <> (); // Pause Word Private Static Final Char Sign = '*'; // filtrage de mot sensible remplacer statique {try {long a = system.nanotime (); init (); a = System.NanoTime () - A; System.out.println ("Temps de chargement:" + a + "ns"); System.out.println ("Temps de chargement:" + A / 1000000 + "MS"); } catch (exception e) {lancer une nouvelle RuntimeException ("Filtre d'initialisation a échoué"); }} private static void init () {// Obtenez le mot sensible addSensitive (readwordFromFile ("wd.txt")); AddStOPWORD (readwordFromFile ("stopwd.txt")); } / ** * Ajouter un mot sensible * @param path * @return * / private static list <string> readwordFromfile (String path) {list <string> words; BufferedReader br = null; try {br = new BufferedReader (new inputStreamReader (wordFilter.class.getClassOLODOller (). getResourceSstream (path))); words = new ArrayList <string> (1200); for (String buf = ""; (buf = br.readline ())! = null;) {if (buf == null || buf.trim (). equals ("")) continue; words.add (buf); }} catch (exception e) {lancer une nouvelle RuntimeException (e); } enfin {try {if (br! = null) br.close (); } catch (ioException e) {}} retour des mots; } / ** * Add Pause Word * * @param mots * / private static void addstopword (list final <string> words) {if (words! = Null && word.size ()> 0) {char [] chs; for (String curr: words) {chs = curr.tocharArray (); pour (char c: chs) {stopwdset.add (charconvert (c)); }}}}} / ** * Ajouter le nœud dfa * @param mots * / private static void addSensitiveword (final list <string> words) {if (words! = Null && words.size ()> 0) {char [] chs; int fChar; int lastIndex; Wordnode fnode; // Node de première lettre pour (String Curr: Words) {chs = curr.tocharArray (); fChar = charconvert (chs [0]); if (! set.contains (fChar)) {// pas de définition initiale set.add (fChar); // Le premier drapeau peut être répété. Quoi qu'il en soit, il est jugé, il ne sera donc pas répété fnode = new WordNode (fChar, chs.length == 1); NODES.PUT (FCHAR, FNODE); } else {fnode = nœuds.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); }}}} / ** * Le jugement de filtrage convertit les mots sensibles en mots masqués * @param src * @return * / public static final string dofilter (final string src) {char [] chs = src.ToCharArray (); int length = chs.length; int currc; Int K; Node WordNode; pour (int i = 0; i <length; i ++) {currc = charconvert (chs [i]); if (! set.contains (currc)) {continuant; } node = nœuds.get (currc); // jour 2 if (node == null) // En fait, cela ne se produira pas, vous êtes habitué à l'écrire sur la continuité; booléen pourraitmark = false; int marknum = -1; if (node.islast ()) {// Match Matching (Day) pourraitmark = true; marknum = 0; } // Continuez à correspondre (jour / jour) avec une priorité à long terme // vous-3 sœur-4 mari-5 k = i; pour (; ++ k <longueur;) {int temp = charconvert (chs [k]); if (stopwddset.contains (temp))) continue; node = node.QuerySub (temp); if (node == null) // pas de pause; if (node.islast ()) {pourraitmark = true; marknum = k - i; // 3-2}} if (pourraitmark) {for (k = 0; k <= marknum; k ++) {chs [k + i] = signe; } i = i + marknum; }} return new String (chs); } / ** * Les mots sensibles contiennent-ils * @param src * @return * / public static final booléan isContains (Final String src) {char [] chs = src.tocharArray (); int length = chs.length; int currc; Int K; Node WordNode; pour (int i = 0; i <length; i ++) {currc = charconvert (chs [i]); if (! set.contains (currc)) {continuant; } node = nœuds.get (currc); // jour 2 if (node == null) // Cela ne se produit pas, il est habituellement écrit sur continue; booléen pourraitmark = false; if (node.islast ()) {// Match Matching (Day) pourraitmark = true; } // Continuez à correspondre (jour vous / jour votre sœur), avec la priorité de la longévité // vous-3 sœur-4 mari-5 k = i; pour (; ++ k <longueur;) {int temp = charconvert (chs [k]); if (stopwddset.contains (temp))) continue; node = node.QuerySub (temp); if (node == null) // pas de pause; if (node.islast ()) {pourraitmark = true; }} if (pourraitmark) {return true; }} return false; } / ** * Uppercase to minuscase Full-width Conversion en demi-largeur * * @param src * @return * / private static int charconvert (char src) {int r = bcConvert.qj2bj (src); return (r> = 'a' && r <= 'z')? R + 32: R; }} dans:
IsContains: s'il faut inclure des mots sensibles
Dofilter: Filtrez des mots sensibles
2. Nœuds de mot sensibles de WordNode
Package org.andy.SensitiveWdFilter; import java.util.linkedlist; Importer java.util.list; / ** * Créé: 30 août 2016 à 15:07:45 PM * * @Author Andy * @version 2.2 * / classe publique Wordnode {private int value; // Nom de nœud Liste privée <WordNode> Subnodes; // nœud enfant privé boolean islast; // par défaut faux public wordnode (int value) {this.value = value; } public wordnode (int value, boolean islast) {this.value = value; this.islast = islast; } / ** * * @param subnode * @return est le subnode entrant * / wordnode privé addSubNode (final wordNode subNode) {if (subnodes == null) subnodes = new LinkedList <WordNode> (); subnodes.add (subNode); return subNode; } / ** * S'il y en a, renvoyez directement le nœud enfant. S'il n'y a pas, créez et ajoutez et renvoyez le nœud enfant * * @param value * @return * / public wordnode addifnoExist (Final int valum, final boolean isLast) {if (subnodes == null) {return addSubNode (new WordNode (valeur, isLast)); } pour (wordNode subNode: subnodes) {if (subNode.value == valeur) {if (! subnode.islast && isLast) subNode.islast = true; return subNode; }} return addSubNode (new WordNode (valeur, isLast)); } public wordnode queRysub (final int value) {if (subnodes == null) {return null; } pour (wordNode subNode: subnodes) {if (subNode.value == valeur) return subNode; } return null; } public boolean islast () {return islast; } public void setLast (boolean islast) {this.islast = isLast; } @Override public int hashcode () {return value; }}3. Résultats des tests
Le projet comprend le thésaurus sensible, le code source, le thésaurus en pause, etc. Il suffit d'exécuter le package Maven et Jar pour exécuter directement.
Code source du projet: sensiblewd-filter_jb51.rar
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.