Question

我有一组初始数据，可以有两种不同的格式需要匹配。条目将是完全匹配或提供范围。范围值将是十进制格式的整数 - 但要匹配的数据可以是十六进制和十进制。基数将在初始数据中指示。因此，初始数据将类似于以下内容（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，但是我不能将该类用于其他可比对象。

理想情况下，我想限制Strings到WrappedRange类的转换，因为Comparable的其他扩展可能会用于将来对contains函数的输入。该课程类似于以下内容：

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.
    }
}

有一种简单的方法吗？它甚至可能吗？

Answer 1

如果输入始终是一个字符串，并且内部结构总是一个范围，为什么不做这样的事情呢？

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);
  }
}

如何在Java中将字符串转换为不同的类？

1 个答案: