我有一组初始数据,可以采用两种不同的格式进行匹配。这些条目将完全匹配或提供一个范围。范围值将是十进制格式的整数-但是要匹配的数据可以是十六进制以及十进制。基数将在初始数据中显示。因此,初始数据将类似于以下内容(JSON格式):

[
    {"value":"X"},
    {"value":"Y"},
    {"START":"0000", "END":"0010", "INPUTBASE":"10"},
    {"START":"0200", "END":"0300", "INPUTBASE":"16"}
]


因此,我需要一个类似boolean contains(final String value)的函数,该函数将检查“ keeper”集中是否包含值。字符串X,Y,8,FF都将命中-FF为十六进制数字(无需考虑多个匹配项) )。我要做的是创建两个具有单个值的集合,另一个具有Range包裹以包含基数的集合。我的代码如下所示:

Set<WrappedRange> wrappedRangeSet;
Set<String> singleEntrySet;
public boolean contains(final String value) {
    return singleEntrySet.contains(value) || valueInRange(value);
}

private boolean valueInRange(final String incoming) {
    Long value;
    for(WrappedRange<Long> wrappedRange : wrappedRangeSet) {
        try {
            value = Long.valueOf(incoming, wrappedRange.getBase());
        } catch (NumberFormatException nfe) {
            continue; // not worried if wrong format...
        }
        if (wrappedRange.contains(value)) {
            return true;
        }
     }
     return false;
}


WrappedRange看起来像:

class WrappedRange<C Extends Comparable> {
    private final int base;
    private final Range<C> range;

    public WrappedRange(final Range<C> range, final int base) {
        this.range = range;
        this.base = base;
    }

    public boolean contains(final C value) {
         return range.contains(value);
    }

    public int getBase() {
         return int base;
    }
}


我至少要摆脱WrappedRange.getBase()方法,并将转换从String转换为所需的类型,并将其移到WrappedRange类中。然后可以将contains(String)方法添加到WrappedRange类。 valueInRange方法中的循环简化为:

for(WrappedRange<Long> wrappedRange : wrappedRangeSet) {
    if (wrappedRange.contains(value)) {
        return true;
    }
 }


我遇到的问题是,我已经假设要比较的值是Long,而不是Comparable的任何扩展。我可以只将WrappedRange修复为使用Longs,但随后不能将该类用于其他Comparables。

理想情况下,我想将字符串转换为WrappedRange类,因为将来有可能将Comparable的其他扩展名用于包含函数的输入。该类如下所示:

class WrappedRange<C Extends Comparable> {
    private final int base;
    private final Range<C> range;

    public WrappedRange(final Range<C> range, final int base) {
        this.range = range;
        this.base = base;
    }

    public boolean contains(final C value) {
         return range.contains(value);
     }

    public boolean contains(final String incoming) {
         C value = convert(incoming);
         return range.contains(value);
     }

    private convert(final String incoming) {
         // ... convert to type C and return.
    }
}


有没有简单的方法可以做到这一点?可能吗

最佳答案

如果输入将始终是字符串,并且内部结构将始终是范围,那么为什么不这样做呢?

public abstract class WrappedRange<C extends Comparable> {
  private final Range<C> range;

  protected WrappedRange(Range<C> range) {
    this.range = range;
  }

  public boolean contains(String incoming) {
    try {
      C value = convert(incoming);
    } catch (Exception ex) {
      return false;
    }
    return range.contains(value);
  }

  protected abstract C convert(String incoming);
}

class WrappedLongRange extends WrappedRange<Long> {
  private final int base;

  WrappedLongRange(Range<Long> range, int base) {
    super(range);
    this.base = base;
  }

  @Override
  protected Long convert(String incoming) {
    return Long.valueOf(incoming, base);
  }
}

10-04 12:23