大きな文字列に部分文字列が存在することをJavaで直接チェックできますか

Question

Ex。 .comはamazon.comに存在します それは逆の順序で仕事を含んでいます それは "amazon.com"を確認します.contains（ "。com） しかし、私は .COMがamazon.comに含まれているかどうかを確認する必要があります 私はそれがします真の最後の文字列が一致し

Answer 1

使用して、正規表現

をチェックする（.COM、.ORG、等）のような値のリストを持っているよう。

String str = "amazon.com"; 
    System.out.println(str.matches(".*(com|org|in)")); 

Answer 2

私は思いますあなたはうんざりするそして、あなたがcharをご入力文字列内のすべての文字をループして見つけることができます

convert 
[".com", ".org"] 
to 
[ 
    '.': [ 
     'c': [ 
      'o': [ 
       'm': [] 
      ] 
     ], 
     'o': [ 
      'r': [ 
       'g': [] 
      ] 
     ] 
    ] 
] 

：それを行うには

private boolean checkUrl(String url, List<String> suffixes) { 
    boolean isValid = false; 
    //Loop through all the correct suffixes 
    for(String suffix : suffixes) { 
     //If the suffix exists then we can set the variable to true and break the loop so we can return true. 
     if(url.endsWith(suffix)) { 
      isValid = true; 
      break; 
     } 
    } 

    return isValid; 
} 

Answer 3

一つの方法は、このような何かにあなたの検索アルゴリズムを分割することです。このようなトン何かその個々のチャーの木。 その後、木の端まで歩いていくことができます。ある時点で空の地図が見つかると、一致するものが見つかりました。まったく地図が見つからない場合は、それは一致しません。

このクラスは、検索ツリーをコンパイルし、いくつかの入力

public class CharSearch 
{ 
    private final Map<Character, CharSet> charSets; 

    public CharSearch(String[] values) 
    { 
     charSets = new HashMap<>(); 
     for (String value : values) 
      addValue(value); 
    } 

    public void addValue(String value) 
    { 
     addValue(value.toCharArray(), 0); 
    } 

    public void addValue(char[] value, int index) 
    { 
     if (value == null || value.length == 0) 
      return; 

     CharSet charSet = charSets.computeIfAbsent(value[index], k -> new CharSet()); 
     charSet.addValue(value, index +1); 
    } 

    public String toString() 
    { 
     return getClass().getName() + charSets.toString(); 
    } 

    public int match(String input) 
    { 
     char[] characters = input.toCharArray(); 
     for (int i = 0; i < characters.length; i++) 
     { 
      CharSet charSet = charSets.get(characters[i]); 
      if (charSet != null) 
      { 
       if (charSet.match(characters, i) >= 0) 
        return i; 
       else 
        break; 
      } 
     } 
     return -1; 
    } 
} 

class CharSet 
{ 
    final Map<Character, CharSet> nextChars; 
    boolean isLocked = false; 

    CharSet() 
    { 
     this.nextChars = new HashMap<>(); 
    } 

    public String toString() 
    { 
     return nextChars.toString(); 
    } 

    void addValue(char[] value, int index) 
    { 
     if (isLocked) 
      return; 
     if (value.length <= index) 
     { 
      isLocked = true; 
      nextChars.clear(); 
      return; 
     } 

     CharSet charSet = nextChars.computeIfAbsent(value[index], k -> new CharSet()); 
     charSet.addValue(value, index +1); 
    } 

    int match(char[] input, int index) 
    { 
     if (nextChars.isEmpty()) 
      return index; 

     index++; 
     if (input.length <= index) 
      return -1; 

     CharSet charSet = nextChars.get(input[index]); 
     if (charSet != null) 
     { 
      return (charSet.match(input, index)); 
     } 
     return -1; 
    } 
} 

と一致するメソッドを持っていますこれは、あなたがコンパイル「または」と「ORG」ならば、組織は単純に無視されることを前提としています。 ".blablabla1"と ".blablabla2"をコンパイルすると、 ".blablabla"は1回のみチェックされます。 なぜなら、なぜなら、matchメソッドは最初に見つかった一致のインデックスを返します。

String[] values = {".com", ".org",}; 
CharSearch charSearch = new CharSearch(values); 
System.out.println(charSearch.match("amazon.com")); 
System.out.println(charSearch.match("amazon.cooo")); 

"6"と "-1"が表示されます。

私は（この場合は2）をチェックするための非常に少ない値で、これは実際にこのような単純な何かを行うよりも遅くなることを想定しています

public static boolean hasAny(String text, String[] values) 
{ 
    for (String value : values) 
    { 
     if (text.contains(value)) 
      return true; 
    } 
    return false; 
} 

しかし、あなたはチェック以上の値、より多くのSearchCharのアプローチが効率的になり、hasAny（）アプローチの効率が低下します。 （になってきて、より効率的なdoesntのは、ランタイムが下がることを意味していることに注意してください。）

あなたが一緒に一つだけの子供とのマッピングを設定することにより、このアルゴリズムを最適化することができます。

[ 
    '.': [ 
     'com': [], 
     'org': [] 
    ] 
] 

またはのための長さのチェックを追加することにより、文字列の残りの長さに比べて、各ツリーの最小限の長さ（char型[]）あなたは

を評価するか、いくつかの高知能の予測で複数の文字をスキップしている...

をしかし、これはすべき）

EDIT： すべての入力（たとえば、）がドットで始まるときに効率が上がります。 簡単なチェックでは、入力の文字数をn、一致の開始文字を見つけるためにチェックする値の数をnとしたとき、O（n * t）になります。

CharSearchでは、一致の開始文字を見つけるのにO（n）が必要です。 O（n *（1〜L））の最終的な複雑さでは、Lはあなたが入れた値の最大長です。これは誤解しない限りString.contains（）と同じ複雑さです。

（その大きなO記法はしかし、右の表記ではないかもしれないが、私はそれを理解する人々のためにかなり明確であるべきだと思います。）