Tage String og fjerne besteme ord fra den

PS: Ideen var at man kunne have en let-udbyggelig samling af ord som skulle fjernes... :o)

String res = textIn.replace("fuck","*blip*").replace("sgu","*blib*");

måske ?

Eller måske:

String res = textIn;
for(int i = 0; i < bandeord.length; i++) {
    res = res.replace(bandeord[i],"*blip*");
}

Hej arne - glædeligt gensyn. Findes der en sådan metode i String!?

Ja. Siden Java 1.4 !

jeg er bange for mit jsp-hotel på www.levonline.com bruger version 1.3.1

kæft hvor det bittert...

Hov jeg checkede lige.

Den hedder ikke replace men replaceALl.

Altså:

String res = textIn;
for(int i = 0; i < bandeord.length; i++) {
    res = res.replaceAll(bandeord[i],"*blip*");
}

Jeg har masser af replaceAll funktioner på lager !!!!

har du!? Virkelig!? - nogen jeg kan bruge under 1.3.1!?

*stikker hovedet ind i arne v's lager*

public static String replaceAll(String s, String s1, String s2) {
      StringBuffer tmp = new StringBuffer("");
      int pos = 0;
      while (pos < s.length()) {
        int ix = s.indexOf(s1, pos);
        if (ix >= 0) {
            tmp.append(s.substring(pos, ix));
            tmp.append(s2);
            pos = ix + s1.length();
        } else {
            tmp.append(s.substring(pos));
            pos = s.length();
        }
      }
      return tmp.toString();
  }

public static String replaceAll(String s, String s1, String s2) {
      int ix = s.indexOf(s1);
      if (ix >= 0) {
        return (s.substring(0, ix) + s2 + replaceAll(s.substring(ix + s1.length()), s1, s2));
      } else {
        return s;
      }
  }

De virker på en hvilken som helst Java version.

Syntaxen er naturligvis lidt anderledes:

String res = textIn;
for(int i = 0; i < bandeord.length; i++) {
    res = replaceAll(res,bandeord[i],"*blip*");
}

What? Den fatter jeg ikke helt... s er teksten - s1 og s2?

De virker alle? hvilken er mest kørselseffektiv?

Fordi det ikke er en metode i String er det ikke s.replaceAll(fnd,rpl)
men replaceAll(s,fnd,rpl) ...

Test selv:

public class ReplaceTest {
  private final static int N = 10000;
  public static void main(String[] args) {
      test(new ReplaceRecursiveString());
      test(new ReplaceSmartRecursiveString());
      test(new ReplaceRecursiveStringBuffer());
      test(new ReplaceRecursiveGlobalStringBuffer());
      test(new ReplaceLoopString());
      test(new ReplaceLoopStringBuffer());
      return;
  }
  private static void test(Replacer r) {
      verify(r);
      perf(r);
      return;
  }
  private static void verify(Replacer r) {
      if (!r.replaceAll("123<P>456<P>789", "<P>", "\n").equals("123\n456\n789")
        || !r.replaceAll("<P>123<P>456<P>789<P>", "<P>", "\n").equals("\n123\n456\n789\n")
        || !r.replaceAll("123<P><P>456", "<P>", "\n").equals("123\n\n456")
        || !r.replaceAll("<P>", "<P>", "\n").equals("\n")
        || !r.replaceAll("", "<P>", "\n").equals("")) {
        System.out.println(r.getMethod() + " failed");
      }
      return;
  }
  private static void perf(Replacer r) {
      System.out.println(r.getMethod() + ":");
      perf("short text - few replaces", r, 1000, 5);
      perf("short text - many replaces", r, 1000, 25);
      perf("long text - few replaces", r, 10000, 5);
      perf("long text - many replaces", r, 10000, 25);
      return;
  }
  private static void perf(String title, Replacer r, int txtlen, int nrepl) {
      StringBuffer sb = new StringBuffer("");
      for (int i = 0; i < txtlen; i++) {
        sb.append('A');
        if ((i % (txtlen / nrepl)) == 0) {
            sb.append("<P>");
        }
      }
      perf(title, r, sb.toString());
      return;
  }
  private static void perf(String title, Replacer r, String s) {
      long t1 = System.currentTimeMillis();
      for (int i = 0; i < N; i++) {
        r.replaceAll(s, "<P>", "\n");
      }
      long t2 = System.currentTimeMillis();
      System.out.println(title + " = " + (t2 - t1));
      return;
  }
}
interface Replacer {
  public String getMethod();
  public String replaceAll(String s, String s1, String s2);
}
class ReplaceRecursiveString implements Replacer {
  public String getMethod() {
      return "Recursive with String";
  }
  public String replaceAll(String s, String s1, String s2) {
      int ix = s.indexOf(s1);
      if (ix >= 0) {
        return replaceAll(s.substring(0, ix) + s2 + s.substring(ix + s1.length()), s1, s2);
      } else {
        return s;
      }
  }
}
class ReplaceSmartRecursiveString implements Replacer {
  public String getMethod() {
      return "Smart recursive with String";
  }
  public String replaceAll(String s, String s1, String s2) {
      int ix = s.indexOf(s1);
      if (ix >= 0) {
        return (s.substring(0, ix) + s2 + replaceAll(s.substring(ix + s1.length()), s1, s2));
      } else {
        return s;
      }
  }
}
class ReplaceRecursiveStringBuffer implements Replacer {
  public String getMethod() {
      return "Recursive with StringBuffer";
  }
  public String replaceAll(String s, String s1, String s2) {
      int ix = s.indexOf(s1);
      if (ix >= 0) {
        StringBuffer tmp = new StringBuffer("");
        tmp.append(s.substring(0, ix));
        tmp.append(s2);
        tmp.append(s.substring(ix + s1.length()));
        return replaceAll(tmp.toString(), s1, s2);
      } else {
        return s;
      }
  }
}
class ReplaceRecursiveGlobalStringBuffer implements Replacer {
  public String getMethod() {
      return "Recursive with global StringBuffer";
  }
  public String replaceAll(String s, String s1, String s2) {
      StringBuffer tmp = new StringBuffer("");
      replaceAllHelp(tmp, s, s1, s2);
      return tmp.toString();
  }
  private void replaceAllHelp(StringBuffer res, String s, String s1, String s2) {
      int ix = s.indexOf(s1);
      if (ix >= 0) {
        res.append(s.substring(0, ix));
        res.append(s2);
        replaceAllHelp(res, s.substring(ix + s1.length()), s1, s2);
      } else {
        res.append(s);
      }
      return;
  }
}
class ReplaceLoopString implements Replacer {
  public String getMethod() {
      return "Loop with String";
  }
  public String replaceAll(String s, String s1, String s2) {
      String tmp = new String("");
      int pos = 0;
      while (pos < s.length()) {
        int ix = s.indexOf(s1, pos);
        if (ix >= 0) {
            tmp = tmp + s.substring(pos, ix) + s2;
            pos = ix + s1.length();
        } else {
            tmp = tmp + s.substring(pos);
            pos = s.length();
        }
      }
      return tmp;
  }
}
class ReplaceLoopStringBuffer implements Replacer {
  public String getMethod() {
      return "Loop with StringBuffer";
  }
  public String replaceAll(String s, String s1, String s2) {
      StringBuffer tmp = new StringBuffer("");
      int pos = 0;
      while (pos < s.length()) {
        int ix = s.indexOf(s1, pos);
        if (ix >= 0) {
            tmp.append(s.substring(pos, ix));
            tmp.append(s2);
            pos = ix + s1.length();
        } else {
            tmp.append(s.substring(pos));
            pos = s.length();
        }
      }
      return tmp.toString();
  }
}

Havde du også testklassen liggende eller smed du den lige sammen!?

Hvis man har en nyere Java:

import java.util.regex.*;
import java.util.*;

public class badwords {

  public static void main(String[] a) {

    String str = "der var engang en hund og en kat der dystede i en kategori";

    Pattern p = Pattern.compile("\\b(hund|kat)\\b");
    Matcher m = p.matcher(str);
    String res = m.replaceAll("*biip*");

    System.out.println(res);

  }

}

Nej - jeg havde test klasen liggende (den var "lageret"). Og så klippede
jeg de 2 varianter ud af den.

Ser ud til at Smart recursive with String er hurtigst - er du enig?

tror du et jsp-hotel kan have problemer med rekursivitet?

Nej.

Det er helt normal kode.

nåeh ja - jeg tænkte på RAM-implikationerne ifht. alm. iteration.

Prøver lige at teste en bean med metoden

public static String replaceAll(String s, String s1, String s2) {
      int ix = s.indexOf(s1);
      if (ix >= 0) {
        return (s.substring(0, ix) + s2 + replaceAll(s.substring(ix + s1.length()), s1, s2));
      } else {
        return s;
      }
  }

Husk at skrive et slags svar så du kan få point...

den behøver ikke være static vel?

Nej den behøver ikke være static - den kan bare være det.

svar

Hos mig er:
  Recursive with global StringBuffer
  Loop with StringBuffer
de 2 hurtigste.

s er texten - s1 er det forbudte ord og s2 er det ord det skal etstattes med - er det rigtigt?

En rekursion per bandeord kan vel ikke løbe helt løbsk.

Ja.

På "små" data er forskellen iøvrigt meget lille.

Hvad siger du til:

public class TextCleaner {
 
 
  /**
    * Denne metode modtager en String og fjerner ord der findes i String-Vector
    */
  public String cleanOut(String textIn Vector badWords) {
      int counter = 0;
      int vectorSize = badWords.size();
      String tempString = textIn
      String badWord = null;
      while(counter < vectorSize) {
        badWord = badWords.indexAt(counter);
        tempString = replaceAll(tempIn, badWord, "*bliip*");
      }
      return tempString;
  }
   
   
  public String replaceAll(String s, String s1, String s2) {
      StringBuffer tmp = new StringBuffer("");
      int pos = 0;
      while (pos < s.length()) {
        int ix = s.indexOf(s1, pos);
        if (ix >= 0) {
            tmp.append(s.substring(pos, ix));
            tmp.append(s2);
            pos = ix + s1.length();
        } else {
            tmp.append(s.substring(pos));
            pos = s.length();
        }
      }
      return tmp.toString();
  }

}

Ser det ikke meget fornuftigt ud :o)

*retter til*

remote-compiled nu skal jeg bare lige lave en lille test-side :o}

*arbejder*

Det ser OK ud.

Jeg ville nok have brugte andre variabel navne, for løkke i.s.f.
while løkke etc. m.v. men det er jo kun et spørgsmål om kode stil.

Du har rettet så du tæller counter op ikke ?

haha - jo NU har jeg :o) Det er en klassiker...

Det fungerer P-E-R-F-E-K-T Det vidste jeg det ville komme til så snart jeg så du deltog i spørgsmålet - hvordan gør jeg hvis jeg gerne vil give flere point end lovet fra starten? Ved at se på historikken er det tydeligt at se at 20 point er for lidt...

http://www.ebruger.dk/faq/#flere_point_end_lovet

ah - nu ved jeg det.. :o)

Tak for hjælpen!

-ERK
www.erk.dk

Hvordan skal metoden:

public String replaceAll(String s, String s1, String s2) {
      StringBuffer tmp = new StringBuffer("");
      int pos = 0;
      while (pos < s.length()) {
        int ix = s.indexOf(s1, pos);
        if (ix >= 0) {
            tmp.append(s.substring(pos, ix));
            tmp.append(s2);
            pos = ix + s1.length();
        } else {
            tmp.append(s.substring(pos));
            pos = s.length();
        }
      }
      return tmp.toString();
  }

se ud hvis den skal ignorere store/små bogstaver? ellers er det LIDT for mange ord at sætte ind :o)

I mit eksemspel fra i går skal du bare skrive

Pattern p = Pattern.compile("\\b(hund|kat)\\b",CASE_INSENSITIVE);

eller evt.

Pattern p = Pattern.compile("\\b(hund|kat)\\b",2);

int ix = s.toUpperCase().indexOf(s1.toUpperCase(), pos);

bør gøre replaceAll case insensitiv !

perfekt arne v :o) se på http://www.erk.dk/vis_gaestebog.jsp *lol* By the way - skal du ikke have nogle point i det andet spørgsmål hvor erikjacobsen også deltog??