1. Vorwort
Während der Entwicklung werden häufig die Einreichungen der Texte einiger Benutzer verarbeitet, sodass die Funktion der filternen sensiblen Wörter filtern. Die Implementierung des Algorithmus für DFA -Finite -Status -Maschine in Referenzmaterialien wird zum Erstellen von gerichteten Diagrammen verwendet. Die Filterung sensibler Wörter und Werbempfänger wurde abgeschlossen und die Effizienz ist gut, also teilen Sie es.
Spezifische Implementierung:
1. Match -Fallfilterung
2. Passen Sie den Filter mit voller Breite an
3. Filter -Pause -Wortfilterung.
4. Wiederholen Sie die Wortfilterung für sensible Wörter.
Zum Beispiel:
Unterstützt die folgende Erkennung von Filterung:
Scheiße
Fuck Case
Ficken Sie die halbe Breite mit voller Breite
f !!! u & c ### k pause word
ffuuuucccckkk -Wiederholungswörter
Es gibt viele Möglichkeiten, sensible Wörter zu filtern. Ich werde kurz einige Typen beschreiben, die ich jetzt verstehe:
① Die sensiblen Wörter in der Datenbank abfragen, jedes sensible Wort schleifen und dann von Anfang bis Ende im Eingabetxt suchen, um festzustellen, ob dieses sensible Wort vorhanden ist.
Um es unverblümt auszudrücken, ist diese Methode, eine zu finden, die mit dem anderen umgeht.
Vorteile: So einfach. Es ist im Grunde keine Schwierigkeit, es mit Java -Code zu implementieren.
Nachteile: Diese Effizienz bringt mich dazu, über 100.000 Grasschlammpferde in meinem Herzen zu laufen, und das Matching ist etwas schmerzhaft? Wenn es auf Englisch ist, finden Sie eine sehr sprachlose Sache wie Englisch.
A ist ein empfindliches Wort. Wenn ich ein englisches Dokument bin, wie oft muss es sensible Wörter verarbeiten? Kann mir jemand sagen?
② Der legendäre DFA -Algorithmus (schlechte Automaten) ist genau das, was ich mit Ihnen teilen möchte. Schließlich fühlt es sich allgemeiner an. Ich hoffe, jeder kann die Prinzipien des Algorithmus selbst überprüfen.
Die Informationen werden hier nicht ausführlich erläutert.
Vorteile: Zumindest ist es effizienter als der oben genannte SB.
Nachteile: Es sollte für diejenigen, die Algorithmen gelernt haben, nicht schwierig sein, aber es ist nicht schwierig, sie zu verwenden. Es ist nur ein bisschen schmerzhaft zu verstehen, die passende Effizienz ist nicht hoch und es verbraucht das Gedächtnis.
Je sensiblerer Wörter, desto mehr Gedächtnis verbraucht es.
③ Der dritte Typ wird hier ausdrücklich erklärt, dh Sie sollten selbst einen Algorithmus schreiben oder ihn basierend auf vorhandenen Algorithmen optimieren. Dies ist auch das, was Xiao Alan verfolgt.
Eines der hohen Bereiche, wenn ein unanständiger Bruder seine eigenen Ideen hat, vergessen Sie Xiao Alan nicht. Sie können den QQ: 810104041 von Xiao Alan hinzufügen, um Xiao Alan zwei Tricks zum Spielen beizubringen.
2. Code -Implementierung
Die Verzeichnisstruktur lautet wie folgt:
Im Ressourcenressourcenverzeichnis:
STOPWD.TXT: PAUSE WORD, Übereinstimmungszeit wird direkt gefiltert.
WD.TXT: Sensitive Thesaurus.
1. Wordfilter Sensitive Word Filtering Kategorie
Paket org.andy.SensitivewdFilter; Import Java.io.BufferedReader; importieren java.io.ioException; importieren java.io.inputStreamReader; Import Java.util.ArrayList; import Java.util.hashMap; import Java.util.hashset; importieren java.util.list; import Java.util.map; Java.util.set importieren; import org.andy.sensitivewdFilter.util.bcconvert; /** * Erstellungszeit: 30. August 2016 um 3:01:12 Uhr * * Idee: Erstellen Sie ein Filterset, zählt auf, ob alle Zeichen von 0 ~ 65535 am Anfang eines sensiblen Wortes beginnen * * Bestimmen Sie, ob sie bei einem sensiblen Wort beginnen | | Ist es in Ordnung, den Kopfknoten zu bekommen-das nächste Wort und dann Schritt für Schritt, DFA-Algorithmus * * @Author Andy * @Version 2.2 */ Public Class Wordfilter {private statische endgültige Filterset Set = new filterset (); // Das erste Wort private statische endgültige Karte <Integer, WordNode> NODES = New HashMap <Integer, WordNode> (1024, 1) speichern; // Speicherknoten privater statischer endgültiger Satz <Ganzzahl> stopwdset = new Hashset <> (); // pause word private static final char sign = '*'; // Sensitive Wortfilterung ersetzen static {try {long a = system.nanotime (); init (); a = System.nanotime () - a; System.out.println ("Ladezeit:" + a + "ns"); System.out.println ("Ladezeit:" + a / 1000000 + "MS"); } catch (Ausnahme e) {neue runTimeException werfen ("Initialisierungsfilter fehlgeschlagen"); }} private static void init () {// das sensible Wort addSesibalWord (leswordfromFile ("wd.txt")); addStopWord (redwordfromFile ("stopwd.txt")); } / ** * sensibles Wort hinzufügen * @param Pfad * @return * / private statische Liste <string> redwordfromFile (String -Pfad) {list <string> Wörter; BufferedReader BR = NULL; try {br = new bufferedReader (neuer InputStreamReader (WordFilter.class.getClassloader (). getResourceAsStream (Pfad))); Words = New ArrayList <String> (1200); für (String buf = ""; (buf = br.readline ())! Words.Add (buf); }} catch (Ausnahme E) {neue runTimeException (e) werfen; } endlich {try {if (br! = null) br.close (); } catch (ioException e) {}} Rückgabewörter; } / ** * PAUSE Word hinzufügen * * @param Wörter * / private statische void addStopword (endgültige Liste <string> Wörter) {if (Words! = Null && words.size ()> 0) {char [] chs; für (String curr: wörter) {chs = curr.toCharArray (); für (char c: chs) {stopwdset.add (charconvert (c)); }}}}} / *** fügen Sie den DFA -Knoten hinzu* @param Wörter* / private statische void addSensitiveWord (endgültige Liste <string> Wörter) {if (Words! = Null && words.size ()> 0) {char [] chs; int fchar; int lastIndex; WordNode fnode; // Erster Buchstabenknoten für (String Curr: Wörter) {chs = curr.toCharArray (); fchar = charconvert (CHS [0]); if (! set.contains (fchar)) {// keine anfängliche Definition set.add (fchar); // Das erste Flag kann wiederholt werden. Wie auch immer, es wird beurteilt, so dass es nicht wiederholt wird, fnode = new WordNode (fchar, chs.Length == 1); Knoten.put (fchar, fnode); } else {fnode = nodes.get (fchar); if (! fnode.islast () && chs.length == 1) fnode.setLast (true); } lastIndex = chs.length - 1; für (int i = 1; i <chs.length; i ++) {fnode = fnode.addifnoexist (charconvert (chs [i]), i == lastIndex); }}}} / ** * FILTERING AURTHALT Umwandeln sensible Wörter in maskierte Wörter * @param src * @return * / public static Final String dofilter (endgültige String src) {char [] chs = src.toarArray (); int länge = chs.length; int Currc; int k; WordNode -Knoten; für (int i = 0; i <länge; i ++) {currc = charconvert (chs [i]); if (! set.contains (currc)) {Fortsetzung; } node = nodes.get (currc); // Tag 2 if (node == null) // Eigentlich wird es nicht geschehen, Sie werden es gewohnt, es auf die Kontinuität zu schreiben. boolean könnte markieren = falsch; int marknum = -1; if (node.islast ()) {// einzelne Wort Matching (Tag) mark = true; Marknum = 0; } // Passen Sie weiter (Tag/Tag) mit einer langfristigen Priorität // You-3 Sister-4 Ehemann-5 k = i; für (; ++ k <Länge;) {int temp = charconvert (chs [k]); if (stopwdset.contains (temp))) fortsetzen; node = node.querysub (temp); if (node == null) // keine Pause; if (node.islast ()) {könnte mark = true; marknum = k - i; // 3-2}} if (cutmark) {für (k = 0; k <= marknum; k ++) {chs [k+i] = sign; } i = i + marknum; }} return New String (CHS); } / ** * Enthält sensible Wörter * @param src * @return * / public static Final Boolean iscontains (endgültige String src) {char [] chs = src.toCharArray (); int länge = chs.length; int Currc; int k; WordNode -Knoten; für (int i = 0; i <länge; i ++) {currc = charconvert (chs [i]); if (! set.contains (currc)) {Fortsetzung; } node = nodes.get (currc); // Tag 2 if (node == null) // Es passiert nicht, es ist gewohnheitsmäßig geschrieben, um weiterzumachen; boolean könnte markieren = falsch; if (node.islast ()) {// einzelne Wort Matching (Tag) mark = true; } // Passen Sie weiter (Tag Sie/Tag, Ihre Schwester), mit der Priorität der Langlebigkeit // You-3 Schwester-4 Hemd-5 k = i; für (; ++ k <Länge;) {int temp = charconvert (chs [k]); if (stopwdset.contains (temp))) fortsetzen; node = node.querysub (temp); if (node == null) // keine Pause; if (node.islast ()) {könnte mark = true; }} if (könnte mark) {return true; }} return false; } / ** * Großbuchstaben in die Umwandlung der Kleinbreite in der Fall-Breite in eine halbe Breite * * @param src * @return * / private static int charconvert (char src) {int r = bcconvert.qj2bj (SRC); return (r> = 'a' && r <= 'z')? R + 32: R; }} In:
Iscontains: Ob sensible Wörter einbeziehen sollen
DOFILTER: filtern sensible Wörter
2. Wordnode empfindliche Wortknoten
Paket org.andy.SensitivewdFilter; import Java.util.linkedList; importieren java.util.list; / ** * Erstellt: 30. August 2016 um 3:07:45 Uhr * * @Author Andy * @Version 2.2 */ public Class WordNode {private int value; // Knotenname private Liste <Wordnode> Subnodes; // Child Node Private boolean islast; // Standard falsches öffentliches WordNode (int value) {this.Value = value; } public WordNode (int value, boolean islast) {this.Value = value; this.islast = islast; } / ** * * @param subnode * @return ist der eingehende Subnode * / private WordNode addSubnode (endgültiger WordNode subnode) {if (subnodes == null) subnode = new LinkedList <Wordnode> (); subnodes.add (subnode); Subnode zurückgeben; } /*** Wenn es vorhanden ist, geben Sie den untergeordneten Knoten direkt zurück. Wenn es nein gibt, erstellen und hinzufügen und geben Sie den untergeordneten Knoten * * @param value * @return */ public WordNode addifnoExist (endgültiger intwert, endgültig boolean islast) {if (subnodes == null) {return addSubnode (neuer Wordnode (Wert, Islast)); } für (WordNode subnode: subnodes) {if (subnode.value == value) {if (! subnode.islast && islast) subnode.islast = true; Subnode zurückgeben; }} return addSubnode (neuer WordNode (Wert, ISLAST)); } public WordNode querysub (endgültiger intwert) {if (subnodes == null) {return null; } für (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 () {return value; }}3. Testergebnisse
Das Projekt umfasst sensible Thesaurus, Quellcode, Pause Thesaurus usw. Führen Sie einfach das Paket Maven und JAR aus, um sie direkt auszuführen.
Projektquellcode: SensitiveWD-filter_jb51.rar
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.