精华内容
下载资源
问答
  • java模糊字符串匹配
    2021-03-06 19:32:44

    在java里,在字符串中找字符很方便。

    如下例子:

    String fileContent=”this is a  flash call html this flash file=sdcard/initalFlash.swf”;

    要在fileContent这个字符串中查找tempflash这个字符串就可以用如下的方法:

    Pattern pattern = new Pattern.complie(“initialFlash”);  // 这个用来设置要匹配的字符串,可以是正则表达式。

    设置查找的字符串——要在哪个字符串中查找

    Matcher matcher = pattern.matcher(fileContent);

    匹配成功之后,就可以进行替换了。

    String targetFileContent = matcher.replaceFirst(“tempFlash”);

    如此就完成了字符串的查找和替换。

    不过需要导入两个包:

    import java.util.regex.Matcher;

    import java.util.regex.Pattern;

    更多相关内容
  • 什么是模糊字符串匹配 Fuzzy-string-match是用于ruby的模糊字符串匹配库。 很快(用RubyInline用C编写) 它仅支持Jaro-Winkler距离算法。 该程序是从Lucene 3.0.2手动移植的。 (lucene是Java产品) 如果要添加...
  • 模糊匹配算法java实现

    2021-02-04 10:05:15
    使用java实现对两个字符串进行比较分析其相似度。
  • 字符串首字符检测 可以实现模糊查找,保存返回大写字母的数据,然后可以通过输入某个字符串和数据列表进行对比,从而达到模糊查找,无聊时汉字还是英文或者非法字符
  • 使用递归实现,字符串模糊匹配,看设置允许匹配错误数。
  • Java字符串匹配算法

    千次阅读 2021-10-28 11:53:42
    串(string)是由零个或多个字符组成的有限序列又名叫字符串。 一般地,由n个字符串构成的串记作: S=“a0a1…an-1”(n≥0),其中a_i(1≤i≤n) n是个有限的数值 串一般记为S是串的名称,用引号括起来的字符序列是串的...

    定义

    串(string)是由零个或多个字符组成的有限序列又名叫字符串。

    • 一般地,由n个字符串构成的串记作: S=“a0a1…an-1”(n≥0),其中a_i(1≤i≤n)
    • n是个有限的数值
    • 串一般记为S是串的名称,用引号括起来的字符序列是串的值
    • 可以是字母,数字或其他字符,i就是该字符在串中的位置,串中的字符数目n称为串的长度

    子串

    在对字符串S做处理时,经常需要取出其中某一连续的片段,称为S的子串(substring)

    • 具体地,由串S中起始于位置i的连续k个字符组成的子串记作substr(S,i,k) = “aiai+1…ai+k-1”,0≤i (n,0≤k)
    • 前缀 prefix(S,k) = substr(S,0,k);
    • 后缀 suffix(S,k) = substr(S,n-k,k)
    • 空格串:只包含空格的串。

    BF字符串暴力解法

    基本思想

    1. 从主串的第一个字符起与子串的第一个字符进行比较,若相等,则继续对字符串进行后续的比较
    2. 若不相等,则从主串第二个字符起与子串的第一个字符重新比较,以此类推,直到子串中每个字符依次和主串中的一个连续的字符序列相等为止,此时称为匹配成功。
    3. 如果不能在主串中找到与子串相同的字符序列,则匹配失败。

    需要进行回溯操作,否则会错过相等的部分

     /**
         *
         * @param parent 主串
         * @param sub 子串
         */
        public static void bruteForce(String parent,String sub){
            //成功匹配的位置
            int index = -1;
            //主串的长度
            int pLen = parent.length();
            //子串的长度
            int sLen = sub.length();
    
            if (pLen<sLen){
                System.out.println("Error.The main string is greater than the sub string length.");
                return;
            }
    
            int i = 0;
            int j = 0;
            while (i<pLen&&j<sLen){
                // 判断对应位置的字符是否相等
                if (parent.charAt(i)==sub.charAt(j)){
                   //若相等.主串子串继续比较
                   i++;
                   j++;
                }else{
                    //主串回溯到上一次开始匹配的下一个字符
                    i = i- j+1;
                    j = 0;
                }
            }
            //匹配成功
            if (j >= sLen) {
                index = i - j;
                System.out.println("Successful match,index is:" + index);
            } else {// 匹配失败
                System.out.println("Match failed.");
            }
        }
    

    KMP算法

    其核心思想是主串不回溯,模式串尽量多向右移动

    首先构造next表(next表里存放的是字符串真后缀与真前缀相同的子字符串最大长度):

    以ABCDABD为例说明构建next表

    P = ABCDABD
    j = 0, prefix(P, 0) = φ
    next[0] = -1;//规定如此
    
    P = ABCDABD
    j = 1, prefix(P, 1) = A
    真前缀: φ
    真后缀: φ
    next[1] = 0;
    
    P = ABCDABD
    j = 2, prefix(P, 2) = AB
    真前缀: A
    真后缀: B
    next[2] = 0;
    
    P = ABCDABD
    j = 3, prefix(P, 3) = ABC
    真前缀: A,AB
    真后缀: BC,C
    next[3] = 0;
    
    P = ABCDABD
    j = 4, prefix(P, 4) = ABCD
    真前缀: A,AB,ABC
    真后缀: BCD,CD,D
    next[4] = 0;
    
    P = ABCDABD
    j = 5, prefix(P, 5) = ABCDA
    真前缀: A,AB,ABC,ABCD
    真后缀: BCDA,CDA,DA,A
    next[5] = 1;
    
    P = ABCDABD
    j = 6, prefix(P, 6) = ABCDAB
    真前缀: A,AB,ABC,ABCD,ABCDA
    真后缀: BCDAB,CDAB,DAB,AB,B
    next[6] = 2;
    
    得出next表为:
    [-1, 0, 0, 0, 0, 1, 2]
    

    代码实现

    package string;
    
    public class KMP {
        //构建next表
        public static int[] buildNext(String sub){
            //构建next表就是查找真前缀 == 真后缀的最大长度,以获取模式串尽量多地往右移动
            int[] next = new int[sub.length()];
            //主串位置
            int j = 0;
            //子串位置
            int t = next[0] = -1;
    
            while (j<sub.length()-1){
                if (t<0||sub.charAt(j)==sub.charAt(t)){
                    j++;
                    t++;
                    next[j] = t;
                }else {
                    t = next[t];
                }
            }
            return next;
        }
    
        public static void kmp(String parent,String sub){
            int[] next = buildNext(sub);
            //成功匹配的位置
            int index = -1;
            //主串的长度
            int pLen = parent.length();
            //子串的长度
            int sLen = sub.length();
    
            if (pLen<sLen){
                System.out.println("Error.The main string is greater than the sub string length.");
                return;
            }
    
            int i = 0;
            int j = 0;
            while (i<pLen&&j<sLen){
                // 判断对应位置的字符是否相等
                if (j==-1||parent.charAt(i)==sub.charAt(j)){
                    //若相等.主串子串继续比较
                    i++;
                    j++;
                }else{
                    //i不变,j=next[j]
                    j = next[j];
                }
            }
            //匹配成功
            if (j >= sLen) {
                index = i - j;
                System.out.println("Successful match,index is:" + index);
            } else {// 匹配失败
                System.out.println("Match failed.");
            }
        }
    }
    
    
    展开全文
  • 模糊匹配库提供了OmniMark模式函数,该函数试图将输入前缀与任何给定的目标字符串近似匹配。 距离每个目标字符串的允许的Damerau–Levenshtein距离是用户指定的。 此距离等于将目标字符串转换为输入所需的最小字符...
  • 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字符串中的模糊匹配

    千次阅读 2020-07-24 10:51:57
    返回:如果字符串参数作为一个子字符串在此对象中出现,则返回第一个这种子字符串的第一个字符的索引;如果它不作为一个子字符串出现,则返回 -1。 if(str1.indexOf(“RO”)>=0 || str1.indexOf(“EL”)>=0 ||...

    方法一、
    public int indexOf(String str)
    返回指定子字符串在此字符串中第一次出现处的索引。返回的整数是
    this.startsWith(str, k)为 true 的最小 k 值。
    参数:str - 任意字符串。
    返回:如果字符串参数作为一个子字符串在此对象中出现,则返回第一个这种子字符串的第一个字符的索引;如果它不作为一个子字符串出现,则返回 -1。
    if(str1.indexOf(“RO”)>=0 || str1.indexOf(“EL”)>=0 || str1.indexOf(“RO”)>=0)
    {存在}
    public int indexOf(int ch, int fromIndex) :返回在此字符串中第一次出现指定字符处的索引,从指定的索引开始搜索。如果不存在则返回 -1。
    在忽略大小写的情况下,如果至少下列一项为true,则认为C1,C2这两个相等。
    如果字符串参数作为一个子字符串在此对象中则返回第一个这种字符串的第一个字符的索引,如果它不作为一个子字符串出现,则返回-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 );                              //结果输出
    }
    

    方法二、

    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

    展开全文
  • 在面试或者算法学习中,我们多少会接触到一些字符串匹配类型的题目,那么在java中,字符串匹配是怎么实现的呢 二、Java中的字符串匹配方法 java.lang.String 中用来判断字符串匹配的底层代码如下, 返回值不是" -1 ...
  • java 字符串模糊匹配

    2021-03-09 05:39:23
    Pattern类用于创建一个正则表达式,也可以说创建一个匹配模式,它的构造方法是私有的,不可以直接创建,但可以通过Pattern.complie(String regex)简单工厂方法创建一个正则表达式,Java代码示例: Pattern p=Pattern....
  • 字符串应用十分广泛,计算机上非数值处理的对象大部分都是字符串数据,所以字符串匹配技术也是十分重要的一项技术,匹配字符串的索引有许多方法,本文主要讲诉常见的KMP算法,使用 Java 语言实现。
  • Java中的字符串模糊匹配问题

    千次阅读 2020-10-26 13:58:18
    今天做项目时需要用到字符串模糊匹配知识,于是对这块知识进行了简单梳理,如下: 第一种方法: public intindexOf(Stringstr) 返回指定子字符串在此字符串中第一次出现处的索引。返回的整数是 this.startsWith...
  • 您可以使用Apache Lucene,但根据用例,这可能是太重了。...我在这里找到了Java实现。它的代码适用于一个相对较短的方法,具有几乎自我解释的签名:public static List find(String doc, String p...
  • java中进行字符串模糊匹配

    千次阅读 2020-04-24 16:57:46
    需要在java中进行字符串模糊匹配,由于要比较的对象长度不同,也没有固定的组成规则,收集到下列三个方法解决问题 方法一、 public int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。...
  • 本文实例讲述了正则表达式实现字符模糊匹配功能。分享给大家供大家参考,具体如下:package com.cn.util;import java.util.regex.Pattern;/*** 正则表达式 工具类** @author lifangyu*/public class RegexUtil {/*...
  • Ahocorasick 使用Java中的Hashmap轻松实现多模式字符串匹配算法(AhoCorasick) 该项目是使用带有Java SE的eclipse完成的。 要使用它,只需将其导入到Eclipse中即可。 项目状态:完成
  • java字符串的括号匹配

    千次阅读 2021-11-30 19:09:40
    java字符串的括号匹配
  • 快速,模糊字符串匹配。 根据百分比进行搜索并编辑距离。 将数据与字符串关键字相关联,并同时返回两者。 例如,搜索文件名,然后返回关联的文件路径。 动机 尽管哈希映射可用于精确的字符串匹配,而尝试可用于...
  • Java实现伪查询(全匹配+模糊匹配

    千次阅读 2021-03-06 04:18:58
    Java实现伪查询(全匹配+模糊匹配)在项目中一直习惯了框架下[springboot+mybatis]的增删改查,然后领导突然给了一个需求,让我先弄一些假数据出来,用于页面的展示,业务啥的也没说,咱是啥也不知道,咱也不该问,...
  • 需要在java中进行字符串模糊匹配,由于要比较的对象长度不同,也没有固定的组成规则,收集到下列三个方法解决问题 方法一、 public intindexOf(Stringstr) 返回指定子字符串在此字符串中第一次出现处的索引...
  • 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方法 其中第一种方法...
  • 然后输入一个正整数n (0输入一行字符串,在字符串中查找该字符(ch),如果找到,则输出该字符在字符串中最后出现的位置(从0开始);否则输出“Not Found”。例:括号内是说明输入:m (输入一个字符)3...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,429
精华内容 11,771
关键字:

java模糊字符串匹配