精华内容
下载资源
问答
  • 使用递归实现字符串模糊匹配,看设置允许匹配错误数。
  • Java实现字符串组合的模糊匹配

    万次阅读 2019-03-10 11:27:58
    Java实现字符串组合的模糊匹配背景实现方式后续优化 背景 接到这么一个需求:根据用户输入内容(以下简称S)对一系列的字符串组合(每个字符串组合以下简称Z)进行模糊匹配,返回匹配的字符串组合(以下简称R)。 举...

    Java实现字符串组合的模糊匹配

    背景

    接到这么一个需求:根据用户输入内容(以下简称S)对一系列的字符串组合(每个字符串组合以下简称Z)进行模糊匹配,返回匹配的字符串组合(以下简称R)。
    举个例子,有如下一系列的Z:(ab),(ab,cd),(ab,cd,ef)
    当S为a时,R为(ab),(ab,cd),(ab,cd,ef)
    当S为a,c时,R为(ab,cd),(ab,cd,ef)

    实现方式

    如果要做精确匹配,实际上就是判断S是不是Z的子集,可以直接考虑调用List.containsAll实现。
    模糊匹配,实际上是对S中的每个字符串s,判断Z中是否有一个字符串z包含它,即z.contains(s)。

    核心代码如下:

    import java.util.*;
    
    public class FuzzyContainsTest {
        public static void main(String []args) {
            List<String> list = Arrays.asList("ab,cd".split(","));
    		List<String> query = Arrays.asList("a,c".split(","));
    		System.out.println(fuzzyContainsAll(list, query));
        }
    	
    	// 判断S是不是Z的子集
    	public static boolean fuzzyContainsAll(List<String> list, List<String> query) {
    		boolean flag = true;
    		for(String str : query) {
    			flag = flag && fuzzyContains(list, str);
    		}
    		return flag;
    	}
    	
    	// 对S中的每个字符串s,判断Z中是否有一个字符串z包含它
    	public static boolean fuzzyContains(List<String> list, String s) {
    		boolean flag = false;
    		for(String z : list) {
    			flag = flag || z.contains(s);
    		}
    		return flag;
    	}
    }
    

    后续优化

    这段代码的时间复杂度是O(n^3),应该有优化的空间,或者有更高效的实现方式,后续想到了再补充。

    展开全文
  • Java字符串中查找匹配的子字符串

    万次阅读 多人点赞 2017-05-07 15:25:25
    Java字符串中查找匹配的子字符串

    示例:
           在源字符串“You may be out of my sight, but never out of my mind.”中查找“my”的个数。输出:匹配个数为2

    三种方法:
           1.通过String的indexOf方法
           2. 通过正则表达式
           3. 通过String的split方法
    其中第一种方法只能用于精确匹配,第二三种则可以模糊匹配(方法3的参数为正则表达式)。例如:若将child改为“.my.”,第一种方法失效。

    方法1:通过String的indexOf方法

    public int indexOf(int ch, int fromIndex) :返回在此字符串中第一次出现指定字符处的索引,从指定的索引开始搜索。如果不存在则返回 -1。

    //方法1、通过String的indexOf(String str, int fromIndex)方法
    	private void matchStringByIndexOf( String parent,String child )
    	{
    		int count = 0;
    		int index = 0;
    		while( ( index = parent.indexOf(child, index) ) != -1 )
    		{
    			index = index+child.length();
    			count++;
    		}
    		System.out.println( "匹配个数为"+count );							  //结果输出
    	}
    

    方法2:通过正则表达式

    类 Pattern :正则表达式的编译表示形式。
           指定为字符串的正则表达式必须首先被编译为此类的实例。然后,可将得到的模式用于创建 Matcher 对象,依照正则表达式,该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中,所以多个匹配器可以共享同一模式。
           因此,典型的调用顺序是
           Pattern p = Pattern.compile(“a*b”);
           Matcher m = p.matcher(“aaaaab”);
           boolean b = m.matches();

    • 类 Matcher:通过调用模式的 matcher 方法从模式创建匹配器。创建匹配器后,可以使用它执行三种不同的匹配操作:
             matches 方法尝试将整个输入序列与该模式匹配。
             lookingAt 尝试将输入序列从头开始与该模式匹配。
             find 方法扫描输入序列以查找与该模式匹配的下一个子序列
    //方法2、通过正则表达式
    	private void matchStringByRegularExpression( String parent,String child )
    	{
    		
    		int count = 0;
    		Pattern p = Pattern.compile( child );
    		Matcher m = p.matcher(parent);
    		while( m.find() )
    		{
    			count++;
    			System.out.println( "匹配项" + count+":" + m.group() ); //group方法返回由以前匹配操作所匹配的输入子序列。
    		}
    		System.out.println( "匹配个数为"+count );							  //结果输出
    	}
    

    方法3:通过String的split方法

    public String[] split(String regex):根据给定正则表达式的匹配拆分此字符串。 该方法的作用就像是使用给定的表达式和限制参数 0 来调用两参数 split 方法。因此,所得数组中不包括结尾空字符串。

    //方法3、通过split方法
    	private void matchStringBySplit( String parent,String child )
    	{
    		String[] array = parent.split(child);
    		System.out.println( "匹配个数为" + (array.length-1) );
    	}
    

    完整代码:

    import java.util.Arrays;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    /**
     * 在字符串中查找匹配的子字符串
     * author:大能豆   QQ:1023507448
     * case :
     * 源字符串:You may be out of my sight, but never out of my mind.
     * 要查找的子字符串:my
     * 输出:匹配个数为2
     */
    public class MatchString {
    
        //方法1、通过String的indexOf(String str, int fromIndex)方法
        private void matchStringByIndexOf(String parent, String child) {
            int count = 0;
            int index = 0;
            while ((index = parent.indexOf(child, index)) != -1) {
                index = index + child.length();
                count++;
            }
            System.out.println("匹配个数为" + count);//结果输出
        }
    
        //方法2、通过正则表达式
        private void matchStringByRegularExpression(String parent, String child) {
            int count = 0;
            Pattern p = Pattern.compile(child);
            Matcher m = p.matcher(parent);
            while (m.find()) {
                count++;
                System.out.println("匹配项" + count + ":" + m.group()); //group方法返回由以前匹配操作所匹配的输入子序列。
            }
            System.out.println("匹配个数为" + count); //结果输出
        }
    
        //方法3、通过split方法,但此方法需考虑子字符串是否是在末尾,若在末尾则不需要-1
        private void matchStringBySplit(String parent, String child) {
            String[] array = parent.split(child);
            System.out.println("匹配个数为" + (array.length - 1));
        }
    
        public static void main(String[] args) {
            MatchString ms = new MatchString();
            String parent = "You may be out of my sight, but never out of my mind.";
            String child = "my";
    
            System.out.println("------通过indexOf-------");
            ms.matchStringByIndexOf(parent, child);  //调用方法1
    
            System.out.println("------通过正则表达式-------");
            ms.matchStringByRegularExpression(parent, child);  //调用方法2
    
            System.out.println("------通过split方法-------");
            ms.matchStringBySplit(parent, child);  //调用方法3
    
            String test = "abcdbdasda";
            String[] as = test.split("a");
            System.out.println(Arrays.toString(as));
        }
    
    }
    
    
    展开全文
  • java 字符串模糊匹配

    万次阅读 2014-10-17 17:45:03
    java正则表达式通过java.util.regex包下的Pattern类与Matcher类实现. Pattern类用于创建一个正则表达式,也可以说创建一个匹配模式,它的构造方法是私有的,不可以直接创建,但可以通过Pattern.complie(String regex)...
    java正则表达式通过java.util.regex包下的Pattern类与Matcher类实现. Pattern类用于创建一个正则表达式,也可以说创建一个匹配模式,它的构造方法是私有的,不可以直接创建,但可以通过Pattern.complie(String regex)简单工厂方法创建一个正则表达式,
    Java代码示例: Pattern p=Pattern.compile("\\w+");
    p.pattern();//返回 \w+ 

    pattern() 返回正则表达式的字符串形式,其实就是返回Pattern.complile(String regex)的regex参数

    1、Pattern.split(CharSequence input)
     Pattern有一个split(CharSequence input)方法,用于分隔字符串,并返回一个String[].
    Java代码示例:
    Pattern p=Pattern.compile("\\d+");
    String[] str=p.split("TestPattern97Matcher"); 
    结果:str[0]="TestPattern" str[1]="Matcher"

    2、Pattern.matcher(String regex,CharSequence input)是一个静态方法,用于快速匹配字符串,该方法适合用于只匹配一次,且匹配全部字符串.
    Java代码示例:
    Pattern.matches("\\d+","2223");//返回true
    Pattern.matches("\\d+","2223aa");//返回false,需要匹配到所有字符串才能返回true,这里aa不能匹配到
    Pattern.matches("\\d+","22bb23");//返回false,需要匹配到所有字符串才能返回true,这里bb不能匹配到 

    3、Pattern.matcher(CharSequence input)
    Pattern.matcher(CharSequence input)返回一个Matcher对象.
    Matcher类的构造方法也是私有的,不能随意创建,只能通过Pattern.matcher(CharSequence input)方法得到该类的实例.
    Pattern类只能做一些简单的匹配操作,要想得到更强更便捷的正则匹配操作,那就需要将Pattern与Matcher一起合作.Matcher类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持.
    Java代码示例:
    Pattern p=Pattern.compile("\\d+");
    Matcher m=p.matcher("22bb23");
    m.pattern();//返回p 也就是返回该Matcher对象是由哪个Pattern对象的创建的 

    4、Matcher.matches()/ Matcher.lookingAt()/ Matcher.find()
    Matcher 类提供三个匹配操作方法,三个方法均返回boolean类型,当匹配到时返回true,没匹配到则返回false

    matches()对整个字符串进行匹配,只有整个字符串都匹配了才返回true
    Pattern p=Pattern.compile("\\d+");
    Matcher m=p.matcher("22bb23");
    m.matches();//返回false,因为bb不能被\d+匹配,导致整个字符串匹配未成功.
    Matcher m2=p.matcher("2223");
    m2.matches();//返回true,因为\d+匹配到了整个字符串 

    在仅使用一次正则表达式时,可以方便地通过此类定义 matches 方法。此方法编译表达式并在单个调用中将输入序列与其匹配
    即Pattern.matcher("\\d+","22bb23")与 Pattern.compile("\\d+").matcher("22bb23").matches()  等价

    lookingAt()对前面的字符串进行匹配,只有匹配到的字符串在最前面才返回true
    Pattern p=Pattern.compile("\\d+");
    Matcher m=p.matcher("22bb23");
    m.lookingAt();//返回true,因为\d+匹配到了前面的22
    Matcher m2=p.matcher("aa2223");
    m2.lookingAt();//返回false,因为\d+不能匹配前面的aa 

    find()对字符串进行匹配,匹配到的字符串可以在任何位置.
    Pattern p=Pattern.compile("\\d+");
    Matcher m=p.matcher("22bb23");
    m.find();//返回true
    Matcher m2=p.matcher("aa2223bb");
    m2.find();//返回true
    Matcher m3=p.matcher("aabb");
    m3.find();//返回false 

    find(int start) 从指定索引开始匹配
    Pattern p=Pattern.compile("\\d+");
    Matcher m=p.matcher("aa2223bb");
    m.find(5); // 返回true
    m.find(6); // 返回false

    5、Mathcer.start()/ Matcher.end()/ Matcher.group()
    当使用matches(),lookingAt(),find()执行匹配操作后,就可以利用以上三个方法得到更详细的信息.
    start()返回匹配到的子字符串在字符串中的索引位置.
    end()返回匹配到的子字符串的最后一个字符在字符串中的索引位置.
    group()返回匹配到的子字符串
    Pattern p=Pattern.compile("\\d+");
    Matcher m=p.matcher("aaa2223bb");
    m.find();//匹配2223
    m.start();//返回3
    m.end();//返回7,返回的是2223后的索引号
    m.group();//返回2223 
    Mathcer m2=m.matcher("2223bb"); 
    m.lookingAt();   //匹配2223 
    m.start();   //返回0,由于lookingAt()只能匹配前面的字符串,所以当使用lookingAt()匹配时,start()方法总是返回0 
    m.end();   //返回4 
    m.group();   //返回2223
    Matcher m3=m.matcher("2223bb"); 
    m.matches();   //匹配整个字符串 
    m.start();   //返回0,原因相信大家也清楚了 
    m.end();   //返回6,原因相信大家也清楚了,因为matches()需要匹配所有字符串 
    m.group();   //返回2223bb
    

    start(),end(),group()均有一个重载方法它们是start(int i),end(int i),group(int i)专用于分组操作,Mathcer类还有一个groupCount()用于返回有多少组.
    Pattern p=Pattern.compile("([a-z]+)(\\d+)");
    Matcher m=p.matcher("aaa2223bb");
    m.find();   //匹配aaa2223
    m.groupCount();   //返回2,因为有2组
    m.start(1);   //返回0 返回第一组匹配到的子字符串在字符串中的索引号
    m.start(2);   //返回3
    m.end(1);   //返回3 返回第一组匹配到的子字符串的最后一个字符在字符串中的索引位置.
    m.end(2);   //返回7
    m.group(1);   //返回aaa,返回第一组匹配到的子字符串
    m.group(2);   //返回2223,返回第二组匹配到的子字符串 

    现在我们使用一下稍微高级点的正则匹配操作,例如有一段文本,里面有很多数字,而且这些数字是分开的,我们现在要将文本中所有数字都取出来,利用java的正则操作是那么的简单.
    Java代码示例:
    Pattern p=Pattern.compile("\\d+");
    Matcher m=p.matcher("我的QQ是:456456 我的电话是:0532214 我的邮箱是:aaa123@aaa.com");
    while(m.find()) {
         System.out.println(m.group());
    }
    
    输出:
    456456
    0532214
    123

    如将以上while()循环替换成
    while(m.find()) {
         System.out.println(m.group());
         System.out.print("start:"+m.start());
         System.out.println(" end:"+m.end());
    } 
    则输出:
    456456
    start:6 end:12
    0532214
    start:19 end:26
    123
    start:36 end:39

    现在大家应该知道,每次执行匹配操作后start(),end(),group()三个方法的值都会改变,改变成匹配到的子字符串的信息,以及它们的重载方法,也会改变成相应的信息.

    注意:只有当匹配操作成功,才可以使用start(),end(),group()三个方法,否则会抛出java.lang.IllegalStateException,也就是当matches(),lookingAt(),find()其中任意一个方法返回true时,才可以使用.


    文章参考 :http://blog.csdn.net/kofandlizi/article/details/7323863


    展开全文
  • java字符串模糊匹配

    千次阅读 2013-04-24 20:25:58
    今天因为业务需求,需要在java中进行字符串模糊匹配,由于要比较的对象长度不同,也没有固定的组成规则,收集到下列三个方法解决问题  方法一、  public intindexOf(String str)  返回指定子字符串在此字符...

    今天因为业务需求,需要在java中进行字符串的模糊匹配,由于要比较的对象长度不同,也没有固定的组成规则,收集到下列三个方法解决问题
       方法一、
        public intindexOf(String str)
          返回指定子字符串在此字符串中第一次出现处的索引。返回的整数是
         this.startsWith(str, k)为 true 的最小 k值。
    参数:str - 任意字符串。
    返回:如果字符串参数作为一个子字符串在此对象中出现,则返回第一个这种子字符串的第一个字符的索引;如果它不作为一个子字符串出现,则返回-1。
        if(str1.indexOf("RO")>=0 ||str1.indexOf("EL")>=0 ||str1.indexOf("RO")>=0)
        {存在}
       方法二、
    public boolean contains(CharSequence s)
      当且仅当此字符串包含指定的 char 值序列时,返回true。
       参数:s- 要搜索的序列(注意:String 类是实现CharSequence接口的一个实体类)
       返回:如果此字符串包含s,则返回 true,否则返回 false
       例子:
          Str.contains("12334")
          注意:,意思为,Str字符串中出现字符串“12345”五个字符中的任何一个,那么则返回true;
     方法三、通过正则表达式+matches方法
         publicboolean matches(String regex)
      告知此字符串是否匹配给定的正则表达式。
     
    调用此方法的str.matches(regex)形式与以下表达式产生的结果完全相同:
    Pattern.matches(regex,str)
    参数:regex - 用来匹配此字符串的正则表达式
    返回:当且仅当此字符串匹配给定的正则表达式时,返回 true


    友情提示,要想真正的用好正则表达式,正确的理解元字符是最重要的事情。下表列出了所有的元字符和对它们的一个简短的描述。
    元字符 描述
    \ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如,“\n”匹配字符“n”。“\\n”匹配一个换行符。序列“\\”匹配“\”而“\(”则匹配“(”。
    ^ 匹配输入字符串的开始位置。如果设置了RegExp对象的Multiline属性,^也匹配“\n”或“\r”之后的位置。
    $ 匹配输入字符串的结束位置。如果设置了RegExp对象的Multiline属性,$也匹配“\n”或“\r”之前的位置。
    * 匹配前面的子表达式零次或多次。例如,zo*能匹配“z”以及“zoo”。*等价于{0,}。
    + 匹配前面的子表达式一次或多次。例如,“zo+”能匹配“zo”以及“zoo”,但不能匹配“z”。+等价于{1,}。
    ? 匹配前面的子表达式零次或一次。例如,“do(es)?”可以匹配“does”或“does”中的“do”。?等价于{0,1}。
    {n} n是一个非负整数。匹配确定的n次。例如,“o{2}”不能匹配“Bob”中的“o”,但是能匹配“food”中的两个o。
    {n,} n是一个非负整数。至少匹配n次。例如,“o{2,}”不能匹配“Bob”中的“o”,但能匹配“foooood”中的所有o。“o{1,}”等价于“o+”。“o{0,}”则等价于“o*”。
    {n,m} m和n均为非负整数,其中n<=m。最少匹配n次且最多匹配m次。例如,“o{1,3}”将匹配“fooooood”中的前三个o。“o{0,1}”等价于“o?”。请注意在逗号和两个数之间不能有空格。
    ? 当该字符紧跟在任何一个其他限制符(*,+,?,{n},{n,},{n,m})后面时,匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串,而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如,对于字符串“oooo”,“o+?”将匹配单个“o”,而“o?”将匹配所有“o”。
    .点 匹配除“\n”之外的任何单个字符。要匹配包括“\n”在内的任何字符,请使用像“(.|\n)”的模式。
    (pattern) 匹配pattern并获取这一匹配。所获取的匹配可以从产生的Matches集合得到,在VBScript中使用SubMatches集合,在JScript中则使用$0…$9属性。要匹配圆括号字符,请使用“\(”或“\)”。
    (?:pattern) 匹配pattern但不获取匹配结果,也就是说这是一个非获取匹配,不进行存储供以后使用。这在使用或字符“(|)”来组合一个模式的各个部分是很有用。例如“industr(?:y|ies)”就是一个比“industry|industries”更简略的表达式。
    (?=pattern) 正向肯定预查,在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需要获取供以后使用。例如,“Windows(?=95|98|NT|2000)”能匹配“Windows2000”中的“Windows”,但不能匹配“Windows3.1”中的“Windows”。预查不消耗字符,也就是说,在一个匹配发生后,在最后一次匹配之后立即开始下一次匹配的搜索,而不是从包含预查的字符之后开始。
    (?!pattern) 正向否定预查,在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需要获取供以后使用。例如“Windows(?!95|98|NT|2000)”能匹配“Windows3.1”中的“Windows”,但不能匹配“Windows2000”中的“Windows”。预查不消耗字符,也就是说,在一个匹配发生后,在最后一次匹配之后立即开始下一次匹配的搜索,而不是从包含预查的字符之后开始。
    (?<=pattern) 反向肯定预查,与正向肯定预查类似,只是方向相反。例如,“(?<=95|98|NT|2000)Windows”能匹配“2000Windows”中的“Windows”,但不能匹配“3.1Windows”中的“Windows”。
    (?<!pattern) 反向否定预查,与正向否定预查类似,只是方向相反。例如“(?<!95|98|NT|2000)Windows”能匹配“3.1Windows”中的“Windows”,但不能匹配“2000Windows”中的“Windows”。
    x|y 匹配x或y。例如,“z|food”能匹配“z”或“food”。“(z|f)ood”则匹配“zood”或“food”。
    [xyz] 字符集合。匹配所包含的任意一个字符。例如,“[abc]”可以匹配“plain”中的“a”。
    [^xyz] 负值字符集合。匹配未包含的任意字符。例如,“[^abc]”可以匹配“plain”中的“plin”。
    [a-z] 字符范围。匹配指定范围内的任意字符。例如,“[a-z]”可以匹配“a”到“z”范围内的任意小写字母字符。
    [^a-z] 负值字符范围。匹配任何不在指定范围内的任意字符。例如,“[^a-z]”可以匹配任何不在“a”到“z”范围内的任意字符。
    \b 匹配一个单词边界,也就是指单词和空格间的位置。例如,“er\b”可以匹配“never”中的“er”,但不能匹配“verb”中的“er”。
    \B 匹配非单词边界。“er\B”能匹配“verb”中的“er”,但不能匹配“never”中的“er”。
    \cx 匹配由x指明的控制字符。例如,\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则,将c视为一个原义的“c”字符。
    \d 匹配一个数字字符。等价于[0-9]。
    \D 匹配一个非数字字符。等价于[^0-9]。
    \f 匹配一个换页符。等价于\x0c和\cL。
    \n 匹配一个换行符。等价于\x0a和\cJ。
    \r 匹配一个回车符。等价于\x0d和\cM。
    \s 匹配任何空白字符,包括空格、制表符、换页符等等。等价于[\f\n\r\t\v]。
    \S 匹配任何非空白字符。等价于[^ \f\n\r\t\v]。
    \t 匹配一个制表符。等价于\x09和\cI。
    \v 匹配一个垂直制表符。等价于\x0b和\cK。
    \w 匹配包括下划线的任何单词字符。等价于“[A-Za-z0-9_]”。
    \W 匹配任何非单词字符。等价于“[^A-Za-z0-9_]”。
    \xn 匹配n,其中n为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如,“\x41”匹配“A”。“\x041”则等价于“\x04&1”。正则表达式中可以使用ASCII编码。
    \num 匹配num,其中num是一个正整数。对所获取的匹配的引用。例如,“(.)\1”匹配两个连续的相同字符。
    \n 标识一个八进制转义值或一个向后引用。如果\n之前至少n个获取的子表达式,则n为向后引用。否则,如果n为八进制数字(0-7),则n为一个八进制转义值。
    \nm 标识一个八进制转义值或一个向后引用。如果\nm之前至少有nm个获得子表达式,则nm为向后引用。如果\nm之前至少有n个获取,则n为一个后跟文字m的向后引用。如果前面的条件都不满足,若n和m均为八进制数字(0-7),则\nm将匹配八进制转义值nm。
    \nml 如果n为八进制数字(0-3),且m和l均为八进制数字(0-7),则匹配八进制转义值nml。
    \un 匹配n,其中n是一个用四个十六进制数字表示的Unicode字符。例如,\u00A9匹配版权符号(©)。

                   注意:在普通的正则表达式中,15个具有特殊意义的元字符需要进行转义:
                 ( [ { } ] ) \ ^ - $ | ? * + .

    字符串精确匹配
       public booleanequalsIgnoreCase(String anotherString)
    将此 String 与另一个 String比较,不考虑大小写。如果两个字符串的长度相同,并且其中的相应字符都相等(忽略大小写),则认为这两个字符串是相等的。
    在忽略大小写的情况下,如果下列至少一项为 true,则认为 c1 和c2 这两个字符相同。
    这两个字符相同(使用 == 运算符进行比较)。
    对每个字符应用方法 Character.toUpperCase(char) 生成相同的结果。
    对每个字符应用方法 Character.toLowerCase(char) 生成相同的结果。
    参数:
    anotherString - 与此 String 进行比较的String。
    返回:
    如果参数不为 null,且这两个 String 相等(忽略大小写),则返回true;否则返回 false。

    展开全文
  • 今天做项目时需要用到字符串模糊匹配知识,于是对这块知识进行了简单梳理,如下: 第一种方法: public intindexOf(Stringstr) 返回指定子字符串在此字符串中第一次出现处的索引。返回的整数是 this.startsWith...
  • 需要在java中进行字符串模糊匹配,由于要比较的对象长度不同,也没有固定的组成规则,收集到下列三个方法解决问题 方法一、 public intindexOf(Stringstr) 返回指定子字符串在此字符串中第一次出现处的索引...
  • 今天因为业务需求,需要在java中进行字符串模糊匹配,由于要比较的对象长度不同,也没有固定的组成规则,收集到下列三个方法解决问题 方法一、 public int indexOf(String str) 返回指定子字符串在此字符串中第...
  • 主要介绍了正则表达式实现字符的模糊匹配功能,结合具体java实例形式分析了针对字符串模糊匹配查询相关实现技巧,需要的朋友可以参考下
  • 返回:如果字符串参数作为一个子字符串在此对象中出现,则返回第一个这种子字符串的第一个字符的索引;如果它不作为一个子字符串出现,则返回 -1。 if(str1.indexOf(“RO”)>=0 || str1.indexOf(“EL”)>=0 ||...
  • 在源字符串“You may be out of my sight, but never out of my mind.”中查找“my”的个数。输出:匹配个数为2 三种方法: 1.通过String的indexOf方法 2. 通过正则表达式 3. 通过String的split方法 其中第一种方法...
  • 字符串模糊匹配递归实现优化1

    千次阅读 2012-11-22 20:12:08
    此程序可以匹配相似度比较大的字符串。 例如: FR-IRC6【产品描述:配件|Family InterDomain Routing Feature配件】 FR-IRC6【产品描述:附件|Family InterDomain Routing Feature附件】 热缩套管【产品描述:1...
  • java实现字符串匹配的算法问题

    千次阅读 2019-03-16 20:37:52
    字符串匹配算就是给定两个串,查找一个串是否在另一个串里面。 就是一个串一个串的比较即可! public static int BF(String str,String sub,int pos){ //1.判断pos合法性。 if(pos &amp;lt; 0 || pos &...
  • 字符串模糊匹配是NLP自然语言处理中一项十分重要的研究项目。 今天给大家介绍的就是字符串模糊匹配。 文章链接:NLP教程:字符串模糊匹配
  • java中进行字符串模糊匹配

    千次阅读 2020-04-24 16:57:46
    需要在java中进行字符串模糊匹配,由于要比较的对象长度不同,也没有固定的组成规则,收集到下列三个方法解决问题 方法一、 public int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。...
  • 解决模糊字符串匹配的算法经典算法:基于动态生成矩阵的方法,其时间复杂度为 O(mn) 对该算法的改进: 1.位向量方法 -bpm算法,时间复杂度为 O( n[m/ w] )。 2.过滤方法,它们的平均执行时间一般快于 O(n)。 背景...
  • 简单易用的字符串模糊匹配库Fuzzywuzzy 阅读目录 FuzzyWuzzy 简介 安装 用法 已知移植 FuzzyWuzzy 简介 FuzzyWuzzy 是一个简单易用的模糊字符串匹配工具包。它依据 Levenshtein Distance 算法 计算两个...
  • mybatis字符串模糊匹配

    2019-09-26 20:36:43
    1. 参数中直接加入%%,注意不需要加两个单引号,加了就会出错,因为系统会自动为字符串类型加上两个单引号 <select id="selectPersons" resultType="person" parameterType="person"> select id,sex,age,...
  • FuzzyWuzzy 是一个简单易用的模糊字符串匹配工具包。它依据Levenshtein Distance 算法计算两个序列之间的差异。 Levenshtein Distance算法,又叫Edit Distance算法,是指两个字符串之间,由一个转成另一个所需的...
  • 实现 项目里面的一个 字符串检索功能(无关业务,只写实现,后续 需要融入项目,会把树生成一段二进制blob 放到内存,变长的字节储存listsize 以及一些偏移 会重新构造搜索算法,预计一周后会继续与大家分享) ...
  • * 判断str字符串是否能够被regex匹配,能满足普通情况,没有考虑特别复杂的情况 * 如a*b?d可以匹配aAAAbcd * @param str 任意字符串 * @param regex 包含*或?的匹配表达式(如果要匹配*、?、\,需要加上反...
  • 模糊匹配算法java实现

    2021-02-04 10:05:15
    使用java实现对两个字符串进行比较分析其相似度。
  • 一、字符串关键字索引越靠前,排序越靠前 二、索引相同,字越少越靠前 /** * 进行filter索引进行排序 * @param filter * @param filterVector 要进行排序字符串 * @param rowList 过滤后的行列表 * @...
  • 题目描述给定一些字符串,请写一个算法,从中搜索出包含您输入的字符序列的那些字符串,按匹配度的高低排序输出。没有任何一个字符串匹配上,输出-1。字符串源source 如下:"AB","ABC","ACB","ABCD","ADBCF","ABDCF...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,597
精华内容 9,438
关键字:

java实现字符串模糊匹配

java 订阅