【问题标题】:如何知道给定字符串是否是Java中另一个字符串的子字符串(How to know if a given string is substring from another string in Java)
【发布时间】:2011-06-15 20:02:13
【问题描述】:

嗨 我必须计算给定字符串是否是更大字符串的子字符串。 例如

String str = "Hallo my world";
String substr = "my"

“包含”方法应返回 true,因为 str 包含 substr(否则为 false)。

我在 String 类中寻找类似“包含”的东西 但我没有找到。我想唯一的解决方案是使用 模式匹配。如果是这种情况,那将是更好(最便宜)的方式 这样做?

谢谢!

【问题讨论】:

  • str.indexOf(substr) != -1 就是答案。
  • 好吧,这么多正确的答案在更短的时间内一起出现。非常感谢大家。你为我节省了很多时间。我正在使用 java 1.5 并且我正在查看 java 1.4.2 的文档,因此我没有意识到存在“包含”方法。子索引方法也可以。为大家 +1。
  • @biziclop 万一你错过了,你需要在下面的答案部分发布答案。
  • @dogbane 我可以,但我不必这样做。 :)

标签: java string pattern-matching substring


【解决方案1】:
 String str="hello world";
        System.out.println(str.contains("world"));//true
        System.out.println(str.contains("world1"));//false

【问题讨论】:

    【解决方案2】:

    如果不匹配,使用 indexOf 将返回 -1(包含在 1.5 中添加,也许您使用的是旧版 jdk?)请参阅 "contains(CharSequence s)" method in String class in JDK 1.4.2 了解详情

    【问题讨论】:

      【解决方案3】:

      一个contains() 方法!它是在 Java 1.5 中引入的。如果您使用的是早期版本,那么很容易将其替换为:

      str.indexOf(substr) != -1
      

      【问题讨论】:

        【解决方案4】:
        if (str.indexOf(substr) >= 0) {
            // do something
        }
        

        【问题讨论】:

        • 将在str="foobar"substr="foo" 上失败,因为indexOf() 将返回0
        【解决方案5】:

        我认为有一个 String 函数可以满足您的要求:String.indexOf(String)。

        查看此链接:http://download.oracle.com/javase/1.4.2/docs/api/java/lang/String.html#indexOf(java.lang.String)

        那么,你可以编写这个函数:

        public boolean isSubstring(String super, String sub) {
            return super.indexOf(sub) >= 0;
        }
        

        【问题讨论】:

          【解决方案6】:

          String.indexOf(substr) 复杂度为 O(n2).. Luixv 提出了一个更便宜的解决方案.. 但就目前而言,我知道没有比当前更好的算法了。

          【问题讨论】:

            【解决方案7】:
                public boolean isSubString(String smallStr, String largerStr) {
                char[] larger = largerStr.toCharArray();
                char[] smaller = smallStr.toCharArray();
            
                int i = 0;
            
                for (int j = 0; j < larger.length; j++) {
                    if(larger[j] == smaller[i]){
                        if(i == smaller.length -1){
                            //done we found that this string is substring
                            return true;
                        }
                        i++;
                        continue;
                    }else{
                        if(i > 0){
                            //that means we encountered a duplicate character before and if string was substring 
                            // it shouldn't have hit this condition..
                            if(larger.length - j >= smaller.length){
                                i = 0;
                                //reset i here because there are still more characters to check for substring..
                            }else{
                                //we don't have enough characters to check for substring.. so done..
                                return false;
                            }
            
                        }
                    }
            
                }
            
                return false;
            }
            

            【问题讨论】:

              【解决方案8】:
                String s = "AJAYkumarReddy";
                  String sub = "kumar";
                  int count = 0;
                  for (int i = 0; i < s.length(); i++) {
                      if (s.charAt(i) == sub.charAt(count)) {
                          count++;
                      } else {
                          count = 0;
                      }
                      if (count == sub.length()) {
                          System.out.println("Sub String");
                          return;
                      }
              
                  }
              

              【问题讨论】:

              • 您的算法不是最优的。不要重新发明轮子。查看接受的答案。
              • 不正确... String s = "aabcxbx"; 将失败String sub = "abc";
              【解决方案9】:

              这是一个通用的方法,你可以使用

              public static boolean isSubstring(String s1, String s2) {
                  if(s1.length() == s2.length()) 
                      return s1.equals(s2);
                  else if(s1.length() > s2.length())
                      return s1.contains(s2);
                  else
                      return s2.contains(s1);
              
              }
              

              【问题讨论】:

              • 您的算法不是最优的。不要重新发明轮子。查看接受的答案。
              【解决方案10】:
              public static boolean isSubstring(String s1, String s2){
                  if(s1.length()<s2.length()) return false;
                  if(s1.length()==s2.length()) return s1.equals(s2);
                  for(int i=0;i<=s1.length()-s2.length();i++){
                      if(s1.charAt(i)==s2.charAt(0)){
                          int matchLength=1;
                          for(int j=1;j<s2.length();j++){
                              if(s1.charAt(i+j)!=s2.charAt(j)){
                                  break;
                              }
                              matchLength++;
                          }
                          if(matchLength==s2.length()) return true;
                      }
                  }
                  return false;
              }
              

              这会检查 s2 是否是 s1 的子字符串。

              【问题讨论】:

              • 您的算法不是最优的。不要重新发明轮子。查看接受的答案
              【解决方案11】:

              您可以使用 .substring(int beginIndex,int lastIndex) 来检查这个程序。示例代码如下:-

              public class Test {
              
                  public static void main(final String[] args) {
                      System.out.println("Enter the first String");
                      BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
              
                      try {
                          String s1 = br.readLine();
                          System.out.println("Enter the second String");
                          String s2 = br.readLine();
              
                          boolean result = isSubStr(s1, s2);
                          if (result == true)
                              System.out.println("The second String is substring of the first String");
                          else
                              System.out.println("The second String is not a substring of the first String");
              
                      } catch (IOException e) {
                          System.out.println("Exception Caught: " + e);
                      }
              
                  }
              
                  public static boolean isSubStr(String st1, String s2) {
              
                      boolean result = false;
              
                      String tem_str = "";
                      int len1 = st1.length();
                      int i = 0;
                      int j;
              
                      while (i < len1) {
                          j = i+1;
                          while (j <=len1) {
                              tem_str = st1.substring(i, j);
                              if (tem_str.equalsIgnoreCase(s2)) {
                                  result = true;
                                  break;
                              }
                             j++;
                          }
              
                          i++;
                      }
                      return result;
                  }
              }
              

              【问题讨论】:

                【解决方案12】:

                通过这个方法。 visit for tricky code

                public static boolean isSubString(String s, String sub) {
                    int count = 0;
                    for (int i = 0; i < s.length(); i++) {
                        if (s.charAt(i) == sub.charAt(count)) {
                            count++;
                        } else {
                            i-=count;
                            count = 0;
                        }
                        if (count == sub.length()) {
                            return true;
                        }
                
                    }
                    return false;
                }
                

                【问题讨论】:

                • 欢迎来到 Stack Overflow!请不要添加必要的链接以添加到解释中,否则它们会被社区视为垃圾邮件,您的答案可能会被删除。
                • 但是您建议的解决方案效率相对较低且非常有效。你应该看看 KMP 算法,它效率更高,几乎无处不在。
                【解决方案13】:

                考虑以下代码:

                如果存在子字符串,则返回给定字符串中子字符串的起始索引

                否则返回-1

                public static int isSubstring(String str, String pattern)
                {
                    int str_length = str.length();
                    int pattern_length = pattern.length();
                
                    for (int i = 0; i <= str_length - pattern_length; i++)
                    {
                        int j;
                
                        for (j = 0; j < pattern_length; j++)
                            if (str.charAt(i + j) != pattern.charAt(j))
                                break;
                
                        if (j == pattern_length)
                            return i;
                    }
                    return -1;
                }
                

                【问题讨论】:

                  【解决方案14】:
                      String str1 = "Java8 makes Java more powerful";
                      String str2 = "Java";
                      char c;
                      char d;
                      int count=0;
                      boolean match = true;
                      for (int i = 0; i < str1.length(); i++) {
                          c = str1.charAt(i);
                          for (int j = 0; j < str2.length(); j++) {
                              d = str2.charAt(j);
                              if (c == d) {
                                  match = true;
                                  count++;
                                  if(count== str2.length()){
                                      i = str1.length();
                                      break;
                                  }
                                  i++;
                                  c = str1.charAt(i);
                              } else {
                                  match = false;
                              }   
                          }
                      }
                  
                      if(match == true){
                          System.out.println("SubString ");
                      }
                  

                  【问题讨论】:

                    【解决方案15】:
                    public class StringIsSubString {
                    
                        public static void main(String[] args) {
                    
                            String s1 = "wel";
                            String s2 = "12wlecome123";
                    
                            boolean isSubStr = isSubStr(s1,s2);
                            System.out.println(isSubStr);
                        }
                    
                        private static boolean isSubStr(String s1, String s2) {
                            String s3 = "";
                            int j = 0;
                    
                            if(s1.length() > s2.length()) {
                                return false;
                            } else if(s1.equals(s2)){
                                return true;
                            } else {
                                for(int i=0; i<s1.length();i++) {
                                    for(; j<s2.length();j++) {
                                        if(s1.charAt(i) == s2.charAt(j)) {
                                            s3 = s3 + s1.charAt(i);
                                            break;
                                        }
                                    }
                                }
                                if(s3.equals(s1)) {
                                    return true;
                                }
                                return false;       
                            }
                        }
                    }
                    

                    【问题讨论】:

                    • 发布代码时,在开始前和结束后用三个`包裹代码。
                    【解决方案16】:

                    *在他们的任何子串中,都会以子串的第1位的形式计算*

                    int isSubstring(string s1, string s2) {
                        int M = s1.length();
                        int N = s2.length();
                    
                        for (int i = 0; i <= N - M; i++) {
                            int j;
                            for (j = 0; j < M; j++)
                                if (s2[i + j] != s1[j])
                                    break;
                    
                            if (j == M)
                                return i;
                        }
                    
                        return -1;
                    }
                    
                    
                    int main() {
                        string s1 = "kumar";
                        string s2 = "abhimanyukumarroy";
                        int res = isSubstring(s1, s2);
                        if (res == -1)
                            cout << "Not present";
                        else
                            cout << "Present at index " << res;
                        return 0;
                    }
                    

                    【问题讨论】: