精华内容
下载资源
问答
  • 现有一接口语句,用于数据集接口维护,其中sql查询入参是使用的'${}'来标识的。在实际使用过程中,需要将sql中的参数全部提取出来,那应该如何处理呢?...2、找到字符串中相同的关键字,如 '${ 和 }' ...

    b28aebc07badd487276df06d91cac779.png

    现有一接口语句,用于数据集接口维护,其中sql查询入参是使用的'${}'来标识的。在实际使用过程中,需要将sql中的参数全部提取出来,那应该如何处理呢?经过资料查询,发现并没有现成的API可以直接使用,所以,这个轮子得自己来造。效率问题暂时不考虑,先实现功能,再做优化。

    实现思路:

    1、参数值可能有多个,又是在字符串中,可以利用下标截取字符串的方式。

    2、找到字符串中相同的关键字,如 '${ 和 }' ,利用两个下标值就能截取到实际的参数值

    3、查询全部'${的下标生成集合,查询全部}'的下标生成集合

    4、根据两个下标集合的一一匹配关系,截取字符串中的全部参数

    代码实现:

    1、查询一个字符串再另一个字符串中出现的下标

    /** * 查询一个字符串再另一个字符串中出现的下标 * @param str * @param key * @return */public static List searchAllIndex(String str, String key) { List allIndex=new ArrayList(); int a = str.indexOf(key);//*第一个出现的索引位置 while (a != -1) { allIndex.add(a); a = str.indexOf(key, a + 1);//*从这个索引往后开始第一个出现的位置 } return allIndex;}2、根据关键字 获取字符串中参数

    /** * 根据关键字 获取字符串中参数 * @param string * @param keyStart 如'${ * @param keyEnd 如 }' * @return */public static List getKeyListFromString(String string,String keyStart,String keyEnd){ // 返回数据 List allStringList=new ArrayList(); // 判断不为空 if(StringUtils.isNotBlank(string)){ // 去空格 string = string.replaceAll("\\\\s*",""); // 开始keyIndex集合 List firstIndex=searchAllIndex(string,keyStart); // 结束keyIndex集合 List endIndex=searchAllIndex(string,keyEnd); // 不为空 if(CollectionUtils.isNotEmpty(firstIndex)){ // 循环 for(int i=0;i

    010a6cea6e5f90237caa545263e82de3.png

    展开全文
  • 该楼层疑似违规已被系统折叠隐藏此楼查看...import java.io.UnsupportedEncodingException;import java.net.URLDecoder;import java.util.List;import com.Action.DefaultAction;import com.model.TbArticle;import ...

    该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

    package com.Action;

    import java.io.UnsupportedEncodingException;

    import java.net.URLDecoder;

    import java.util.List;

    import com.Action.DefaultAction;

    import com.model.TbArticle;

    import com.model.TbArticletype;

    import com.DAO.TbArticleDAO;

    public class ArticleAction extends DefaultAction {

    private TbArticleDAO articleDao = null;

    private TbArticle article = null;

    private List searchArticles = null;

    private List articleTypes = null;

    private String searchStr = null;

    private String articleType = null;

    public String doSearch() {

    if (searchStr != null) {

    searchStr = searchStr.trim();

    }

    String type = this.article == null ? null : this.article

    .getArticleTypeName();

    this.searchArticles = this.articleDao.doSearch(type, searchStr, this

    .getFirstResult(), this.getMaxResults());

    return "searchResult";

    }

    /**

    * 查找某个类型下的所有文章

    *

    * @return

    */

    public String findArticlesByType() {

    this.searchArticles = this.articleDao.findArticlesByType(

    this.articleType, this.getFirstResult(), this.getMaxResults());

    return "type_article";

    }

    public TbArticleDAO getArticleDao() {

    return articleDao;

    }

    public TbArticle getArticle() {

    return article;

    }

    public void setArticle(TbArticle article) {

    this.article = article;

    }

    public void setArticleDao(TbArticleDAO articleDao) {

    this.articleDao = articleDao;

    }

    public List getSearchArticles() {

    return searchArticles;

    }

    public void setSearchArticles(List searchArticles) {

    this.searchArticles = searchArticles;

    }

    public String getSearchStr() {

    return searchStr;

    }

    public void setSearchStr(String searchStr) {

    try {

    searchStr = URLDecoder.decode(searchStr, "UTF-8");

    } catch (UnsupportedEncodingException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    this.searchStr = searchStr;

    }

    public String getArticleType() {

    return articleType;

    }

    public void setArticleType(String articleType) {

    this.articleType = articleType;

    }

    public List getArticleTypes() {

    return articleTypes;

    }

    public void setArticleTypes(List articleTypes) {

    this.articleTypes = articleTypes;

    }

    }

    这是action

    展开全文
  • javaGUI界面输入关键字,然后根据关键字在数据库进行查询,输出查询结果,核心代码是怎么写的
  • 3个索引无助于有效地回答您的查询 . 最好创建一个覆盖所有3个字段的单个索引(这并不意味着您的查询必须具有所有字段的条件)并发出直接索引查询:Sample graph:g = TitanFactory.open("conf/titan-cassandra-es....

    3个索引无助于有效地回答您的查询 . 最好创建一个覆盖所有3个字段的单个索引(这并不意味着您的查询必须具有所有字段的条件)并发出直接索引查询:

    Sample graph:

    g = TitanFactory.open("conf/titan-cassandra-es.properties")

    m = g.getManagementSystem()

    user = m.makeVertexLabel("USER").make()

    email = m.makePropertyKey("USER_EMAIL").dataType(String.class).make()

    fname = m.makePropertyKey("USER_FNAME").dataType(String.class).make()

    lname = m.makePropertyKey("USER_LNAME").dataType(String.class).make()

    m.buildIndex("users", Vertex.class).addKey(email).addKey(fname).addKey(lname).indexOnly(user).buildMixedIndex("search")

    m.commit()

    ElementHelper.setProperties(g.addVertexWithLabel("USER"), "USER_EMAIL", "foo@bar.com", "USER_FNAME", "foo", "USER_LNAME", "bar")

    ElementHelper.setProperties(g.addVertexWithLabel("USER"), "USER_EMAIL", "foo@xyz.com", "USER_FNAME", "foo", "USER_LNAME", "bar")

    ElementHelper.setProperties(g.addVertexWithLabel("USER"), "USER_EMAIL", "abc@bar.com", "USER_FNAME", "foo", "USER_LNAME", "xyz")

    ElementHelper.setProperties(g.addVertexWithLabel("USER"), "USER_EMAIL", "foo@baz.com", "USER_FNAME", "xyz", "USER_LNAME", "bar")

    ElementHelper.setProperties(g.addVertexWithLabel("USER"), "USER_EMAIL", "xyz@bar.com", "USER_FNAME", "xyz", "USER_LNAME", "xyz")

    g.commit()

    Direct index query:

    gremlin> g.indexQuery("users", 'v."USER_EMAIL":/.*xyz.*/ v."USER_FNAME":/.*xyz.*/ v."USER_LNAME":/.*xyz.*/').vertices()*.getElement()._().map()

    ==>{USER_FNAME=xyz, USER_LNAME=xyz, USER_EMAIL=xyz@bar.com}

    ==>{USER_FNAME=xyz, USER_LNAME=bar, USER_EMAIL=foo@baz.com}

    ==>{USER_FNAME=foo, USER_LNAME=xyz, USER_EMAIL=abc@bar.com}

    ==>{USER_FNAME=foo, USER_LNAME=bar, USER_EMAIL=foo@xyz.com}

    如您所见,我还用顶点标签替换了 ENTITY_TYPE . 标签可以帮助您保持索引尽可能小 . 例如,如果另一种类型的顶点(例如 PROFILE )也使用属性 USER_EMAIL ,则它不会进入索引(如果它是使用 .indexOnly(user) 创建的) .

    展开全文
  • 递归查询树tree结构有两种做法: 第一种,递归查询数据库结构,第二种,一次性将...反向递归(逆向递归)查询树tree结构根据关键字过滤数据,大家有么有遇到过这个问题: 这是一个树结构,默认查询全部 我想要根

              阿里云低价服务器1折特惠,优惠爽翻天,点我立即低价购买

    1. 递归查询树tree结构有两种做法

    第一种,递归查询数据库结构,

    第二种,一次性将数据库表中的所有数据查出来,然后再递归查出来的list集合,

    第一种做法适合数据量较少的tree结构,因为要一直查询数据库数据量大时速度回相对较慢,所以数据量大时建议使用第二种方法,如图1所示是一个常见的树tree结构

    图1

     

    2. 反向递归(逆向递归)查询树tree结构根据关键字过滤数据

    大家有么有遇到过这个问题:我想要根据关键字过滤查询出相关数据和它的上级结构,得到图1所示结果,可往往不知道怎么做,查不出上级结构总是得到图3类似的结构,要解决这个比较常见的问题就要用到反向递归的算法,网上我那个网搜不到类似的解决方案,本人一时兴趣来了,做了一套递归和反递归的解决方案,简单易懂,大家可以相互交流一下

    图2

    图3

    3.示例代码

     

     /**
         * 说明方法描述:将list转为树tree结构
         * 
         * @param allRrecords
         * @return
         * @time 2016年5月10日 下午6:00:35
         * @author yangdong
         */
        public List<Record> useListRecordToTree(List<Record> allRrecords) {
    
            List<Record> listParentRecord = new ArrayList<Record>();
            List<Record> listNotParentRecord = new ArrayList<Record>();
            // 第一步:遍历allRrecords保存所有数据的uuid用于判断是不是根节点
            Map<String, String> mapAllUuid = new HashMap<String, String>();
            Map<String, Record> allRecordMap = new HashMap<String, Record>();
            for (Record record : allRrecords) {
                mapAllUuid.put(record.getStr("uuid"), record.getStr("uuid"));
                allRecordMap.put(record.getStr("uuid"), record);
            }
            // 第二步:遍历allRrecords找出所有的根节点和非根节点
            if (allRrecords != null && allRrecords.size() > 0) {
                for (Record record : allRrecords) {
                    if (StringUtil.isBlank(record.getStr("parent_uuid"))
                        || !mapAllUuid.containsKey(record.getStr("parent_uuid"))) {
                        listParentRecord.add(record);
                    } else {
                        listNotParentRecord.add(record);
                    }
                }
            }
    
            // 第三步: 递归获取所有子节点
            if (listParentRecord.size() > 0) {
                for (Record record : listParentRecord) {
                    // 添加所有子级
                    record.set("childs", this.getTreeChildRecord(listNotParentRecord, record.getStr("uuid")));
                }
            }
            return listParentRecord;
        }
    
        /**
         * 说明方法描述:使list转换为树并根据关键字和节点名称过滤
         * 
         * @param allRecords 所有节点
         * @param keywords 要过滤的关键字
         * @param filterFields 要过滤的字段
         * @return
         * @time 2016年5月19日 下午3:27:32
         * @author yangdong
         */
        public List<Record> useListRecordToTreeByKeywords(List<Record> allRecords, String keywords, String... filterFields) {
            List<Record> listRecord = new ArrayList<Record>();
            Map<String, Record> allRecordMap = new HashMap<String, Record>();
            for (Record record : allRecords) {
                allRecordMap.put(record.getStr("uuid"), record);
            }
            // 遍历allRrecords找出所有的nodeName和关键字keywords相关的数据
            if (allRecords != null && allRecords.size() > 0) {
                if (filterFields.length > 1) {
                    for (Record record : allRecords) {
                        for (String field : filterFields) {
                            // 比较
                            if (record.getStr(field).toLowerCase().indexOf(keywords.toLowerCase()) != -1) {
                                listRecord.add(record);
                            }
                        }
                    }
                } else {
                    for (Record record : allRecords) {
                        // 比较
                        if (record.getStr(filterFields[0]).toLowerCase().indexOf(keywords.toLowerCase()) != -1) {
                            listRecord.add(record);
                        }
                    }
                }
            }
            // 查找过滤出来的节点和他们的父节点
            listRecord = this.getSelfAndTheirParentRecord(listRecord, new ArrayList<Record>(),
                                                          new HashMap<String, Record>(), allRecordMap);
            // 将过滤出来的数据变成树tree结构
            listRecord = this.useListRecordToTree(listRecord);
            return listRecord;
        }
    
        /**
         * 说明方法描述:递归查询子节点
         * 
         * @param childList 子节点
         * @param parentUuid 父节点id
         * @return
         * @time 2016年5月10日 下午3:29:35
         * @author yangdong
         */
        private List<Record> getTreeChildRecord(List<Record> childList, String parentUuid) {
            List<Record> listParentRecord = new ArrayList<Record>();
            List<Record> listNotParentRecord = new ArrayList<Record>();
            // 遍历tmpList,找出所有的根节点和非根节点
            if (childList != null && childList.size() > 0) {
                for (Record record : childList) {
                    // 对比找出父节点
                    if (StringUtil.equals(record.getStr("parent_uuid"), parentUuid)) {
                        listParentRecord.add(record);
                    } else {
                        listNotParentRecord.add(record);
                    }
    
                }
            }
            // 查询子节点
            if (listParentRecord.size() > 0) {
                for (Record record : listParentRecord) {
                    // 递归查询子节点
                    record.set("childs", getTreeChildRecord(listNotParentRecord, record.getStr("uuid")));
                }
            }
            return listParentRecord;
        }
    
        /**
         * 说明方法描述:递归找出本节点和他们的父节点
         * 
         * @param parentList 根据关键字过滤出来的相关节点的父节点
         * @param resultList 返回的过滤出来的节点
         * @param filterRecordMap 已经过滤出来的节点
         * @param allRecordMap 所有节点
         * @return
         * @time 2016年5月19日 上午9:53:56
         * @author yangdong
         */
        private List<Record> getSelfAndTheirParentRecord(List<Record> parentList, List<Record> resultList,
                                                         Map<String, Record> filterRecordMap,
                                                         Map<String, Record> allRecordMap) {
            // 当父节点为null或者节点数量为0时返回结果,退出递归
            if (parentList == null || parentList.size() == 0) {
                return resultList;
            }
            // 重新创建父节点集合
            List<Record> listParentRecord = new ArrayList<Record>();
            // 遍历已经过滤出来的节点
            for (Record record : parentList) {
    
                String uuid = record.getStr("uuid");
                String parent_uuid = record.getStr("parent_uuid");
    
                // 如果已经过滤出来的节点不存在则添加到list中
                if (!filterRecordMap.containsKey(uuid)) {
                    listParentRecord.add(record);// 添加到父节点中
                    filterRecordMap.put(uuid, record);// 添加到已过滤的map中
                    allRecordMap.remove(uuid);// 移除集合中相应的元素
                    resultList.add(record);// 添加到结果集中
                }
    
                // 找出本节点的父节点并添加到listParentRecord父节点集合中,并移除集合中相应的元素
                if (StringUtil.isNotBlank(parent_uuid)) {
                    Record parentRecord = allRecordMap.get(parent_uuid);
                    if (parentRecord != null) {
                        listParentRecord.add(parentRecord);
                        allRecordMap.remove(parent_uuid);
                    }
                }
    
            }
            // 递归调用
            getSelfAndTheirParentRecord(listParentRecord, resultList, filterRecordMap, allRecordMap);
    
            return resultList;
        }
    //示例
    /**
         * 说明方法描述:递归查询所有权限
         * 
         * @param keyword
         * @param is_deleted
         * @return
         * @time 2016年5月10日 下午3:47:50
         * @author yangdong
         */
        public List<Record> getRecordByKeywordRecursive(String keyword, String is_deleted) {
            // 第一步:查询所有的数据
            StringBuffer sql = new StringBuffer(
                                                " select pa.uuid,pa.parent_uuid,pa.author_code,pa.author_name,pa.is_menu,pa.sort_number,pa.is_enable,pa.menu_icon ");
            sql.append("  from s_author pa");
            List<Object> params = new ArrayList<Object>();
            sql.append(" where  pa.is_deleted=? ");
            params.add(is_deleted);
            sql.append(" order by pa.sort_number asc ");
    
    
            List<Record> allRrecords = Db.use(AppConst.DB_DATASOURCE_MAIN).find(sql.toString(), ParamUtil.listToArray(params));
                //第二步:将list变为树tree结构
            if (StringUtil.isNotBlank(keyword)) {
                return super.useListRecordToTreeByKeywords(allRrecords, keyword, "author_name");
            } else {
                return super.useListRecordToTree(allRrecords);
            }
        }

     

              阿里云低价服务器1折特惠,优惠爽翻天,点我立即低价购买

     

     

    ---------------------------------------------------------------------------------------------------------------------------------------- 

    如果您认为本教程质量不错,读后觉得收获很大,预期工资能蹭蹭蹭的往上涨,那么不妨小额赞助我一下,让我有动力继续写出高质量的教程。 
       ----------------------------------------------------------------------------------------------------------------------------------------                                                           

    展开全文
  • 能够实现根据以下关键字查询:学生姓名 、学号、班级、课程名称。2. 能够实现按照单科成绩、总成绩、平均成绩、学号排序。3. 能够实现学生信息的插入、删除和修改。4. 能够查询每个课程的最高分、最低分及相应学生...
  • 原文:java递归与反向递归(逆向递归)查询树tree结构根据关键字过滤数据 转载于:https://www.cnblogs.com/wangwangfei/p/6928213.html
  • 1. 递归查询树tree结构有两种做法:第一种,递归查询数据库结构,第二种,一次性将数据库表中的所有数据查出来,然后再... 反向递归(逆向递归)查询树tree结构根据关键字过滤数据大家有么有遇到过这个问题:我想要...
  • 根据订单号查询错误订单信息,并且将查询到的数据写出,作为新的文本 package obj; import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; ...
  • 先来了解一下这个单词的基本含义,根据网络查询结果,如下:说明void这个单词本身的含义就是空白,空的。在Java语言中,一般也用void这个关键字作为方法的返回值,表示该返回值为空。当定义一个方法没有返回值的时候...
  • 文件夹里有很多种类的文件.xls、.txt、.ppt、.excel等文件,需要根据查询的关键字查询这些文件中是否包含
  • 讲白了就是你在项目中输入某些字(比如输入xxoo相关的文字时)时要能检测出来,很多项目中都会有一个敏感词管理模块,在敏感词管理模块中你可以加入敏感词,然后根据加入的敏感词去过滤输入内容中的敏感词并进行相应的...
  • 1、创建接口 BookDao.java package top.woilanlan.jpa.dao;... //根据id查询 Book findBookById(Integer id); //查询id大于 ?1 的所有记录 List<Book> findBookByIdGreaterThan(Integer id);
  • 根据级别查询所有关键字,如果A关键字包含B关键字,例子:关键字A:龙投网 关键字B:龙投网股票入门。 先根据长的匹配加链接,再匹配短的加链接。最后根据匹配次数,为文章的内容加链接。 求源码
  • -- 根据params(匹配) searchPram(模糊字段) sortPram(排序) 查询 返回单个数据--> <select id="getByParam" resultMap="User" parameterType="java.util.Map" > select from user != null" > where ...
  • Android搜索关键字高亮显示

    千次阅读 2018-09-15 17:23:33
    需求分析:根据搜索的关键字,让关键字查询到的内容里高亮显示出来。 先给大家看一下效果图: 这里也分享一下Demo源代码的下载地址: https://download.csdn.net/download/qq15577969/10669001 一、首先从...
  • ES查询 Java RestHighLevelClient API方法

    千次阅读 2019-10-26 15:47:11
    测试环境准备 查询所有文档 分页查询 关键字查询 根据id查询 matchQuery multiMatchQuery BoolQuery filter过滤器 sort排序 高亮 took:本次操作花费的时间,单位为毫秒。...
  • JAVA String 模糊查询

    千次阅读 2013-07-31 10:41:52
    前台输入部分关键字,后台String中进行过滤   // 根据appName过滤 // 判断provider中是否包含appName if (StringUtils.containsIgnoreCase(provider, appName)) { xxxxxxxx }   ...
  • 分页查询 limit [start],[rows]思路:pram start 从哪一行开始 关键是从哪一行开始,需要根据查询的页数来进行换算出查询具体页数是从哪一行开始start = (pages-1)*rows;pages : 具体要查询那一页rows : 每页查询...
  • 1.品优购-高亮显示 1.1需求分析 将用户输入的关键字在标题中以红色的字体显示出来,... * 根据关键字, 分页, 高亮, 过滤, 排序查询, 并且将查询结果返回 * @param paramMap 从页面传入进来的查询参数 * @return ...
  • 通过Lucene的lukeall-1.0.0.jar 通过 java –jar lukeall-1.0.0.jar 可以通过界面的方式可以看到索引库的所有信息截图如下: 但是现在我们需要获取...Lucene中有个IndexSearcher:此类是用来根据Query查询语句来查
  • 小编典典DSL.param()创建一个绑定变量,该绑定变量的生成方式?与SQL一样,或者:bizdate您选择使用命名参数,或者'20190801'选择内联绑定变量。有关绑定变量的更多信息,请参见此处。...相反,您想处理查询...
  • pram start 从哪一行开始 关键是从哪一行开始,需要根据查询的页数来进行换算出查询具体页数是从哪一行开始 start = (pages-1)*rows;pages : 具体要查询那一页 rows : 每页查询多少行 pram rows 查询多少行 总...
  • 业务需要根据关键字查询系统中人员的相关信息,用户输入一个关键字,能够模糊查询一张视图中4个字段的数据。SELECTA .userId,A .account,A .name,A .mobile,A .code,A .phone,A .email,A .sortFROMUSER AIN...
  • Java算法-二分查询

    2021-03-05 12:08:04
    二分查询就是每次遍历时拟定一个中位数,若查找的数小于当次查询的中位数 则右边界等于当此查询的中位数减少-1若查找的数小于当次查询的中位数 则左边界等于当次查询的中位数+1根据左边界右边界进行折半操作 ...
  • Java运维

    2019-09-14 21:51:46
    java程序耗费cpu问题排查 # 首先应该拿到线程列表,假设java应用进程为11952 ps -mp 11952 -o THREAD,tid,time # 根据列表,筛选出资源消耗高的tid,然后解码成关键字 ...# 最后根据线程关键字查询线程 jstack...
  • 参考之后 随意写写,让自己理解下共享变量由volatile修饰,可以保证变量在各个线程的可见性(在执行查询变量值之前会同步缓存和内存,虽然不是原子性操作,但是根据java内存模型happen before原则,使volatile字段的...
  • 我的查询和嵌套文档是关键字标记化的,我只对它们之间的完全匹配感兴趣 .我希望elasticsearch返回具有匹配项的文档,并根据查询术语与嵌套文档匹配的顺序对 "inner_hits" 进行排序 . 这可能吗?例如,假设我的文档...
  • @ApiOperation("根据关键字查询讲师名列表") @GetMapping("list/name/{key}") public ResultVo selectNameListByKey( @ApiParam(name="key",value = "关键字") @PathVariable("key") String key

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 230
精华内容 92
关键字:

java根据关键字查询

java 订阅