Question

例如，我有四个带有相关元素的对象：

.myButton:hover {
  border: 5px solid purple;
  background-color: pink;
}
.myButton[disabled] {
    background-color: blue;
  border: 5px solid red;
}

在test1，test2，test3参数上需要搜索排名1,2,3。所以我的第一次搜索应该是所有匹配的标准{test1，test2，test3）结果 - 没有元素那么第二次搜索应该是{test1，test2} 结果-A4元素匹配这里A1不会被考虑因为A1有额外的参数test4。所以规则是精确匹配或更少匹配，但元素不应该有额外的参数，所以如果有三个参数，那么我需要按以下顺序执行搜索，以最高可能组合开始，然后按较低顺序

A1={test1,test2,test4}
A2={test1}
A3={test1,test3}
A4={test1,test2}

这里没有参数可以是...所以我想要一些通用的解决方案来编程。

Answer 1

您可以使用以下方法进行搜索。

假设您有一个条件数组，其中包含具有优先级的搜索元素，并且您希望搜索输入数组中的哪个元素匹配最高可能性。

条件数组： [z, y, x, w]（优先级为[4, 3, 2, 1]）

输入数组： [wxyz, xz, yz, wz, z]

根据优先级对条件数组进行排序。例如：[w, x, y, z]
让条件数组中的第一个元素作为搜索关键字。例如："w"
过滤以搜索键开头的输入数组中的所有元素。例如：[wxyz, wz]
如果结果集中不包含任何内容，请使用下一个元素作为搜索键。例如"x" 否则，将下一个元素追加到当前搜索键。例如："wx"
重复第3步，直到只剩下一个结果。例如：[wz]
但是，如果最终结果集为空，则可以返回最后一个结果。

以下显示了实施。

<强> Search.java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;


public class Search {

    public static void main(String[] args){
        List<Criteria> criteria = new ArrayList<Criteria>();
        criteria.add(new Criteria("z", 4));
        criteria.add(new Criteria("y", 3));
        criteria.add(new Criteria("x", 2));
        criteria.add(new Criteria("w", 1));
        Collections.sort(criteria);

        List<String> input = Arrays.asList("wx", "wy", "wxy", "xy", "y", "yz", "z", "xyz");

        System.out.println("Final Result: " + performSearch(input, criteria));

    }

    public static Set<String> performSearch(List<String> input, List<Criteria> criteria){
        System.out.println("Start Searching " + criteria + " from " + input);
        Set<String> resultSet = null;
        int keyIdx = 0;
        String searchingKey = "";
        while(true){

            if(keyIdx >= criteria.size()) break;

            Set<String> tempResult = new HashSet<String>();

            searchingKey = searchingKey + criteria.get(keyIdx).getValue();
            System.out.println("Searching... Key = " + searchingKey);
            for(String value : input){
                if(value.startsWith(searchingKey)){
                    tempResult.add(value);
                }
            }
            System.out.println("Result: " + tempResult);

            if(tempResult.size() == 0){
                searchingKey = searchingKey.substring(0, searchingKey.length()-1);
            }else{
                resultSet = tempResult;
                if(resultSet.size() == 1){
                    break;
                }
            }

            keyIdx++;

        }

        return resultSet;
    }

}

<强> Criteria.java

public class Criteria implements Comparable<Criteria> {

    protected String _value;
    protected int _priority;

    public Criteria(String _value, int _priority) {
        super();
        this._value = _value;
        this._priority = _priority;
    }

    public String getValue() {
        return _value;
    }

    public void setValue(String _value) {
        this._value = _value;
    }

    public int getPriority() {
        return _priority;
    }

    public void setPriority(int _priority) {
        this._priority = _priority;
    }

    @Override
    public int compareTo(Criteria o) {
        if(o.getPriority() == this._priority) return 0;
        if(o.getPriority() > this._priority) return -1;
        // smaller priority = higher priority
        return 1;
    }

    public String toString(){
        return this._value;
    }

}

执行结果：

Start Searching [w, x, y, z] from [wx, wy, wxy, xy, y, yz, z, xyz]
Searching... Key = w
Result: [wy, wx, wxy]
Searching... Key = wx
Result: [wx, wxy]
Searching... Key = wxy
Result: [wxy]
Final Result: [wxy]

如何根据优先级搜索具有最大匹配条件的元素

1 个答案: