精华内容
下载资源
问答
  • package com.wyebd.gis; import java.io.File; /** * @Title: DelFiles.java * @Package com.wyebd.gis * @Description: * @author lisr * @date Mar 7, 2012 5:36:03 PM * @version V1.0 */public cla

    package com.wyebd.gis;

    import java.io.File;

    /**  
     * @Title: DelFiles.java
     * @Package com.wyebd.gis
     * @Description:
     * @author lisr
     * @date Mar 7, 2012 5:36:03 PM   
     * @version V1.0  
     */
    public class DelFiles {

     /**
      * @Title: main
      * @Description:
      * @param args
      * @return void
      * @author lisr
      * @date Mar 7, 2012 5:36:04 PM
      * @throws
      */
     //用以模糊删除头部为str的文件
     public static boolean delFilesByPath(String path,String str){
      //参数说明---------path:要删除的文件的文件夹的路径---------str:要匹配的字符串的头
      boolean b=false;
      File file = new File(path);
      File[] tempFile = file.listFiles();
      for(int i = 0; i < tempFile.length; i++){
       if(tempFile[i].getName().startsWith(str)||tempFile[i].getName().endsWith(str)){
        System.out.println("将被删除的文件名:"+tempFile[i].getName());
        boolean del=deleteFile(path+tempFile[i].getName());
        if(del){
         System.out.println("文件"+tempFile[i].getName()+"删除成功");
         b=true;
        }else{
         System.out.println("文件"+tempFile[i].getName()+"删除失败");
        }
       }
      }
      return b;
     }
     
     private static boolean deleteFile(String path){
      System.out.println(path);
      boolean del=false;
      File file=new File(path);
      if(file.isFile()){
       file.delete();
       del=true;
      }
      return del;
     }
     
     public static void main(String[] args) {
      // TODO Auto-generated method stub
      String path="D:/temp/";
      String str="44_";
      if(delFilesByPath(path,str)){
       System.out.println(path+"中包含"+str+"的文件已经全部删除成功!");
      }else{
       System.out.println(path+"中包含"+str+"的文件已经删除失败或该文件夹下不存在这类文件!");
      }
     }

    }

     

     

    ================================================================================

    ================================================================================

    package com.wyebd.gis;

    import java.io.File;

    /**  
     * @Title: DelFiles.java
     * @Package com.wyebd.gis
     * @Description:
     * @author lisr
     * @date Mar 7, 2012 5:36:03 PM   
     * @version V1.0  
     */
    public class DelFiles {

     /**
      * @Title: main
      * @Description:
      * @param args
      * @return void
      * @author lisr
      * @date Mar 7, 2012 5:36:04 PM
      * @throws
      */
     //用以模糊删除头部为str的文件
     public static boolean delFilesByPath(String path,String str){
      //参数说明---------path:要删除的文件的文件夹的路径---------str:要匹配的字符串的头
      boolean b=false;
      File file = new File(path);
      File[] tempFile = file.listFiles();
      for(int i = 0; i < tempFile.length; i++){
       if(tempFile[i].getName().startsWith(str)||tempFile[i].getName().endsWith(str)){
        tempFile[i].delete();
        b=true;
       }
      }
      return b;
     }
     public static void main(String[] args) {
      String path="D:/temp/";
      String str="44_";
      if(delFilesByPath(path,str)){
       System.out.println(path+"中包含"+str+"的文件已经全部删除成功!");
      }else{
       System.out.println(path+"中包含"+str+"的文件已经删除失败或该文件夹下不存在这类文件!");
      }
     }

    }


    个人认为:如果要实现更高级的这种模糊匹配,只需要用String的indexOf()方法,凡是含有这个字符串的文件,都一并删除!
    展开全文
  • 模糊匹配算法java实现

    2021-02-04 10:05:15
    使用java实现对两个字符串进行比较分析其相似度。
  • java Map集合模糊匹配

    万次阅读 2016-10-27 10:23:56
    public class StringTest { public static void main(String[] args) { Map, Object>map=new ConcurrentHashMap, Object>(); map.put("safein", "safein"); map.put("safein
    public class StringTest {
        public static void main(String[] args) {
            Map<String, Object>map=new ConcurrentHashMap<String, Object>();
           map.put("safein", "safein");
           map.put("safein1tebg23", "safein23");
           map.put("twjsafein123", "twjsafein1233");
           map.put("twj", "twj");
           List<?> list=getLikeByMap(map,"twj");
        for (Object val : list) {
            System.err.println(val.toString());
        }
        }
        public static List<String> getLikeByMap(Map<String, Object>map,String keyLike){
            List<String> list=new Vector<>();        
            for (Map.Entry<String, Object> entity : map.entrySet()) {
                                if(entity.getKey().indexOf(keyLike)>-1){
                                        list.add((String) entity.getValue());
                                }
    
                        }    
    
            return list;
        }
    }
    展开全文
  • 使用递归实现,字符串模糊匹配,看设置允许匹配错误数。
  • java字符串模糊匹配

    千次阅读 2014-01-11 00:57:20
    今天因为业务需求,需要在java中进行字符串的模糊匹配,由于要比较的对象长度不同,也没有固定的组成规则,收集到下列三个方法解决问题  方法一、  public int indexOf(String str)  返回指定子字符串在此...
    今天因为业务需求,需要在java中进行字符串的模糊匹配,由于要比较的对象长度不同,也没有固定的组成规则,收集到下列三个方法解决问题
       方法一、  
        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 boolean contains(CharSequence s)
      当且仅当此字符串包含指定的 char 值序列时,返回 true。
       参数:s - 要搜索的序列(注意:String 类是实现CharSequence接口的一个实体类) 
       返回:如果此字符串包含 s,则返回 true,否则返回 false
       例子:
           Str.contains("12334")
           注意:,意思为,Str字符串中出现字符串“12345”五个字符中的任何一个,那么则返回true;
     方法三、通过正则表达式+matches方法
         public boolean 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 boolean equalsIgnoreCase(String anotherString)
    将此 String 与另一个 String 比较,不考虑大小写。如果两个字符串的长度相同,并且其中的相应字符都相等(忽略大小写),则认为这两个字符串是相等的。
    在忽略大小写的情况下,如果下列至少一项为 true,则认为 c1 和 c2 这两个字符相同。
    这两个字符相同(使用 == 运算符进行比较)。
    对每个字符应用方法 Character.toUpperCase(char) 生成相同的结果。
    对每个字符应用方法 Character.toLowerCase(char) 生成相同的结果。
    参数:
    anotherString - 与此 String 进行比较的 String。
    返回:
    如果参数不为 null,且这两个 String 相等(忽略大小写),则返回 true;否则返回 false。

    展开全文
  • java 查询mongo模糊匹配

    千次阅读 2017-08-09 17:49:54
    1完全匹配 Pattern pattern = Pattern.compile("^王$", Pattern.CASE_INSENSITIVE); 2右匹配 Pattern pattern = Pattern.compile("^.*王$", Pattern.CASE_INSENSITIVE); 3左匹配 Pattern pattern = Pattern....
    1完全匹配
    Pattern pattern = Pattern.compile("^王$", Pattern.CASE_INSENSITIVE);
    2右匹配
    Pattern pattern = Pattern.compile("^.*王$", Pattern.CASE_INSENSITIVE);
    3左匹配
    Pattern pattern = Pattern.compile("^王.*$", Pattern.CASE_INSENSITIVE);
    4模糊匹配

    Pattern pattern = Pattern.compile("^.*王.*$", Pattern.CASE_INSENSITIVE);

    BasicDBObject query = new BasicDBObject();
    query.put("account_name", new BasicDBObject("$regex", pattern));

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

    万次阅读 2014-10-17 17:45:03
    Pattern类用于创建一个正则表达式,也可以说创建一个匹配模式,它的构造方法是私有的,不可以直接创建,但可以通过Pattern.complie(String regex)简单工厂方法创建一个正则表达式, Java代码示例: Pattern p=Pattern....
  • Java使用RedisTemplate模糊匹配删除key

    千次阅读 2019-07-18 16:48:46
    Redis模糊匹配批量删除操作,使用redisTemplate操作: 如果有多处用到可将这个方法封装起来调用 /** * redisTemplate删除迷糊匹配的key的缓存 */ public void deleteByPrex(String prex) { Set<String> ...
  • * 判断str字符串是否能够被regex匹配,能满足普通情况,没有考虑特别复杂的情况 * 如a*b?d可以匹配aAAAbcd * @param str 任意字符串 * @param regex 包含*或?的匹配表达式(如果要匹配*、?、\,需要加上反...
  • 主要介绍了Java实现的模糊匹配某文件夹下的文件并删除功能,涉及java针对目录与文件的遍历、匹配、判断、删除等相关操作技巧,需要的朋友可以参考下
  • // 默认匹配 String keyword = "宁"; Bson f0 = Filters.and(f, Filters.regex("key", keyword)); ObjList = Lists.newArrayList(collection.find(f0)); //右匹配 keyword = "^.*宁$"; Bson f1 = Filters.and(f, ...
  • pom <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> RedisConfig ... @B
  • 需要在java中进行字符串的模糊匹配,由于要比较的对象长度不同,也没有固定的组成规则,收集到下列三个方法解决问题 方法一、 public intindexOf(Stringstr) 返回指定子字符串在此字符串中第一次出现处的索引...
  • Java实现字符串组合的模糊匹配

    万次阅读 2019-03-10 11:27:58
    Java实现字符串组合的模糊匹配背景实现方式后续优化 背景 接到这么一个需求:根据用户输入内容(以下简称S)对一系列的字符串组合(每个字符串组合以下简称Z)进行模糊匹配,返回匹配的字符串组合(以下简称R)。 举...
  • Java实现伪查询(全匹配+模糊匹配)        在项目中一直习惯了框架下[springboot+mybatis]的增删改查,然后领导突然给了一个需求,让我先弄一些假数据出来,用于页面的展示,...
  • package com.learn.test; import java.io.File; import java.io.FileFilter; import java.util.ArrayList; import java.util.List; public class TextSearchFile { public static List<File> searchFil...
  • 今天小编就为大家分享一篇Java替换中使用正则表达式实现中间模糊匹配的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 模糊匹配器 介绍 一个基于Java的库,用于对文档集中的“相似”元素进行匹配和分组。 想象一下,在一个具有联系人集合的系统中工作,并且想要对具有相似名称,地址或其他属性的联系人进行匹配和分类。 模糊匹配匹配...
  • java中进行字符串的模糊匹配

    千次阅读 2020-04-24 16:57:46
    需要在java中进行字符串的模糊匹配,由于要比较的对象长度不同,也没有固定的组成规则,收集到下列三个方法解决问题 方法一、 public int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。...
  • 今天做项目时需要用到字符串模糊匹配知识,于是对这块知识进行了简单梳理,如下: 第一种方法: public intindexOf(Stringstr) 返回指定子字符串在此字符串中第一次出现处的索引。返回的整数是 this.startsWith...
  • 字符串匹配 精确: indexOf(String str); -- strstr(), O(mn)。 lastIndexOf(String str); -- continue 的别样用法。 matches(String regex); -- Regex.compile()/match()。 模糊:  java package?  Spell ...
  • 模糊匹配算法(java版)

    2021-01-27 12:18:22
    import java.util.*; public class StringCompareUtil { public static int longestCommonSubsequence(String text1, String text2) { return searchSame(text1, text2, 0, 0, new int[text1.length()][text2....
  • 调用此方法的str.matches(regex)形式与以下表达式产生的结果完全相同: Pattern.matches(regex,str) 参数:regex - 用来匹配此字符串的正则表达式 返回:当且仅当此字符串匹配给定的正则表达式时,返回 true

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 493
精华内容 197
关键字:

java模糊匹配

java 订阅